Mech - User contributions [en]

Music from the Heart -- Music Suit

2010-03-17T09:10:51Z

EricWest:

=Introduction=

This project attempted to create a natural form of musical expression by connecting sensors to the body. Six tilt switches were attached to the wrist, ankles, and shoulders, each controlling a single pitch from the [http://en.wikipedia.org/wiki/Pentatonic_scale pentatonic scale]. The heart beat was obtained using [http://en.wikipedia.org/wiki/Photoplethysmograph photoplethysmography] on the user's finger, and this signal was used to strike a drum in sync with the heart beat.

For a video demonstration, click [http://www.youtube.com/watch?v=YyipByy7m6I here].

{{multiple image
| width1 = 150
| width2 = 269
| align = center
| header = Music from the Heart Project
| image1 = Music from the heart overview.jpg
| caption1 = The full "music suit" on James, with heart rate sensor on his finger.
| image2 = Drum overview mfth.jpg
| caption2 = A closer view of the drum mechanism
}}

 

==Team Members==

[[Image:Mfth team picture.JPG|thumb|200px|From left: Thomas, Eric, James]]

*Thomas Peterson (Computer Engineering, 2010)
*James Rein (Biomedical Engineering and Music Cognition, 2010)
*Eric West (Mechanical Engineering, 2011)

=Subsystems=

Although intended as a single, cohesive system that would allow the user to intuitively make music, the project was easily divided into three subsystems: heart rate monitor, drum actuation, and music tones. Below is more explanation about each subsystem.

==Heart rate monitor - Concepts==

In brainstorming how to translate a heart beat into a drum beat, we decided that the least intrusive method would be the best. Attaching electrodes to the user would simplify the process of identifying a heart beat, but attaching the sensors directly to the skin would be a time-consuming and personally-invasive process. Instead, we decided a finger tip sensor would be much more comfortable and easy to use.

To make a finger tip sensor, we used the concepts of [http://en.wikipedia.org/wiki/Photoplethysmograph photoplethysmography]. Photoplethysmography is typically used in [http://en.wikipedia.org/wiki/Pulse_oximeter pulse oximeters] and finger-tip sensors in commercially-available devices. We originally tried to hack a heart rate monitor that we had purchased, but this proved difficult, so we decided to make our own.

The basic concept of photoplethysmography is that blood reflects a certain amount of IR light, and the blood density in the finger changes as the heart pumps, so the IR reflectivity of the finger changes as the heart beats. Using an IR emitter-detector pair found in the mechatronics lab followed by lots of amplification and filtering, we were able to obtain a decent signal with peaks when the user's heart beat.

===Heart rate monitor - Electrical Design===

The signal coming directly out of the IR detector was very weak and noisy. To obtain just the information we desired, we ran it through the following filters and amplifiers:

# [[Passive Filters#High-Pass Filter (HPF)|Passive High-Pass Filter]]
# [[Operational Amplifiers (Op-Amps)#Inverting Amplifier|Inverting Amplifier]]: gain = -470
# [http://en.wikipedia.org/wiki/Low-pass_filter#Active_electronic_realization Active Low-pass filter]: cutoff frequency = 4.82Hz, gain = -70
# [http://www.electronics-tutorials.ws/filter/filter_7.html Band-pass filter]: Frequency range = 0.72 to 3.39Hz, inverting gain = -46.8
# [[Comparators|Comparator]]: output to the PIC pin A14, with pull-up resistor to 3.3V and capacitors to smooth out the signal.

The complete signal processing circuit is shown below.

[[Image:Heartrate monitor.PNG|thumb|center|900px|Heart rate monitor circuit diagram. Click for larger image.]]

===Heart rate monitor - Mechanical Design===

[[Image:Heart rate sensor mfth.JPG|thumb|200px|Heart rate sensor with the latex band pulled away so that the emitter-detector is revealed]]
The sensor itself was a QRB1114 emitter-detector pair that was encased in open-cell foam insulation. We inserted it into the foam by drilling and filing a hole in the foam to the appropriate size, and gluing the sensor in place. A round, finger-shaped groove was filed into the foam and the sensor sat flush with the bottom of this groove. The user's finger was held in the correct position with relatively constant pressure using a latex band around the finger and the foam enclosure.

==Drum actuator - Electrical design==

Once the signal from the heart rate sensor is sent to the PIC, the rising edge triggers an interrupt which starts the driving sequence for the motor that strikes the drum. The drive sequence was: drive down (into drum) 100ms, drive up 75ms, wait 150ms. The interrupt does not do the entire driving sequence, it merely flags a variable to start the sequence, which is done in the main loop, as seen in the code below.

An additional interrupt was triggered by the falling edge of the signal; this falling edge interrupt added additional wait time that prevented the PIC from being "fooled" by a noisy falling edge. For instance, if the falling signal had some noise in it, the rising edge interrupt would be triggered again, thus causing the drum to strike on both the rising and falling edges of the heartbeat. We only wanted one strike per heartbeat, so the falling edge interrupt was triggered by the ''first'' falling edge, and any noise in the falling edge was ignored because the PIC was told to wait for 300ms. With a maximum delay of 150 + 300 = 450ms from the two interrupts, and 100 + 75 = 175ms of drive time, the fastest heartbeat our drum could play was 96 beats per minute, but we did not expect anyone to come play the instrument after running, so this was plenty high for our purposes. '''IS MY MATH CORRECT?? SEEMS SLOW TO ME, BUT I GUESS WE HAD TO DO WHAT WE HAD TO DO'''

Initially, we tried skipping the comparator and sending the analog signal directly into one of the PICs analog inputs. Our intention was to use the fast Fourier transform (FFT) library to try to extract the dominant frequency (see [[PIC32MX: FFT of Analog Input]] for more information). Unfortunately, we ran into various problems. First, to get the accuracy we wanted for small frequencies, the sample window had to be very long (10 seconds or more), which made the output lag changes in heart rate. Additionally, the FFT was often "messy", which messed up our original algorithm of detecting the peak frequency between .5 and 2.5 hz. The system would sometimes randomly switch between very different frequencies, and although it was right most of the time it was enough to make the drum beating sound bad. We also tried algorithms to find the [http://en.wikipedia.org/wiki/Fundamental_frequency fundamental frequency] using the entire FFT (instead of just the .5-2.5 hz range), but this was still unreliable. We considered FFT peak detection algorithms, but they seemed to complex for the time and computing power we had available. Because of all this, we went with the simple comparator in the end.

The motor for driving the drumstick was driven by an [[media:L298N.pdf|L298 H-bridge]]. See [[Driving a high current DC Motor using an H-bridge]] for more information on how this works. Our particular circuit diagram is shown below:

[[Image:T21_motorckt_png.PNG|thumb|center|600px|Motor Circuit (non-motor PIC connections not shown). Click for larger image.]]

====Drum actuator - Mechanical Design====

[[Image:Drum stick mount mfth.jpg|thumb|200px|Attachment for the drumstick to the motor shaft. Split-clamp to the motor shaft on the left, drum stick on the right|right]]
We wanted to use a real drum for our drum beat, so our challenge was to attach a motor and drumstick to a drum. We chose a small rack tom for its resonant tone that is reminiscent of a heart beat.

To attach the drumstick to the motor shaft, we used a small block of acrylic (.5"x.75"x2"). The drumstick was cut down to 8" in length so that it would require less torque from the motor. In one end of the block, a hole was drilled and the drumstick was sanded to the correct diameter in order to snuggly fit into the hole. To ensure that the drumstick could not slide out of the block, a screw was placed in a hole drilled through both the stick and the block. The other end of the block was attached to the motor shaft using a split-clamp method: A hole the size of the motor shaft was drilled through the block, and then a slit was cut from the end of the block to the hole, allowing a screw to tightly clamp the block around the motor.

[[Image:Motor mount mfth.jpg|thumb|200px|Mounting bracket for the motor-stick assembly.|right]]
To attach the motor-stick assembly to the drum, we utilized the tuning screws on the drum and holes in the face of the motor. A sheet metal bracket with holes in the appropriate places attached the motor to two of the tuning screws. The bracket was easily made by cutting and bending a piece of 16 gauge steel sheet metal to the appropriate size. Ideally, this part would have been made out of one continuous piece of sheet metal, but we could not find a large enough sheet available in the shop, so we used rivets to connect two smaller pieces together.

After testing the drum striking, we decided it was too loud. To dampen the sound, we taped a piece of foam core and a shop rag to the head of the drum where the stick strikes it.

'''Parts list for drum actuator'''
*Bargain drumstick, at least .5" in diameter
*Small block of acrylic, .5"x.75"x2" (aluminum would work just as well, this is what was available)
*16 gauge steel sheet metal for bracket
*2 pop rivets
*Screws and nuts
*Foam core, shop rag, tape for dampening

==Music Tones - Electrical Design==
The music tones were activated by tilt switches and generated using a [http://pdf1.alldatasheet.com/datasheet-pdf/view/82065/YAMAHA/YMZ284.html YMZ284] chip and were output through a 1/8" jack to a standard set of computer speakers.

Each YMZ284 is capable of producing and mixing any combination of three tones. Since we wanted to have six notes from a [http://en.wikipedia.org/wiki/Pentatonic_scale pentatonic scale], we needed two of these chips and used an [[Operational Amplifiers (Op-Amps)#Summer|summing opamp circuit]] to combine outputs from each chip. We envisioned a possibility of adding [http://en.wikipedia.org/wiki/Overtone overtones] to each note, to make them sound better and more like a real instrument, so we ended up having four YMZ284s attached to our board. When we tried adding an overtone an octave above the fundamental frequency, it ended up sounding harsh and whiny. We decided the tones sounded better with no overtones, so we are only using 2 of the 4 chips on our board.

The YMZ284 communicates with the PIC over an 8-bit databus, plus additional pins for chip select, address, write enable, and reset. All four of our YMZ284s shared all of their pins ''except'' the chip select line; each required their own individual chip select line so that the PIC could specify with which chips it wanted to talk. The circuit diagram below shows how the chips were connected to the PIC and the summing circuit that followed.

{{multiple image
| align = center
| width = 500
| image1 = T21_musicckt_png.PNG
| caption1 = Music circuit diagram. The summing amplifier is not shown.
| image2 = Solder board mfth.jpg
| alt2 = Red cartouche
| caption2 = Music chips are in the center of the board. H-bridge for motor driving is on the far right, along with the power supply plug. The left side is an unsuccessful attempt at moving the heart rate circuitry to the solder board
}}

===Tilt switches - Electrical Design===
In order to detect when the limbs of the user had moved past a certain critical angle, we chose to use tilt switches. We purchased our tilt switches for $2 each from [http://www.goldmine-elec-products.com/prodinfo.asp?number=G16881 Electronics Goldmine]. We chose to use tilt switches instead of an accelerometer because the switches were much cheaper and we figured they would be easier to work with.

The tilt switches we chose are optically-based with an emitter and detector that are selectively blocked by a small ball. When the critical angle is achieved, the tiny ball rolls up a ramp, allowing the emitter to shine directly on the detector, and current flows. When the angle is neutral, the ramp forces the ball to block the light, making current stop flowing through the phototransistor. The "ramp" is really an inverted cone, so the switch can be activated by a change in angle in any direction away from the neutral position. We purchased three different tilt switches to try, each with a different critical angle - 15, 30, and 45 degrees. The configuration we ended up using was:

*30 degrees for shoulders and ankles
*45 degrees for elbows

In hindsight, we would have used all 45-degree switches because they produced the sharpest jump from off to on. The 15-degree switches were practically unusable because they created a large amount of noise as they switched on and off.

We used the tilt switches to provide high-low inputs to the PIC to tell it when to turn on any of the six tones. By attaching these switches to the body such that they are in the neutral position when the body is relaxed, we were able to control the six tones by moving the body in relatively natural ways.

===Tilt switches - Mechanical Design===

[[Image:Wrist sensor mfth.JPG|thumb|200px|Wrist tilt sensor. Ankles are similar, with a larger strap.]]
The switches were attached to the user's body using adjustable straps and buckles. The wrist and ankle sensors were simply a loop of webbing with an adjustable buckle attached. The straps could be tightened or loosened to fit any size user. To attach the switch to the straps, we created an enclosure for each switch out of high-density foam (left over scraps from DSGN 307). The switch was jammed into a hole in the foam so that it could not easily be moved. The foam was then taped to the straps using electrical tape.

The shoulder straps were a bit more involved. Two loops with buckles, similar to the wrist and ankle straps, went over the user's shoulder and underneath their armpit. To keep these straps from sliding off the shoulders, a large strap across the user's back connected the two smaller straps together. This large strap was also used for mounting the solder board which gathered the wires from all six tilt switches and sent them to the PIC over one ribbon cable. Using this strap configuration, we found that the user could comfortably and securely wear the sensors.

[[Image:Shoulder sensors mfth.JPG|thumb|200px|Shoulder straps containing the tilt sensors.]]
To attach the switches to the shoulders, we again created a foam encasement. However, electrical tape was not secure enough to hold the foam pieces to the irregularly-shaped shoulder straps. Instead, we riveted a piece of canvas to the webbing straps. We chose to use rivets instead of sewing because the sewing machine could not tightly sew the foam encasement in place. With rivets, we were able to pull the canvas tightly around the foam so that it couldn't move.

=Code=
To download the entire C file, click [[Media:Main_music.c|here]]. Below, the file is split into sections for comments.

/**********************************************************
* main_music.c: Main c file for "Music Suit" project
*
* Thomas Peterson, James Rein, Eric West
* ME333 Winter 2010
**********************************************************/

#include <HardwareProfile.h>
#include <delays.c> //Delayms and Delayus functions

The first section defines all the input and output pins, used with the motor, sensor, and music circuits.

////////////////////////////////////////////////////
//Pin Defines

//YMZ Chip selects
#define CS1 LATCbits.LATC2
#define CS2 LATCbits.LATC3
#define CS3 LATCbits.LATC4
#define CS4 LATGbits.LATG6
//YMZ communication pins
#define NWR LATBbits.LATB0 //"Not WRite": active low write line
#define A0 LATBbits.LATB6 //Address 0
#define NIC LATCbits.LATC1 //"Not Input Clear": active low reset line
//YMZ data pins
#define D0 LATGbits.LATG9
#define D1 LATEbits.LATE8
#define D2 LATEbits.LATE9
#define D3 LATBbits.LATB5
#define D4 LATBbits.LATB4
#define D5 LATBbits.LATB3
#define D6 LATBbits.LATB2
#define D7 LATBbits.LATB1

//Tilt inputs
#define ENC PORTDbits.RD3
#define END PORTDbits.RD2
#define ENE PORTDbits.RD1
#define ENG PORTCbits.RC14
#define ENA PORTCbits.RC13
#define ENC5 PORTDbits.RD0

//Motor outputs
#define IN1 LATBbits.LATB7
#define IN2 LATAbits.LATA9
#define EN LATAbits.LATA10

///////////////////////////////////////
//Other defines
//Motor times
#define MS(x) x*312.5
#define DRIVETIME MS(100)
#define BACKTIME MS(75)
#define WAITTIME MS(150)
//Channels
#define CHNA 1
#define CHNB 2
#define CHNC 4

//////////////////////////////////////////
//Function definitions
void write_chip(int address, int data);
void portout(int byte);
void channelSw(int chip, int chn, int *mixer, int state);
//Global variables
int mixer1, mixer2;
int motorflag = 0;
The initialization function sets up various parts of the system.
/* init() : This function runs initializations, setting up the pic and music chips */
void init() {
int pbClk = SYSTEMConfigPerformance(SYS_FREQ);

/////////////////////////////////////////////
//Setup inputs / outputs
AD1PCFG = 0xFFFF; //All digital inputs
TRISG &= 0xFDBF; //sets G9,G6 to 0 (output); all else remains the same
TRISC &= 0xFFE1; //sets C4,C3,C2,C1 to 0s (outputs); all else remains the same
TRISB &= 0xFF80; //sets B0-B6 0 (output)
TRISE &= 0xFCFF; //sets E8,9 to output
TRISB |= 0xF000; //sets B12,B13,B14,B15 to 1s (inputs); all else remains the same
TRISC |= 0x6000; //sets C14,13 to inputs
TRISD |= 0x000F; //Sets D0,D1,D2,D3 to inputs
TRISDbits.TRISD4 = 0; //Output for clock
//Motor outputs
TRISAbits.TRISA9 = 0;
TRISAbits.TRISA10 = 0;
TRISBbits.TRISB7 = 0;
//Pulse inputs
TRISAbits.TRISA14 = 1;
TRISAbits.TRISA15 = 1;
//ODC setup
ODCCbits.ODCC1 = 1; //open drain control; can only float high (when set high) or pull low

/* Initialize outputs */
//YMZs
CS1 = 1;
CS2 = 1;
CS3 = 1;
CS4 = 1;
NWR = 1;
A0 = 0;
NIC = 1;
//Motor
IN2 = 0;
IN1 = 0;
EN = 0;

Delayms(100); //wait for power supply to ramp up
NIC = 0; //resets YMZ284s
Delayms(10);
NIC = 1;

In the init() function, the pic writes all the setup data to the music chips. This includes the frequency registers, which determine the frequency of each output, the mixer, which determines which channels are on or off (1 = off), and the volume registers, which determine the volume of each channel. After the setup, the only register that is changed in normal operation is the mixer register, which merely turns channels on and off.
//////////////////////////////////////////////////
//Setup music chips
//Setup Chip 1//
CS1 = 0;
write_chip(0x00,0xC7); //a low // C4
write_chip(0x01,0x01); //a high
write_chip(0x02,0x98); //b low // D
write_chip(0x03,0x01); //b high
write_chip(0x04,0x6E); //c low
write_chip(0x05,0x01); //c high // E
write_chip(0x07,0xFF); //mixer (0 enables)
write_chip(0x08, 0x0A); //level (volume) A
write_chip(0x09, 0x0A); //level (volume) B
write_chip(0x0A, 0x0A); //level (volume) C
CS1=1;
//Setup Chip 2//
CS2 = 0;
write_chip(0x00,0x2C); //a low //G 392
write_chip(0x01,0x01); //a high
write_chip(0x02,0x0D); //b low //A 440
write_chip(0x03,0x01); //b high
write_chip(0x04,0xE3); //c low //C5 523.25
write_chip(0x05,0x00); //c high
write_chip(0x07,0xFF); //mixer (0 enables)
write_chip(0x08, 0x0A); //level (volume) A
write_chip(0x09, 0x0A); //level (volume) B
write_chip(0x0A, 0x0A); //level (volume) C
CS2=1;

mixer1=0xFF;
mixer2=0xFF;
OC5 is used to create a PWM signal with 50% duty at 4Mhz, in effect creating a 4Mhz square wave. This is used by the music chips as a master clock.
//////////////////////////////////////////////
//Setup OC to create master clock for music chips (~4 Mhz)
OpenOC5( OC_ON | OC_TIMER2_SRC | OC_PWM_FAULT_PIN_DISABLE, 0, 0);
OpenTimer2( T2_ON | T2_PS_1_1 | T2_SOURCE_INT, 20);
SetDCOC5PWM(10);
The interrupts are used, as mentioned above, to control when the motor is driven. The motor should drive once every rising edge.
/////////////////////////////////////////////
//External interrupt setups (for motor) - INT3 (A14)
mINT3ClearIntFlag();
mINT3IntEnable(1);
mINT3SetIntPriority(6);
mINT3SetEdgeMode(1); //Rising edge
/////////////////////////////////////////////
//External interrupt setups (for motor) - INT4 (A15)
mINT4ClearIntFlag();
mINT4IntEnable(1);
mINT4SetIntPriority(5);
mINT4SetEdgeMode(0); //Falling edge
INTEnableSystemMultiVectoredInt();

/////////////////////////////////////////////
//Setup motor timer (used for timing delays)
OpenTimer3(T3_ON | T3_PS_1_256 | T3_SOURCE_INT, 0xFFFF);
ConfigIntTimer3(T3_INT_OFF);
}

Main function
/* Main function */
int main()
{
init(); /* Run initialization functions */
Delayms(1);

/* Main while loop: loop indefinietly */
while (1) {
In the main while loop, the PIC checks every cycle to see if an input has changed since the last cycle. Since the "mixer" variables store the current state, if an input does not match up with its valid mixer bit then it has changed recently. In this case, the channelSw() function is called to switch on or off the music channel controlled by that bit.
//Check for state changes in music notes
if (ENC != (mixer1 & 0x01)) { channelSw(1,CHNA,&mixer1,!ENC); } //If input ENC (enable C) is not equal to the state of channel A1 (note c), change the state
if (END != (mixer1 & 0x02)) { channelSw(1,CHNB,&mixer1,!END); }
if (ENE != (mixer1 & 0x04)) { channelSw(1,CHNC,&mixer1,!ENE); }
if (ENG != (mixer2 & 0x01)) { channelSw(2,CHNA,&mixer2,!ENG); }
if (ENA != (mixer2 & 0x02)) { channelSw(2,CHNB,&mixer2,!ENA); }
if (ENC5 != (mixer2 & 0x04)) { channelSw(2,CHNC,&mixer2,!ENC5); }
During the main while loop, the motor flag variable is checked to see if the motor should be driven. If so, it enters a sequence where it uses timer3 to determine the current stage in the motor cycle, changing the outputs as needed.
//Check for motor state changes
switch (motorflag) {
case 0: break; //Do nothing (motor off)
case 1: //Start motor cycle
WriteTimer3(0); //Reset timer to 0
IN1 = 0; //Set H bridge to forward drive
IN2 = 1;
EN = 1;
motorflag = 2; //In drivedown cycle
break;
case 2: //Drivedown cycle
if (ReadTimer3() > DRIVETIME) { //Wait for DRIVETIME to pass
WriteTimer3(0); //Reset timer to 0
motorflag = 3; //In driveup phase
IN2 = 0; //Switch H bridge
IN1 = 1;
}
break;
case 3: //Driveup cycle
if (ReadTimer3() > BACKTIME) { //Wait for BACKTIME to pass
WriteTimer3(0); //Reset timer to 0
motorflag = 4; //In coast/wait phase
EN = 0; //Turn off motor
}
break;
case 4: //coast / wait cycle
if (ReadTimer3() > WAITTIME) {
motorflag = 5; //more wait
WriteTimer3(0);
}
break;
case 5: //Additional wait cycle
if (ReadTimer3() > WAITTIME) {
//Done!
motorflag = 0; //Motor off (can now be triggered again)
}
break;
//Static wait cycles
case 6:
if (ReadTimer3() > WAITTIME) {
motorflag = 7;
WriteTimer3(0);
}
break;
case 7:
if (ReadTimer3() > WAITTIME) {
WriteTimer3(0);
motorflag = 8;
}
break;
case 8:
if (ReadTimer3() > WAITTIME) {
motorflag = 0;
}
break;
}

Delayms(10);
}
return 0;
}//end main

Write chip function, which is a support function that writes data to the music chips.
/* write_chip: This writes the given byte "data" to the "address" (0 or 1)
on a YMZ284. It is assumed that the chip select is already low */
void write_chip(int address,int data) {
//Write address
portout(address);
A0 = 0; //select address mode
Delayus(1); //setup time
NWR = 0; //Write cycle begin
Delayus(1); //hold time
NWR = 1; //Write cycle end

//Write data
portout(data);
A0 = 1; //select data mode
Delayus(1); //setup time
NWR = 0; //write cycle begin
Delayus(1); //hold time
NWR = 1; //write cycle end
}
Port out function
/* port_out: This function outputs a byte to the D0-D7 port */
void portout(int byte) {
// Note: !! converts an integer expression to a boolean (1 or 0).
D0 = !!(byte & 1);
D1 = !!(byte & 2);
D2 = !!(byte & 4);
D3 = !!(byte & 8);
D4 = !!(byte & 16);
D5 = !!(byte & 32);
D6 = !!(byte & 64);
D7 = !!(byte & 128);
}
Channel switch function, which writes a new mixer value to turn a channel on or off.
/* channelSw: Generic channel switch function
This writes a new mixer value to chip "chip". The mixer value
depends on "chn", the channel turning on or off, "state" whether
the channel is turning on or off, and "*mixer", a pointer to
the old mixer value. */
void channelSw(int chip, int chn, int *mixer, int state) {
/* Enable music chip */
switch(chip) {
case 1: CS1 = 0; break;
case 2: CS2 = 0; break;
case 3: CS3 = 0; break;
case 4: CS4 = 0; break;
}
/* Write mixer value */
/* This writes to channel 7 (mixer channel) the _new_ mixer value, which is
the old mixer value with a particular bit flipped based on "chn" and "state" */
write_chip(0x07, (*mixer) = state ? (*mixer) & (0xFF & ~chn) : (*mixer) | chn);
/* Disable chip */
switch(chip) {
case 1: CS1 = 1; break;
case 2: CS2 = 1; break;
case 3: CS3 = 1; break;
case 4: CS4 = 1; break;
}

}
Interrupt functions
//External interrupt for motor driving
void __ISR(_EXTERNAL_3_VECTOR, ipl6) _SingleVectorHandler(void) {
if (motorflag == 0) {
motorflag = 1; //Start motor cycle
}
//If on already, do nothing
mINT3ClearIntFlag();
}

//External interrupt for motor waiting
void __ISR(_EXTERNAL_4_VECTOR, ipl5) _SingleVectorHandler2(void) {
if (motorflag == 0) {
WriteTimer3(0);
motorflag = 6; //Start wait cycle
}
//If on already, do nothing
mINT4ClearIntFlag();
}

=Results=

The project turned out to be a mild success overall. The tilt switches worked very well for activating the music tones, but the heart rate monitor was less successful. One of the biggest issues was getting rid of very low frequency drift in the signal that made the peaks sometimes as high as 10V, but other times less 1V. Dealing with this fluctuation in peak size was the most difficult part of signal processing. As mentioned above, we tried FFT in order to establish a steady heart rate, but could not get the resolution we desired, thus we abandoned the idea.

'''PROBABLY NEED MORE TECHNICAL RESULTS HERE, BUT I'M NOT SURE WHAT TO SAY RIGHT NOW'''

The best result was that using the device was just plain fun. We each had a great time moving around and hearing the fun sounds that resulted, or if we were feeling ambitious, we would try to play a simple melody like "Mary Had a Little Lamb." It was rather difficult to play anything more complicated than that because it required lots of body control and precise movements.

=Reflections=

'''Successes'''
*tilt switches activated each of the six notes when they were supposed to
**the YMZ284 chips were able to produce all six notes at the same time, allowing cool chords
*tones were in tune and formed fun melodies and chords as the body moved
*drum actuator hit the drum reliably and with good tone
*heart rate monitor usually showed clear peaks on a scope, but was finnicky in practice

'''Room for improvements'''
*tilt switches sometimes bounced, so the beginning, or particularly the ends of the notes sounded jagged
**''Possible Solution:'' add a low pass filter to the switch signal so that the signal ramps up and down.
*the shoulder straps sometimes needed adjustments for each individual in order for the sensors to be in the correct position
**''Possible Solution:'' create straps with more constraints, such as a strap across the chest as well as the back, to ensure that the sensors are in the correct positions and orientations.
*the straps could be easier to put on
**''Possible Solution:'' maybe integrate them into a single garment, like a onesie
*the heart rate monitor was not reliable. Low frequency drift made setting a comparison level nearly impossible, especially for more than one specific user.
**''Possible Solution:'' improve FFT method so that desired resolution could be achieved in a short sample period (around 10 seconds). Or implement a complicated peak detection algorithm on the PIC.

'''JAMES SHOULD ADD SOME KIND OF HEARTWARMING CONCLUSION CUZ HE'S GOOD AT THAT STUFF'''

Music from the Heart -- Music Suit

2010-03-17T09:10:35Z

EricWest: /* Team Members */

Music from the Heart -- Music Suit

2010-03-17T09:10:15Z

EricWest: /* Team Members */

Music from the Heart -- Music Suit

2010-03-17T09:09:38Z

EricWest: /* Introduction */

=Introduction=

This project attempted to create a natural form of musical expression by connecting sensors to the body. Six tilt switches were attached to the wrist, ankles, and shoulders, each controlling a single pitch from the [http://en.wikipedia.org/wiki/Pentatonic_scale pentatonic scale]. The heart beat was obtained using [http://en.wikipedia.org/wiki/Photoplethysmograph photoplethysmography] on the user's finger, and this signal was used to strike a drum in sync with the heart beat.

For a video demonstration, click [http://www.youtube.com/watch?v=YyipByy7m6I here].

{{multiple image
| width1 = 150
| width2 = 269
| align = center
| header = Music from the Heart Project
| image1 = Music from the heart overview.jpg
| caption1 = The full "music suit" on James, with heart rate sensor on his finger.
| image2 = Drum overview mfth.jpg
| caption2 = A closer view of the drum mechanism
}}

 

==Team Members==

[[Image:Mfth team picture.JPG|thumb|200px|From left: Thomas, Eric, James]]
*Thomas Peterson (Computer Engineering, 2010)
*James Rein (Biomedical Engineering and Music Cognition, 2010)
*Eric West (Mechanical Engineering, 2011)

=Subsystems=

Although intended as a single, cohesive system that would allow the user to intuitively make music, the project was easily divided into three subsystems: heart rate monitor, drum actuation, and music tones. Below is more explanation about each subsystem.

==Heart rate monitor - Concepts==

In brainstorming how to translate a heart beat into a drum beat, we decided that the least intrusive method would be the best. Attaching electrodes to the user would simplify the process of identifying a heart beat, but attaching the sensors directly to the skin would be a time-consuming and personally-invasive process. Instead, we decided a finger tip sensor would be much more comfortable and easy to use.

To make a finger tip sensor, we used the concepts of [http://en.wikipedia.org/wiki/Photoplethysmograph photoplethysmography]. Photoplethysmography is typically used in [http://en.wikipedia.org/wiki/Pulse_oximeter pulse oximeters] and finger-tip sensors in commercially-available devices. We originally tried to hack a heart rate monitor that we had purchased, but this proved difficult, so we decided to make our own.

The basic concept of photoplethysmography is that blood reflects a certain amount of IR light, and the blood density in the finger changes as the heart pumps, so the IR reflectivity of the finger changes as the heart beats. Using an IR emitter-detector pair found in the mechatronics lab followed by lots of amplification and filtering, we were able to obtain a decent signal with peaks when the user's heart beat.

===Heart rate monitor - Electrical Design===

The signal coming directly out of the IR detector was very weak and noisy. To obtain just the information we desired, we ran it through the following filters and amplifiers:

# [[Passive Filters#High-Pass Filter (HPF)|Passive High-Pass Filter]]
# [[Operational Amplifiers (Op-Amps)#Inverting Amplifier|Inverting Amplifier]]: gain = -470
# [http://en.wikipedia.org/wiki/Low-pass_filter#Active_electronic_realization Active Low-pass filter]: cutoff frequency = 4.82Hz, gain = -70
# [http://www.electronics-tutorials.ws/filter/filter_7.html Band-pass filter]: Frequency range = 0.72 to 3.39Hz, inverting gain = -46.8
# [[Comparators|Comparator]]: output to the PIC pin A14, with pull-up resistor to 3.3V and capacitors to smooth out the signal.

The complete signal processing circuit is shown below.

[[Image:Heartrate monitor.PNG|thumb|center|900px|Heart rate monitor circuit diagram. Click for larger image.]]

===Heart rate monitor - Mechanical Design===

[[Image:Heart rate sensor mfth.JPG|thumb|200px|Heart rate sensor with the latex band pulled away so that the emitter-detector is revealed]]
The sensor itself was a QRB1114 emitter-detector pair that was encased in open-cell foam insulation. We inserted it into the foam by drilling and filing a hole in the foam to the appropriate size, and gluing the sensor in place. A round, finger-shaped groove was filed into the foam and the sensor sat flush with the bottom of this groove. The user's finger was held in the correct position with relatively constant pressure using a latex band around the finger and the foam enclosure.

==Drum actuator - Electrical design==

Once the signal from the heart rate sensor is sent to the PIC, the rising edge triggers an interrupt which starts the driving sequence for the motor that strikes the drum. The drive sequence was: drive down (into drum) 100ms, drive up 75ms, wait 150ms. The interrupt does not do the entire driving sequence, it merely flags a variable to start the sequence, which is done in the main loop, as seen in the code below.

An additional interrupt was triggered by the falling edge of the signal; this falling edge interrupt added additional wait time that prevented the PIC from being "fooled" by a noisy falling edge. For instance, if the falling signal had some noise in it, the rising edge interrupt would be triggered again, thus causing the drum to strike on both the rising and falling edges of the heartbeat. We only wanted one strike per heartbeat, so the falling edge interrupt was triggered by the ''first'' falling edge, and any noise in the falling edge was ignored because the PIC was told to wait for 300ms. With a maximum delay of 150 + 300 = 450ms from the two interrupts, and 100 + 75 = 175ms of drive time, the fastest heartbeat our drum could play was 96 beats per minute, but we did not expect anyone to come play the instrument after running, so this was plenty high for our purposes. '''IS MY MATH CORRECT?? SEEMS SLOW TO ME, BUT I GUESS WE HAD TO DO WHAT WE HAD TO DO'''

Initially, we tried skipping the comparator and sending the analog signal directly into one of the PICs analog inputs. Our intention was to use the fast Fourier transform (FFT) library to try to extract the dominant frequency (see [[PIC32MX: FFT of Analog Input]] for more information). Unfortunately, we ran into various problems. First, to get the accuracy we wanted for small frequencies, the sample window had to be very long (10 seconds or more), which made the output lag changes in heart rate. Additionally, the FFT was often "messy", which messed up our original algorithm of detecting the peak frequency between .5 and 2.5 hz. The system would sometimes randomly switch between very different frequencies, and although it was right most of the time it was enough to make the drum beating sound bad. We also tried algorithms to find the [http://en.wikipedia.org/wiki/Fundamental_frequency fundamental frequency] using the entire FFT (instead of just the .5-2.5 hz range), but this was still unreliable. We considered FFT peak detection algorithms, but they seemed to complex for the time and computing power we had available. Because of all this, we went with the simple comparator in the end.

The motor for driving the drumstick was driven by an [[media:L298N.pdf|L298 H-bridge]]. See [[Driving a high current DC Motor using an H-bridge]] for more information on how this works. Our particular circuit diagram is shown below:

[[Image:T21_motorckt_png.PNG|thumb|center|600px|Motor Circuit (non-motor PIC connections not shown). Click for larger image.]]

====Drum actuator - Mechanical Design====

[[Image:Drum stick mount mfth.jpg|thumb|200px|Attachment for the drumstick to the motor shaft. Split-clamp to the motor shaft on the left, drum stick on the right|right]]
We wanted to use a real drum for our drum beat, so our challenge was to attach a motor and drumstick to a drum. We chose a small rack tom for its resonant tone that is reminiscent of a heart beat.

To attach the drumstick to the motor shaft, we used a small block of acrylic (.5"x.75"x2"). The drumstick was cut down to 8" in length so that it would require less torque from the motor. In one end of the block, a hole was drilled and the drumstick was sanded to the correct diameter in order to snuggly fit into the hole. To ensure that the drumstick could not slide out of the block, a screw was placed in a hole drilled through both the stick and the block. The other end of the block was attached to the motor shaft using a split-clamp method: A hole the size of the motor shaft was drilled through the block, and then a slit was cut from the end of the block to the hole, allowing a screw to tightly clamp the block around the motor.

[[Image:Motor mount mfth.jpg|thumb|200px|Mounting bracket for the motor-stick assembly.|right]]
To attach the motor-stick assembly to the drum, we utilized the tuning screws on the drum and holes in the face of the motor. A sheet metal bracket with holes in the appropriate places attached the motor to two of the tuning screws. The bracket was easily made by cutting and bending a piece of 16 gauge steel sheet metal to the appropriate size. Ideally, this part would have been made out of one continuous piece of sheet metal, but we could not find a large enough sheet available in the shop, so we used rivets to connect two smaller pieces together.

After testing the drum striking, we decided it was too loud. To dampen the sound, we taped a piece of foam core and a shop rag to the head of the drum where the stick strikes it.

'''Parts list for drum actuator'''
*Bargain drumstick, at least .5" in diameter
*Small block of acrylic, .5"x.75"x2" (aluminum would work just as well, this is what was available)
*16 gauge steel sheet metal for bracket
*2 pop rivets
*Screws and nuts
*Foam core, shop rag, tape for dampening

==Music Tones - Electrical Design==
The music tones were activated by tilt switches and generated using a [http://pdf1.alldatasheet.com/datasheet-pdf/view/82065/YAMAHA/YMZ284.html YMZ284] chip and were output through a 1/8" jack to a standard set of computer speakers.

Each YMZ284 is capable of producing and mixing any combination of three tones. Since we wanted to have six notes from a [http://en.wikipedia.org/wiki/Pentatonic_scale pentatonic scale], we needed two of these chips and used an [[Operational Amplifiers (Op-Amps)#Summer|summing opamp circuit]] to combine outputs from each chip. We envisioned a possibility of adding [http://en.wikipedia.org/wiki/Overtone overtones] to each note, to make them sound better and more like a real instrument, so we ended up having four YMZ284s attached to our board. When we tried adding an overtone an octave above the fundamental frequency, it ended up sounding harsh and whiny. We decided the tones sounded better with no overtones, so we are only using 2 of the 4 chips on our board.

The YMZ284 communicates with the PIC over an 8-bit databus, plus additional pins for chip select, address, write enable, and reset. All four of our YMZ284s shared all of their pins ''except'' the chip select line; each required their own individual chip select line so that the PIC could specify with which chips it wanted to talk. The circuit diagram below shows how the chips were connected to the PIC and the summing circuit that followed.

{{multiple image
| align = center
| width = 500
| image1 = T21_musicckt_png.PNG
| caption1 = Music circuit diagram. The summing amplifier is not shown.
| image2 = Solder board mfth.jpg
| alt2 = Red cartouche
| caption2 = Music chips are in the center of the board. H-bridge for motor driving is on the far right, along with the power supply plug. The left side is an unsuccessful attempt at moving the heart rate circuitry to the solder board
}}

===Tilt switches - Electrical Design===
In order to detect when the limbs of the user had moved past a certain critical angle, we chose to use tilt switches. We purchased our tilt switches for $2 each from [http://www.goldmine-elec-products.com/prodinfo.asp?number=G16881 Electronics Goldmine]. We chose to use tilt switches instead of an accelerometer because the switches were much cheaper and we figured they would be easier to work with.

The tilt switches we chose are optically-based with an emitter and detector that are selectively blocked by a small ball. When the critical angle is achieved, the tiny ball rolls up a ramp, allowing the emitter to shine directly on the detector, and current flows. When the angle is neutral, the ramp forces the ball to block the light, making current stop flowing through the phototransistor. The "ramp" is really an inverted cone, so the switch can be activated by a change in angle in any direction away from the neutral position. We purchased three different tilt switches to try, each with a different critical angle - 15, 30, and 45 degrees. The configuration we ended up using was:

*30 degrees for shoulders and ankles
*45 degrees for elbows

In hindsight, we would have used all 45-degree switches because they produced the sharpest jump from off to on. The 15-degree switches were practically unusable because they created a large amount of noise as they switched on and off.

We used the tilt switches to provide high-low inputs to the PIC to tell it when to turn on any of the six tones. By attaching these switches to the body such that they are in the neutral position when the body is relaxed, we were able to control the six tones by moving the body in relatively natural ways.

===Tilt switches - Mechanical Design===

[[Image:Wrist sensor mfth.JPG|thumb|200px|Wrist tilt sensor. Ankles are similar, with a larger strap.]]
The switches were attached to the user's body using adjustable straps and buckles. The wrist and ankle sensors were simply a loop of webbing with an adjustable buckle attached. The straps could be tightened or loosened to fit any size user. To attach the switch to the straps, we created an enclosure for each switch out of high-density foam (left over scraps from DSGN 307). The switch was jammed into a hole in the foam so that it could not easily be moved. The foam was then taped to the straps using electrical tape.

The shoulder straps were a bit more involved. Two loops with buckles, similar to the wrist and ankle straps, went over the user's shoulder and underneath their armpit. To keep these straps from sliding off the shoulders, a large strap across the user's back connected the two smaller straps together. This large strap was also used for mounting the solder board which gathered the wires from all six tilt switches and sent them to the PIC over one ribbon cable. Using this strap configuration, we found that the user could comfortably and securely wear the sensors.

[[Image:Shoulder sensors mfth.JPG|thumb|200px|Shoulder straps containing the tilt sensors.]]
To attach the switches to the shoulders, we again created a foam encasement. However, electrical tape was not secure enough to hold the foam pieces to the irregularly-shaped shoulder straps. Instead, we riveted a piece of canvas to the webbing straps. We chose to use rivets instead of sewing because the sewing machine could not tightly sew the foam encasement in place. With rivets, we were able to pull the canvas tightly around the foam so that it couldn't move.

=Code=
To download the entire C file, click [[Media:Main_music.c|here]]. Below, the file is split into sections for comments.

/**********************************************************
* main_music.c: Main c file for "Music Suit" project
*
* Thomas Peterson, James Rein, Eric West
* ME333 Winter 2010
**********************************************************/

#include <HardwareProfile.h>
#include <delays.c> //Delayms and Delayus functions

The first section defines all the input and output pins, used with the motor, sensor, and music circuits.

////////////////////////////////////////////////////
//Pin Defines

//YMZ Chip selects
#define CS1 LATCbits.LATC2
#define CS2 LATCbits.LATC3
#define CS3 LATCbits.LATC4
#define CS4 LATGbits.LATG6
//YMZ communication pins
#define NWR LATBbits.LATB0 //"Not WRite": active low write line
#define A0 LATBbits.LATB6 //Address 0
#define NIC LATCbits.LATC1 //"Not Input Clear": active low reset line
//YMZ data pins
#define D0 LATGbits.LATG9
#define D1 LATEbits.LATE8
#define D2 LATEbits.LATE9
#define D3 LATBbits.LATB5
#define D4 LATBbits.LATB4
#define D5 LATBbits.LATB3
#define D6 LATBbits.LATB2
#define D7 LATBbits.LATB1

//Tilt inputs
#define ENC PORTDbits.RD3
#define END PORTDbits.RD2
#define ENE PORTDbits.RD1
#define ENG PORTCbits.RC14
#define ENA PORTCbits.RC13
#define ENC5 PORTDbits.RD0

//Motor outputs
#define IN1 LATBbits.LATB7
#define IN2 LATAbits.LATA9
#define EN LATAbits.LATA10

///////////////////////////////////////
//Other defines
//Motor times
#define MS(x) x*312.5
#define DRIVETIME MS(100)
#define BACKTIME MS(75)
#define WAITTIME MS(150)
//Channels
#define CHNA 1
#define CHNB 2
#define CHNC 4

//////////////////////////////////////////
//Function definitions
void write_chip(int address, int data);
void portout(int byte);
void channelSw(int chip, int chn, int *mixer, int state);
//Global variables
int mixer1, mixer2;
int motorflag = 0;
The initialization function sets up various parts of the system.
/* init() : This function runs initializations, setting up the pic and music chips */
void init() {
int pbClk = SYSTEMConfigPerformance(SYS_FREQ);

/////////////////////////////////////////////
//Setup inputs / outputs
AD1PCFG = 0xFFFF; //All digital inputs
TRISG &= 0xFDBF; //sets G9,G6 to 0 (output); all else remains the same
TRISC &= 0xFFE1; //sets C4,C3,C2,C1 to 0s (outputs); all else remains the same
TRISB &= 0xFF80; //sets B0-B6 0 (output)
TRISE &= 0xFCFF; //sets E8,9 to output
TRISB |= 0xF000; //sets B12,B13,B14,B15 to 1s (inputs); all else remains the same
TRISC |= 0x6000; //sets C14,13 to inputs
TRISD |= 0x000F; //Sets D0,D1,D2,D3 to inputs
TRISDbits.TRISD4 = 0; //Output for clock
//Motor outputs
TRISAbits.TRISA9 = 0;
TRISAbits.TRISA10 = 0;
TRISBbits.TRISB7 = 0;
//Pulse inputs
TRISAbits.TRISA14 = 1;
TRISAbits.TRISA15 = 1;
//ODC setup
ODCCbits.ODCC1 = 1; //open drain control; can only float high (when set high) or pull low

/* Initialize outputs */
//YMZs
CS1 = 1;
CS2 = 1;
CS3 = 1;
CS4 = 1;
NWR = 1;
A0 = 0;
NIC = 1;
//Motor
IN2 = 0;
IN1 = 0;
EN = 0;

Delayms(100); //wait for power supply to ramp up
NIC = 0; //resets YMZ284s
Delayms(10);
NIC = 1;

In the init() function, the pic writes all the setup data to the music chips. This includes the frequency registers, which determine the frequency of each output, the mixer, which determines which channels are on or off (1 = off), and the volume registers, which determine the volume of each channel. After the setup, the only register that is changed in normal operation is the mixer register, which merely turns channels on and off.
//////////////////////////////////////////////////
//Setup music chips
//Setup Chip 1//
CS1 = 0;
write_chip(0x00,0xC7); //a low // C4
write_chip(0x01,0x01); //a high
write_chip(0x02,0x98); //b low // D
write_chip(0x03,0x01); //b high
write_chip(0x04,0x6E); //c low
write_chip(0x05,0x01); //c high // E
write_chip(0x07,0xFF); //mixer (0 enables)
write_chip(0x08, 0x0A); //level (volume) A
write_chip(0x09, 0x0A); //level (volume) B
write_chip(0x0A, 0x0A); //level (volume) C
CS1=1;
//Setup Chip 2//
CS2 = 0;
write_chip(0x00,0x2C); //a low //G 392
write_chip(0x01,0x01); //a high
write_chip(0x02,0x0D); //b low //A 440
write_chip(0x03,0x01); //b high
write_chip(0x04,0xE3); //c low //C5 523.25
write_chip(0x05,0x00); //c high
write_chip(0x07,0xFF); //mixer (0 enables)
write_chip(0x08, 0x0A); //level (volume) A
write_chip(0x09, 0x0A); //level (volume) B
write_chip(0x0A, 0x0A); //level (volume) C
CS2=1;

mixer1=0xFF;
mixer2=0xFF;
OC5 is used to create a PWM signal with 50% duty at 4Mhz, in effect creating a 4Mhz square wave. This is used by the music chips as a master clock.
//////////////////////////////////////////////
//Setup OC to create master clock for music chips (~4 Mhz)
OpenOC5( OC_ON | OC_TIMER2_SRC | OC_PWM_FAULT_PIN_DISABLE, 0, 0);
OpenTimer2( T2_ON | T2_PS_1_1 | T2_SOURCE_INT, 20);
SetDCOC5PWM(10);
The interrupts are used, as mentioned above, to control when the motor is driven. The motor should drive once every rising edge.
/////////////////////////////////////////////
//External interrupt setups (for motor) - INT3 (A14)
mINT3ClearIntFlag();
mINT3IntEnable(1);
mINT3SetIntPriority(6);
mINT3SetEdgeMode(1); //Rising edge
/////////////////////////////////////////////
//External interrupt setups (for motor) - INT4 (A15)
mINT4ClearIntFlag();
mINT4IntEnable(1);
mINT4SetIntPriority(5);
mINT4SetEdgeMode(0); //Falling edge
INTEnableSystemMultiVectoredInt();

/////////////////////////////////////////////
//Setup motor timer (used for timing delays)
OpenTimer3(T3_ON | T3_PS_1_256 | T3_SOURCE_INT, 0xFFFF);
ConfigIntTimer3(T3_INT_OFF);
}

Main function
/* Main function */
int main()
{
init(); /* Run initialization functions */
Delayms(1);

/* Main while loop: loop indefinietly */
while (1) {
In the main while loop, the PIC checks every cycle to see if an input has changed since the last cycle. Since the "mixer" variables store the current state, if an input does not match up with its valid mixer bit then it has changed recently. In this case, the channelSw() function is called to switch on or off the music channel controlled by that bit.
//Check for state changes in music notes
if (ENC != (mixer1 & 0x01)) { channelSw(1,CHNA,&mixer1,!ENC); } //If input ENC (enable C) is not equal to the state of channel A1 (note c), change the state
if (END != (mixer1 & 0x02)) { channelSw(1,CHNB,&mixer1,!END); }
if (ENE != (mixer1 & 0x04)) { channelSw(1,CHNC,&mixer1,!ENE); }
if (ENG != (mixer2 & 0x01)) { channelSw(2,CHNA,&mixer2,!ENG); }
if (ENA != (mixer2 & 0x02)) { channelSw(2,CHNB,&mixer2,!ENA); }
if (ENC5 != (mixer2 & 0x04)) { channelSw(2,CHNC,&mixer2,!ENC5); }
During the main while loop, the motor flag variable is checked to see if the motor should be driven. If so, it enters a sequence where it uses timer3 to determine the current stage in the motor cycle, changing the outputs as needed.
//Check for motor state changes
switch (motorflag) {
case 0: break; //Do nothing (motor off)
case 1: //Start motor cycle
WriteTimer3(0); //Reset timer to 0
IN1 = 0; //Set H bridge to forward drive
IN2 = 1;
EN = 1;
motorflag = 2; //In drivedown cycle
break;
case 2: //Drivedown cycle
if (ReadTimer3() > DRIVETIME) { //Wait for DRIVETIME to pass
WriteTimer3(0); //Reset timer to 0
motorflag = 3; //In driveup phase
IN2 = 0; //Switch H bridge
IN1 = 1;
}
break;
case 3: //Driveup cycle
if (ReadTimer3() > BACKTIME) { //Wait for BACKTIME to pass
WriteTimer3(0); //Reset timer to 0
motorflag = 4; //In coast/wait phase
EN = 0; //Turn off motor
}
break;
case 4: //coast / wait cycle
if (ReadTimer3() > WAITTIME) {
motorflag = 5; //more wait
WriteTimer3(0);
}
break;
case 5: //Additional wait cycle
if (ReadTimer3() > WAITTIME) {
//Done!
motorflag = 0; //Motor off (can now be triggered again)
}
break;
//Static wait cycles
case 6:
if (ReadTimer3() > WAITTIME) {
motorflag = 7;
WriteTimer3(0);
}
break;
case 7:
if (ReadTimer3() > WAITTIME) {
WriteTimer3(0);
motorflag = 8;
}
break;
case 8:
if (ReadTimer3() > WAITTIME) {
motorflag = 0;
}
break;
}

Delayms(10);
}
return 0;
}//end main

Write chip function, which is a support function that writes data to the music chips.
/* write_chip: This writes the given byte "data" to the "address" (0 or 1)
on a YMZ284. It is assumed that the chip select is already low */
void write_chip(int address,int data) {
//Write address
portout(address);
A0 = 0; //select address mode
Delayus(1); //setup time
NWR = 0; //Write cycle begin
Delayus(1); //hold time
NWR = 1; //Write cycle end

//Write data
portout(data);
A0 = 1; //select data mode
Delayus(1); //setup time
NWR = 0; //write cycle begin
Delayus(1); //hold time
NWR = 1; //write cycle end
}
Port out function
/* port_out: This function outputs a byte to the D0-D7 port */
void portout(int byte) {
// Note: !! converts an integer expression to a boolean (1 or 0).
D0 = !!(byte & 1);
D1 = !!(byte & 2);
D2 = !!(byte & 4);
D3 = !!(byte & 8);
D4 = !!(byte & 16);
D5 = !!(byte & 32);
D6 = !!(byte & 64);
D7 = !!(byte & 128);
}
Channel switch function, which writes a new mixer value to turn a channel on or off.
/* channelSw: Generic channel switch function
This writes a new mixer value to chip "chip". The mixer value
depends on "chn", the channel turning on or off, "state" whether
the channel is turning on or off, and "*mixer", a pointer to
the old mixer value. */
void channelSw(int chip, int chn, int *mixer, int state) {
/* Enable music chip */
switch(chip) {
case 1: CS1 = 0; break;
case 2: CS2 = 0; break;
case 3: CS3 = 0; break;
case 4: CS4 = 0; break;
}
/* Write mixer value */
/* This writes to channel 7 (mixer channel) the _new_ mixer value, which is
the old mixer value with a particular bit flipped based on "chn" and "state" */
write_chip(0x07, (*mixer) = state ? (*mixer) & (0xFF & ~chn) : (*mixer) | chn);
/* Disable chip */
switch(chip) {
case 1: CS1 = 1; break;
case 2: CS2 = 1; break;
case 3: CS3 = 1; break;
case 4: CS4 = 1; break;
}

}
Interrupt functions
//External interrupt for motor driving
void __ISR(_EXTERNAL_3_VECTOR, ipl6) _SingleVectorHandler(void) {
if (motorflag == 0) {
motorflag = 1; //Start motor cycle
}
//If on already, do nothing
mINT3ClearIntFlag();
}

//External interrupt for motor waiting
void __ISR(_EXTERNAL_4_VECTOR, ipl5) _SingleVectorHandler2(void) {
if (motorflag == 0) {
WriteTimer3(0);
motorflag = 6; //Start wait cycle
}
//If on already, do nothing
mINT4ClearIntFlag();
}

=Results=

The project turned out to be a mild success overall. The tilt switches worked very well for activating the music tones, but the heart rate monitor was less successful. One of the biggest issues was getting rid of very low frequency drift in the signal that made the peaks sometimes as high as 10V, but other times less 1V. Dealing with this fluctuation in peak size was the most difficult part of signal processing. As mentioned above, we tried FFT in order to establish a steady heart rate, but could not get the resolution we desired, thus we abandoned the idea.

'''PROBABLY NEED MORE TECHNICAL RESULTS HERE, BUT I'M NOT SURE WHAT TO SAY RIGHT NOW'''

The best result was that using the device was just plain fun. We each had a great time moving around and hearing the fun sounds that resulted, or if we were feeling ambitious, we would try to play a simple melody like "Mary Had a Little Lamb." It was rather difficult to play anything more complicated than that because it required lots of body control and precise movements.

=Reflections=

'''Successes'''
*tilt switches activated each of the six notes when they were supposed to
**the YMZ284 chips were able to produce all six notes at the same time, allowing cool chords
*tones were in tune and formed fun melodies and chords as the body moved
*drum actuator hit the drum reliably and with good tone
*heart rate monitor usually showed clear peaks on a scope, but was finnicky in practice

'''Room for improvements'''
*tilt switches sometimes bounced, so the beginning, or particularly the ends of the notes sounded jagged
**''Possible Solution:'' add a low pass filter to the switch signal so that the signal ramps up and down.
*the shoulder straps sometimes needed adjustments for each individual in order for the sensors to be in the correct position
**''Possible Solution:'' create straps with more constraints, such as a strap across the chest as well as the back, to ensure that the sensors are in the correct positions and orientations.
*the straps could be easier to put on
**''Possible Solution:'' maybe integrate them into a single garment, like a onesie
*the heart rate monitor was not reliable. Low frequency drift made setting a comparison level nearly impossible, especially for more than one specific user.
**''Possible Solution:'' improve FFT method so that desired resolution could be achieved in a short sample period (around 10 seconds). Or implement a complicated peak detection algorithm on the PIC.

'''JAMES SHOULD ADD SOME KIND OF HEARTWARMING CONCLUSION CUZ HE'S GOOD AT THAT STUFF'''

File:Drum overview mfth.jpg

2010-03-17T09:02:49Z

EricWest: closer view of the drum used in Music from the Heart.

closer view of the drum used in Music from the Heart.

Music from the Heart -- Music Suit

2010-03-17T08:58:36Z

EricWest: /* Drum actuator - Mechanical Design */

=Introduction=

[[Image:Music from the heart overview.jpg|thumb|150px|The "music suit" on James, with heart rate detector on his finger.|right]]

This project attempted to create a natural form of musical expression by connecting sensors to the body. Six tilt switches were attached to the wrist, ankles, and shoulders, each controlling a single pitch from the [http://en.wikipedia.org/wiki/Pentatonic_scale pentatonic scale]. The heart beat was obtained using [http://en.wikipedia.org/wiki/Photoplethysmograph photoplethysmography] on the user's finger, and this signal was used to strike a drum in sync with the heart beat.

For a video demonstration, click [http://www.youtube.com/watch?v=YyipByy7m6I here].

 

==Team Members==

[[Image:Mfth team picture.JPG|thumb|200px|From left: Thomas, Eric, James]]
*Thomas Peterson (Computer Engineering, 2010)
*James Rein (Biomedical Engineering and Music Cognition, 2010)
*Eric West (Mechanical Engineering, 2011)

=Subsystems=

Although intended as a single, cohesive system that would allow the user to intuitively make music, the project was easily divided into three subsystems: heart rate monitor, drum actuation, and music tones. Below is more explanation about each subsystem.

==Heart rate monitor - Concepts==

In brainstorming how to translate a heart beat into a drum beat, we decided that the least intrusive method would be the best. Attaching electrodes to the user would simplify the process of identifying a heart beat, but attaching the sensors directly to the skin would be a time-consuming and personally-invasive process. Instead, we decided a finger tip sensor would be much more comfortable and easy to use.

To make a finger tip sensor, we used the concepts of [http://en.wikipedia.org/wiki/Photoplethysmograph photoplethysmography]. Photoplethysmography is typically used in [http://en.wikipedia.org/wiki/Pulse_oximeter pulse oximeters] and finger-tip sensors in commercially-available devices. We originally tried to hack a heart rate monitor that we had purchased, but this proved difficult, so we decided to make our own.

The basic concept of photoplethysmography is that blood reflects a certain amount of IR light, and the blood density in the finger changes as the heart pumps, so the IR reflectivity of the finger changes as the heart beats. Using an IR emitter-detector pair found in the mechatronics lab followed by lots of amplification and filtering, we were able to obtain a decent signal with peaks when the user's heart beat.

===Heart rate monitor - Electrical Design===

The signal coming directly out of the IR detector was very weak and noisy. To obtain just the information we desired, we ran it through the following filters and amplifiers:

# [[Passive Filters#High-Pass Filter (HPF)|Passive High-Pass Filter]]
# [[Operational Amplifiers (Op-Amps)#Inverting Amplifier|Inverting Amplifier]]: gain = -470
# [http://en.wikipedia.org/wiki/Low-pass_filter#Active_electronic_realization Active Low-pass filter]: cutoff frequency = 4.82Hz, gain = -70
# [http://www.electronics-tutorials.ws/filter/filter_7.html Band-pass filter]: Frequency range = 0.72 to 3.39Hz, inverting gain = -46.8
# [[Comparators|Comparator]]: output to the PIC pin A14, with pull-up resistor to 3.3V and capacitors to smooth out the signal.

The complete signal processing circuit is shown below.

[[Image:Heartrate monitor.PNG|thumb|center|900px|Heart rate monitor circuit diagram. Click for larger image.]]

===Heart rate monitor - Mechanical Design===

[[Image:Heart rate sensor mfth.JPG|thumb|200px|Heart rate sensor with the latex band pulled away so that the emitter-detector is revealed]]
The sensor itself was a QRB1114 emitter-detector pair that was encased in open-cell foam insulation. We inserted it into the foam by drilling and filing a hole in the foam to the appropriate size, and gluing the sensor in place. A round, finger-shaped groove was filed into the foam and the sensor sat flush with the bottom of this groove. The user's finger was held in the correct position with relatively constant pressure using a latex band around the finger and the foam enclosure.

==Drum actuator - Electrical design==

Once the signal from the heart rate sensor is sent to the PIC, the rising edge triggers an interrupt which starts the driving sequence for the motor that strikes the drum. The drive sequence was: drive down (into drum) 100ms, drive up 75ms, wait 150ms. The interrupt does not do the entire driving sequence, it merely flags a variable to start the sequence, which is done in the main loop, as seen in the code below.

An additional interrupt was triggered by the falling edge of the signal; this falling edge interrupt added additional wait time that prevented the PIC from being "fooled" by a noisy falling edge. For instance, if the falling signal had some noise in it, the rising edge interrupt would be triggered again, thus causing the drum to strike on both the rising and falling edges of the heartbeat. We only wanted one strike per heartbeat, so the falling edge interrupt was triggered by the ''first'' falling edge, and any noise in the falling edge was ignored because the PIC was told to wait for 300ms. With a maximum delay of 150 + 300 = 450ms from the two interrupts, and 100 + 75 = 175ms of drive time, the fastest heartbeat our drum could play was 96 beats per minute, but we did not expect anyone to come play the instrument after running, so this was plenty high for our purposes. '''IS MY MATH CORRECT?? SEEMS SLOW TO ME, BUT I GUESS WE HAD TO DO WHAT WE HAD TO DO'''

Initially, we tried skipping the comparator and sending the analog signal directly into one of the PICs analog inputs. Our intention was to use the fast Fourier transform (FFT) library to try to extract the dominant frequency (see [[PIC32MX: FFT of Analog Input]] for more information). Unfortunately, we ran into various problems. First, to get the accuracy we wanted for small frequencies, the sample window had to be very long (10 seconds or more), which made the output lag changes in heart rate. Additionally, the FFT was often "messy", which messed up our original algorithm of detecting the peak frequency between .5 and 2.5 hz. The system would sometimes randomly switch between very different frequencies, and although it was right most of the time it was enough to make the drum beating sound bad. We also tried algorithms to find the [http://en.wikipedia.org/wiki/Fundamental_frequency fundamental frequency] using the entire FFT (instead of just the .5-2.5 hz range), but this was still unreliable. We considered FFT peak detection algorithms, but they seemed to complex for the time and computing power we had available. Because of all this, we went with the simple comparator in the end.

The motor for driving the drumstick was driven by an [[media:L298N.pdf|L298 H-bridge]]. See [[Driving a high current DC Motor using an H-bridge]] for more information on how this works. Our particular circuit diagram is shown below:

[[Image:T21_motorckt_png.PNG|thumb|center|600px|Motor Circuit (non-motor PIC connections not shown). Click for larger image.]]

====Drum actuator - Mechanical Design====

[[Image:Drum stick mount mfth.jpg|thumb|200px|Attachment for the drumstick to the motor shaft. Split-clamp to the motor shaft on the left, drum stick on the right|right]]
We wanted to use a real drum for our drum beat, so our challenge was to attach a motor and drumstick to a drum. We chose a small rack tom for its resonant tone that is reminiscent of a heart beat.

To attach the drumstick to the motor shaft, we used a small block of acrylic (.5"x.75"x2"). The drumstick was cut down to 8" in length so that it would require less torque from the motor. In one end of the block, a hole was drilled and the drumstick was sanded to the correct diameter in order to snuggly fit into the hole. To ensure that the drumstick could not slide out of the block, a screw was placed in a hole drilled through both the stick and the block. The other end of the block was attached to the motor shaft using a split-clamp method: A hole the size of the motor shaft was drilled through the block, and then a slit was cut from the end of the block to the hole, allowing a screw to tightly clamp the block around the motor.

[[Image:Motor mount mfth.jpg|thumb|200px|Mounting bracket for the motor-stick assembly.|right]]
To attach the motor-stick assembly to the drum, we utilized the tuning screws on the drum and holes in the face of the motor. A sheet metal bracket with holes in the appropriate places attached the motor to two of the tuning screws. The bracket was easily made by cutting and bending a piece of 16 gauge steel sheet metal to the appropriate size. Ideally, this part would have been made out of one continuous piece of sheet metal, but we could not find a large enough sheet available in the shop, so we used rivets to connect two smaller pieces together.

After testing the drum striking, we decided it was too loud. To dampen the sound, we taped a piece of foam core and a shop rag to the head of the drum where the stick strikes it.

'''Parts list for drum actuator'''
*Bargain drumstick, at least .5" in diameter
*Small block of acrylic, .5"x.75"x2" (aluminum would work just as well, this is what was available)
*16 gauge steel sheet metal for bracket
*2 pop rivets
*Screws and nuts
*Foam core, shop rag, tape for dampening

==Music Tones - Electrical Design==
The music tones were activated by tilt switches and generated using a [http://pdf1.alldatasheet.com/datasheet-pdf/view/82065/YAMAHA/YMZ284.html YMZ284] chip and were output through a 1/8" jack to a standard set of computer speakers.

Each YMZ284 is capable of producing and mixing any combination of three tones. Since we wanted to have six notes from a [http://en.wikipedia.org/wiki/Pentatonic_scale pentatonic scale], we needed two of these chips and used an [[Operational Amplifiers (Op-Amps)#Summer|summing opamp circuit]] to combine outputs from each chip. We envisioned a possibility of adding [http://en.wikipedia.org/wiki/Overtone overtones] to each note, to make them sound better and more like a real instrument, so we ended up having four YMZ284s attached to our board. When we tried adding an overtone an octave above the fundamental frequency, it ended up sounding harsh and whiny. We decided the tones sounded better with no overtones, so we are only using 2 of the 4 chips on our board.

The YMZ284 communicates with the PIC over an 8-bit databus, plus additional pins for chip select, address, write enable, and reset. All four of our YMZ284s shared all of their pins ''except'' the chip select line; each required their own individual chip select line so that the PIC could specify with which chips it wanted to talk. The circuit diagram below shows how the chips were connected to the PIC and the summing circuit that followed.

{{multiple image
| align = center
| width = 500
| image1 = T21_musicckt_png.PNG
| caption1 = Music circuit diagram. The summing amplifier is not shown.
| image2 = Solder board mfth.jpg
| alt2 = Red cartouche
| caption2 = Music chips are in the center of the board. H-bridge for motor driving is on the far right, along with the power supply plug. The left side is an unsuccessful attempt at moving the heart rate circuitry to the solder board
}}

===Tilt switches - Electrical Design===
In order to detect when the limbs of the user had moved past a certain critical angle, we chose to use tilt switches. We purchased our tilt switches for $2 each from [http://www.goldmine-elec-products.com/prodinfo.asp?number=G16881 Electronics Goldmine]. We chose to use tilt switches instead of an accelerometer because the switches were much cheaper and we figured they would be easier to work with.

The tilt switches we chose are optically-based with an emitter and detector that are selectively blocked by a small ball. When the critical angle is achieved, the tiny ball rolls up a ramp, allowing the emitter to shine directly on the detector, and current flows. When the angle is neutral, the ramp forces the ball to block the light, making current stop flowing through the phototransistor. The "ramp" is really an inverted cone, so the switch can be activated by a change in angle in any direction away from the neutral position. We purchased three different tilt switches to try, each with a different critical angle - 15, 30, and 45 degrees. The configuration we ended up using was:

*30 degrees for shoulders and ankles
*45 degrees for elbows

In hindsight, we would have used all 45-degree switches because they produced the sharpest jump from off to on. The 15-degree switches were practically unusable because they created a large amount of noise as they switched on and off.

We used the tilt switches to provide high-low inputs to the PIC to tell it when to turn on any of the six tones. By attaching these switches to the body such that they are in the neutral position when the body is relaxed, we were able to control the six tones by moving the body in relatively natural ways.

===Tilt switches - Mechanical Design===

[[Image:Wrist sensor mfth.JPG|thumb|200px|Wrist tilt sensor. Ankles are similar, with a larger strap.]]
The switches were attached to the user's body using adjustable straps and buckles. The wrist and ankle sensors were simply a loop of webbing with an adjustable buckle attached. The straps could be tightened or loosened to fit any size user. To attach the switch to the straps, we created an enclosure for each switch out of high-density foam (left over scraps from DSGN 307). The switch was jammed into a hole in the foam so that it could not easily be moved. The foam was then taped to the straps using electrical tape.

The shoulder straps were a bit more involved. Two loops with buckles, similar to the wrist and ankle straps, went over the user's shoulder and underneath their armpit. To keep these straps from sliding off the shoulders, a large strap across the user's back connected the two smaller straps together. This large strap was also used for mounting the solder board which gathered the wires from all six tilt switches and sent them to the PIC over one ribbon cable. Using this strap configuration, we found that the user could comfortably and securely wear the sensors.

[[Image:Shoulder sensors mfth.JPG|thumb|200px|Shoulder straps containing the tilt sensors.]]
To attach the switches to the shoulders, we again created a foam encasement. However, electrical tape was not secure enough to hold the foam pieces to the irregularly-shaped shoulder straps. Instead, we riveted a piece of canvas to the webbing straps. We chose to use rivets instead of sewing because the sewing machine could not tightly sew the foam encasement in place. With rivets, we were able to pull the canvas tightly around the foam so that it couldn't move.

=Code=
To download the entire C file, click [[Media:Main_music.c|here]]. Below, the file is split into sections for comments.

/**********************************************************
* main_music.c: Main c file for "Music Suit" project
*
* Thomas Peterson, James Rein, Eric West
* ME333 Winter 2010
**********************************************************/

#include <HardwareProfile.h>
#include <delays.c> //Delayms and Delayus functions

The first section defines all the input and output pins, used with the motor, sensor, and music circuits.

////////////////////////////////////////////////////
//Pin Defines

//YMZ Chip selects
#define CS1 LATCbits.LATC2
#define CS2 LATCbits.LATC3
#define CS3 LATCbits.LATC4
#define CS4 LATGbits.LATG6
//YMZ communication pins
#define NWR LATBbits.LATB0 //"Not WRite": active low write line
#define A0 LATBbits.LATB6 //Address 0
#define NIC LATCbits.LATC1 //"Not Input Clear": active low reset line
//YMZ data pins
#define D0 LATGbits.LATG9
#define D1 LATEbits.LATE8
#define D2 LATEbits.LATE9
#define D3 LATBbits.LATB5
#define D4 LATBbits.LATB4
#define D5 LATBbits.LATB3
#define D6 LATBbits.LATB2
#define D7 LATBbits.LATB1

//Tilt inputs
#define ENC PORTDbits.RD3
#define END PORTDbits.RD2
#define ENE PORTDbits.RD1
#define ENG PORTCbits.RC14
#define ENA PORTCbits.RC13
#define ENC5 PORTDbits.RD0

//Motor outputs
#define IN1 LATBbits.LATB7
#define IN2 LATAbits.LATA9
#define EN LATAbits.LATA10

///////////////////////////////////////
//Other defines
//Motor times
#define MS(x) x*312.5
#define DRIVETIME MS(100)
#define BACKTIME MS(75)
#define WAITTIME MS(150)
//Channels
#define CHNA 1
#define CHNB 2
#define CHNC 4

//////////////////////////////////////////
//Function definitions
void write_chip(int address, int data);
void portout(int byte);
void channelSw(int chip, int chn, int *mixer, int state);
//Global variables
int mixer1, mixer2;
int motorflag = 0;
The initialization function sets up various parts of the system.
/* init() : This function runs initializations, setting up the pic and music chips */
void init() {
int pbClk = SYSTEMConfigPerformance(SYS_FREQ);

/////////////////////////////////////////////
//Setup inputs / outputs
AD1PCFG = 0xFFFF; //All digital inputs
TRISG &= 0xFDBF; //sets G9,G6 to 0 (output); all else remains the same
TRISC &= 0xFFE1; //sets C4,C3,C2,C1 to 0s (outputs); all else remains the same
TRISB &= 0xFF80; //sets B0-B6 0 (output)
TRISE &= 0xFCFF; //sets E8,9 to output
TRISB |= 0xF000; //sets B12,B13,B14,B15 to 1s (inputs); all else remains the same
TRISC |= 0x6000; //sets C14,13 to inputs
TRISD |= 0x000F; //Sets D0,D1,D2,D3 to inputs
TRISDbits.TRISD4 = 0; //Output for clock
//Motor outputs
TRISAbits.TRISA9 = 0;
TRISAbits.TRISA10 = 0;
TRISBbits.TRISB7 = 0;
//Pulse inputs
TRISAbits.TRISA14 = 1;
TRISAbits.TRISA15 = 1;
//ODC setup
ODCCbits.ODCC1 = 1; //open drain control; can only float high (when set high) or pull low

/* Initialize outputs */
//YMZs
CS1 = 1;
CS2 = 1;
CS3 = 1;
CS4 = 1;
NWR = 1;
A0 = 0;
NIC = 1;
//Motor
IN2 = 0;
IN1 = 0;
EN = 0;

Delayms(100); //wait for power supply to ramp up
NIC = 0; //resets YMZ284s
Delayms(10);
NIC = 1;

In the init() function, the pic writes all the setup data to the music chips. This includes the frequency registers, which determine the frequency of each output, the mixer, which determines which channels are on or off (1 = off), and the volume registers, which determine the volume of each channel. After the setup, the only register that is changed in normal operation is the mixer register, which merely turns channels on and off.
//////////////////////////////////////////////////
//Setup music chips
//Setup Chip 1//
CS1 = 0;
write_chip(0x00,0xC7); //a low // C4
write_chip(0x01,0x01); //a high
write_chip(0x02,0x98); //b low // D
write_chip(0x03,0x01); //b high
write_chip(0x04,0x6E); //c low
write_chip(0x05,0x01); //c high // E
write_chip(0x07,0xFF); //mixer (0 enables)
write_chip(0x08, 0x0A); //level (volume) A
write_chip(0x09, 0x0A); //level (volume) B
write_chip(0x0A, 0x0A); //level (volume) C
CS1=1;
//Setup Chip 2//
CS2 = 0;
write_chip(0x00,0x2C); //a low //G 392
write_chip(0x01,0x01); //a high
write_chip(0x02,0x0D); //b low //A 440
write_chip(0x03,0x01); //b high
write_chip(0x04,0xE3); //c low //C5 523.25
write_chip(0x05,0x00); //c high
write_chip(0x07,0xFF); //mixer (0 enables)
write_chip(0x08, 0x0A); //level (volume) A
write_chip(0x09, 0x0A); //level (volume) B
write_chip(0x0A, 0x0A); //level (volume) C
CS2=1;

mixer1=0xFF;
mixer2=0xFF;
OC5 is used to create a PWM signal with 50% duty at 4Mhz, in effect creating a 4Mhz square wave. This is used by the music chips as a master clock.
//////////////////////////////////////////////
//Setup OC to create master clock for music chips (~4 Mhz)
OpenOC5( OC_ON | OC_TIMER2_SRC | OC_PWM_FAULT_PIN_DISABLE, 0, 0);
OpenTimer2( T2_ON | T2_PS_1_1 | T2_SOURCE_INT, 20);
SetDCOC5PWM(10);
The interrupts are used, as mentioned above, to control when the motor is driven. The motor should drive once every rising edge.
/////////////////////////////////////////////
//External interrupt setups (for motor) - INT3 (A14)
mINT3ClearIntFlag();
mINT3IntEnable(1);
mINT3SetIntPriority(6);
mINT3SetEdgeMode(1); //Rising edge
/////////////////////////////////////////////
//External interrupt setups (for motor) - INT4 (A15)
mINT4ClearIntFlag();
mINT4IntEnable(1);
mINT4SetIntPriority(5);
mINT4SetEdgeMode(0); //Falling edge
INTEnableSystemMultiVectoredInt();

/////////////////////////////////////////////
//Setup motor timer (used for timing delays)
OpenTimer3(T3_ON | T3_PS_1_256 | T3_SOURCE_INT, 0xFFFF);
ConfigIntTimer3(T3_INT_OFF);
}

Main function
/* Main function */
int main()
{
init(); /* Run initialization functions */
Delayms(1);

/* Main while loop: loop indefinietly */
while (1) {
In the main while loop, the PIC checks every cycle to see if an input has changed since the last cycle. Since the "mixer" variables store the current state, if an input does not match up with its valid mixer bit then it has changed recently. In this case, the channelSw() function is called to switch on or off the music channel controlled by that bit.
//Check for state changes in music notes
if (ENC != (mixer1 & 0x01)) { channelSw(1,CHNA,&mixer1,!ENC); } //If input ENC (enable C) is not equal to the state of channel A1 (note c), change the state
if (END != (mixer1 & 0x02)) { channelSw(1,CHNB,&mixer1,!END); }
if (ENE != (mixer1 & 0x04)) { channelSw(1,CHNC,&mixer1,!ENE); }
if (ENG != (mixer2 & 0x01)) { channelSw(2,CHNA,&mixer2,!ENG); }
if (ENA != (mixer2 & 0x02)) { channelSw(2,CHNB,&mixer2,!ENA); }
if (ENC5 != (mixer2 & 0x04)) { channelSw(2,CHNC,&mixer2,!ENC5); }
During the main while loop, the motor flag variable is checked to see if the motor should be driven. If so, it enters a sequence where it uses timer3 to determine the current stage in the motor cycle, changing the outputs as needed.
//Check for motor state changes
switch (motorflag) {
case 0: break; //Do nothing (motor off)
case 1: //Start motor cycle
WriteTimer3(0); //Reset timer to 0
IN1 = 0; //Set H bridge to forward drive
IN2 = 1;
EN = 1;
motorflag = 2; //In drivedown cycle
break;
case 2: //Drivedown cycle
if (ReadTimer3() > DRIVETIME) { //Wait for DRIVETIME to pass
WriteTimer3(0); //Reset timer to 0
motorflag = 3; //In driveup phase
IN2 = 0; //Switch H bridge
IN1 = 1;
}
break;
case 3: //Driveup cycle
if (ReadTimer3() > BACKTIME) { //Wait for BACKTIME to pass
WriteTimer3(0); //Reset timer to 0
motorflag = 4; //In coast/wait phase
EN = 0; //Turn off motor
}
break;
case 4: //coast / wait cycle
if (ReadTimer3() > WAITTIME) {
motorflag = 5; //more wait
WriteTimer3(0);
}
break;
case 5: //Additional wait cycle
if (ReadTimer3() > WAITTIME) {
//Done!
motorflag = 0; //Motor off (can now be triggered again)
}
break;
//Static wait cycles
case 6:
if (ReadTimer3() > WAITTIME) {
motorflag = 7;
WriteTimer3(0);
}
break;
case 7:
if (ReadTimer3() > WAITTIME) {
WriteTimer3(0);
motorflag = 8;
}
break;
case 8:
if (ReadTimer3() > WAITTIME) {
motorflag = 0;
}
break;
}

Delayms(10);
}
return 0;
}//end main

Write chip function, which is a support function that writes data to the music chips.
/* write_chip: This writes the given byte "data" to the "address" (0 or 1)
on a YMZ284. It is assumed that the chip select is already low */
void write_chip(int address,int data) {
//Write address
portout(address);
A0 = 0; //select address mode
Delayus(1); //setup time
NWR = 0; //Write cycle begin
Delayus(1); //hold time
NWR = 1; //Write cycle end

//Write data
portout(data);
A0 = 1; //select data mode
Delayus(1); //setup time
NWR = 0; //write cycle begin
Delayus(1); //hold time
NWR = 1; //write cycle end
}
Port out function
/* port_out: This function outputs a byte to the D0-D7 port */
void portout(int byte) {
// Note: !! converts an integer expression to a boolean (1 or 0).
D0 = !!(byte & 1);
D1 = !!(byte & 2);
D2 = !!(byte & 4);
D3 = !!(byte & 8);
D4 = !!(byte & 16);
D5 = !!(byte & 32);
D6 = !!(byte & 64);
D7 = !!(byte & 128);
}
Channel switch function, which writes a new mixer value to turn a channel on or off.
/* channelSw: Generic channel switch function
This writes a new mixer value to chip "chip". The mixer value
depends on "chn", the channel turning on or off, "state" whether
the channel is turning on or off, and "*mixer", a pointer to
the old mixer value. */
void channelSw(int chip, int chn, int *mixer, int state) {
/* Enable music chip */
switch(chip) {
case 1: CS1 = 0; break;
case 2: CS2 = 0; break;
case 3: CS3 = 0; break;
case 4: CS4 = 0; break;
}
/* Write mixer value */
/* This writes to channel 7 (mixer channel) the _new_ mixer value, which is
the old mixer value with a particular bit flipped based on "chn" and "state" */
write_chip(0x07, (*mixer) = state ? (*mixer) & (0xFF & ~chn) : (*mixer) | chn);
/* Disable chip */
switch(chip) {
case 1: CS1 = 1; break;
case 2: CS2 = 1; break;
case 3: CS3 = 1; break;
case 4: CS4 = 1; break;
}

}
Interrupt functions
//External interrupt for motor driving
void __ISR(_EXTERNAL_3_VECTOR, ipl6) _SingleVectorHandler(void) {
if (motorflag == 0) {
motorflag = 1; //Start motor cycle
}
//If on already, do nothing
mINT3ClearIntFlag();
}

//External interrupt for motor waiting
void __ISR(_EXTERNAL_4_VECTOR, ipl5) _SingleVectorHandler2(void) {
if (motorflag == 0) {
WriteTimer3(0);
motorflag = 6; //Start wait cycle
}
//If on already, do nothing
mINT4ClearIntFlag();
}

=Results=

The project turned out to be a mild success overall. The tilt switches worked very well for activating the music tones, but the heart rate monitor was less successful. One of the biggest issues was getting rid of very low frequency drift in the signal that made the peaks sometimes as high as 10V, but other times less 1V. Dealing with this fluctuation in peak size was the most difficult part of signal processing. As mentioned above, we tried FFT in order to establish a steady heart rate, but could not get the resolution we desired, thus we abandoned the idea.

'''PROBABLY NEED MORE TECHNICAL RESULTS HERE, BUT I'M NOT SURE WHAT TO SAY RIGHT NOW'''

The best result was that using the device was just plain fun. We each had a great time moving around and hearing the fun sounds that resulted, or if we were feeling ambitious, we would try to play a simple melody like "Mary Had a Little Lamb." It was rather difficult to play anything more complicated than that because it required lots of body control and precise movements.

=Reflections=

'''Successes'''
*tilt switches activated each of the six notes when they were supposed to
**the YMZ284 chips were able to produce all six notes at the same time, allowing cool chords
*tones were in tune and formed fun melodies and chords as the body moved
*drum actuator hit the drum reliably and with good tone
*heart rate monitor usually showed clear peaks on a scope, but was finnicky in practice

'''Room for improvements'''
*tilt switches sometimes bounced, so the beginning, or particularly the ends of the notes sounded jagged
**''Possible Solution:'' add a low pass filter to the switch signal so that the signal ramps up and down.
*the shoulder straps sometimes needed adjustments for each individual in order for the sensors to be in the correct position
**''Possible Solution:'' create straps with more constraints, such as a strap across the chest as well as the back, to ensure that the sensors are in the correct positions and orientations.
*the straps could be easier to put on
**''Possible Solution:'' maybe integrate them into a single garment, like a onesie
*the heart rate monitor was not reliable. Low frequency drift made setting a comparison level nearly impossible, especially for more than one specific user.
**''Possible Solution:'' improve FFT method so that desired resolution could be achieved in a short sample period (around 10 seconds). Or implement a complicated peak detection algorithm on the PIC.

'''JAMES SHOULD ADD SOME KIND OF HEARTWARMING CONCLUSION CUZ HE'S GOOD AT THAT STUFF'''

Music from the Heart -- Music Suit

2010-03-17T08:57:10Z

EricWest: /* Introduction */

=Introduction=

[[Image:Music from the heart overview.jpg|thumb|150px|The "music suit" on James, with heart rate detector on his finger.|right]]

This project attempted to create a natural form of musical expression by connecting sensors to the body. Six tilt switches were attached to the wrist, ankles, and shoulders, each controlling a single pitch from the [http://en.wikipedia.org/wiki/Pentatonic_scale pentatonic scale]. The heart beat was obtained using [http://en.wikipedia.org/wiki/Photoplethysmograph photoplethysmography] on the user's finger, and this signal was used to strike a drum in sync with the heart beat.

For a video demonstration, click [http://www.youtube.com/watch?v=YyipByy7m6I here].

 

==Team Members==

[[Image:Mfth team picture.JPG|thumb|200px|From left: Thomas, Eric, James]]
*Thomas Peterson (Computer Engineering, 2010)
*James Rein (Biomedical Engineering and Music Cognition, 2010)
*Eric West (Mechanical Engineering, 2011)

=Subsystems=

Although intended as a single, cohesive system that would allow the user to intuitively make music, the project was easily divided into three subsystems: heart rate monitor, drum actuation, and music tones. Below is more explanation about each subsystem.

==Heart rate monitor - Concepts==

In brainstorming how to translate a heart beat into a drum beat, we decided that the least intrusive method would be the best. Attaching electrodes to the user would simplify the process of identifying a heart beat, but attaching the sensors directly to the skin would be a time-consuming and personally-invasive process. Instead, we decided a finger tip sensor would be much more comfortable and easy to use.

To make a finger tip sensor, we used the concepts of [http://en.wikipedia.org/wiki/Photoplethysmograph photoplethysmography]. Photoplethysmography is typically used in [http://en.wikipedia.org/wiki/Pulse_oximeter pulse oximeters] and finger-tip sensors in commercially-available devices. We originally tried to hack a heart rate monitor that we had purchased, but this proved difficult, so we decided to make our own.

The basic concept of photoplethysmography is that blood reflects a certain amount of IR light, and the blood density in the finger changes as the heart pumps, so the IR reflectivity of the finger changes as the heart beats. Using an IR emitter-detector pair found in the mechatronics lab followed by lots of amplification and filtering, we were able to obtain a decent signal with peaks when the user's heart beat.

===Heart rate monitor - Electrical Design===

The signal coming directly out of the IR detector was very weak and noisy. To obtain just the information we desired, we ran it through the following filters and amplifiers:

# [[Passive Filters#High-Pass Filter (HPF)|Passive High-Pass Filter]]
# [[Operational Amplifiers (Op-Amps)#Inverting Amplifier|Inverting Amplifier]]: gain = -470
# [http://en.wikipedia.org/wiki/Low-pass_filter#Active_electronic_realization Active Low-pass filter]: cutoff frequency = 4.82Hz, gain = -70
# [http://www.electronics-tutorials.ws/filter/filter_7.html Band-pass filter]: Frequency range = 0.72 to 3.39Hz, inverting gain = -46.8
# [[Comparators|Comparator]]: output to the PIC pin A14, with pull-up resistor to 3.3V and capacitors to smooth out the signal.

The complete signal processing circuit is shown below.

[[Image:Heartrate monitor.PNG|thumb|center|900px|Heart rate monitor circuit diagram. Click for larger image.]]

===Heart rate monitor - Mechanical Design===

[[Image:Heart rate sensor mfth.JPG|thumb|200px|Heart rate sensor with the latex band pulled away so that the emitter-detector is revealed]]
The sensor itself was a QRB1114 emitter-detector pair that was encased in open-cell foam insulation. We inserted it into the foam by drilling and filing a hole in the foam to the appropriate size, and gluing the sensor in place. A round, finger-shaped groove was filed into the foam and the sensor sat flush with the bottom of this groove. The user's finger was held in the correct position with relatively constant pressure using a latex band around the finger and the foam enclosure.

==Drum actuator - Electrical design==

Once the signal from the heart rate sensor is sent to the PIC, the rising edge triggers an interrupt which starts the driving sequence for the motor that strikes the drum. The drive sequence was: drive down (into drum) 100ms, drive up 75ms, wait 150ms. The interrupt does not do the entire driving sequence, it merely flags a variable to start the sequence, which is done in the main loop, as seen in the code below.

An additional interrupt was triggered by the falling edge of the signal; this falling edge interrupt added additional wait time that prevented the PIC from being "fooled" by a noisy falling edge. For instance, if the falling signal had some noise in it, the rising edge interrupt would be triggered again, thus causing the drum to strike on both the rising and falling edges of the heartbeat. We only wanted one strike per heartbeat, so the falling edge interrupt was triggered by the ''first'' falling edge, and any noise in the falling edge was ignored because the PIC was told to wait for 300ms. With a maximum delay of 150 + 300 = 450ms from the two interrupts, and 100 + 75 = 175ms of drive time, the fastest heartbeat our drum could play was 96 beats per minute, but we did not expect anyone to come play the instrument after running, so this was plenty high for our purposes. '''IS MY MATH CORRECT?? SEEMS SLOW TO ME, BUT I GUESS WE HAD TO DO WHAT WE HAD TO DO'''

Initially, we tried skipping the comparator and sending the analog signal directly into one of the PICs analog inputs. Our intention was to use the fast Fourier transform (FFT) library to try to extract the dominant frequency (see [[PIC32MX: FFT of Analog Input]] for more information). Unfortunately, we ran into various problems. First, to get the accuracy we wanted for small frequencies, the sample window had to be very long (10 seconds or more), which made the output lag changes in heart rate. Additionally, the FFT was often "messy", which messed up our original algorithm of detecting the peak frequency between .5 and 2.5 hz. The system would sometimes randomly switch between very different frequencies, and although it was right most of the time it was enough to make the drum beating sound bad. We also tried algorithms to find the [http://en.wikipedia.org/wiki/Fundamental_frequency fundamental frequency] using the entire FFT (instead of just the .5-2.5 hz range), but this was still unreliable. We considered FFT peak detection algorithms, but they seemed to complex for the time and computing power we had available. Because of all this, we went with the simple comparator in the end.

The motor for driving the drumstick was driven by an [[media:L298N.pdf|L298 H-bridge]]. See [[Driving a high current DC Motor using an H-bridge]] for more information on how this works. Our particular circuit diagram is shown below:

[[Image:T21_motorckt_png.PNG|thumb|center|600px|Motor Circuit (non-motor PIC connections not shown). Click for larger image.]]

====Drum actuator - Mechanical Design====

[[Image:Drum stick mount mfth.jpg|thumb|200px|Attachment for the drumstick to the motor shaft.|right]]
We wanted to use a real drum for our drum beat, so our challenge was to attach a motor and drumstick to a drum. We chose a small rack tom for its resonant tone that is reminiscent of a heart beat.

To attach the drumstick to the motor shaft, we used a small block of acrylic (.5"x.75"x2"). The drumstick was cut down to 8" in length so that it would require less torque from the motor. In one end of the block, a hole was drilled and the drumstick was sanded to the correct diameter in order to snuggly fit into the hole. To ensure that the drumstick could not slide out of the block, a screw was placed in a hole drilled through both the stick and the block. The other end of the block was attached to the motor shaft using a split-clamp method: A hole the size of the motor shaft was drilled through the block, and then a slit was cut from the end of the block to the hole, allowing a screw to tightly clamp the block around the motor.

[[Image:Motor mount mfth.jpg|thumb|200px|Mounting bracket for the motor-stick assembly.|right]]
To attach the motor-stick assembly to the drum, we utilized the tuning screws on the drum and holes in the face of the motor. A sheet metal bracket with holes in the appropriate places attached the motor to two of the tuning screws. The bracket was easily made by cutting and bending a piece of 16 gauge steel sheet metal to the appropriate size. Ideally, this part would have been made out of one continuous piece of sheet metal, but we could not find a large enough sheet available in the shop, so we used rivets to connect two smaller pieces together.

After testing the drum striking, we decided it was too loud. To dampen the sound, we taped a piece of foam core and a shop rag to the head of the drum where the stick strikes it.

'''Parts list for drum actuator'''
*Bargain drumstick, at least .5" in diameter
*Small block of acrylic, .5"x.75"x2" (aluminum would work just as well, this is what was available)
*16 gauge steel sheet metal for bracket
*2 pop rivets
*Screws and nuts
*Foam core, shop rag, tape for dampening

==Music Tones - Electrical Design==
The music tones were activated by tilt switches and generated using a [http://pdf1.alldatasheet.com/datasheet-pdf/view/82065/YAMAHA/YMZ284.html YMZ284] chip and were output through a 1/8" jack to a standard set of computer speakers.

Each YMZ284 is capable of producing and mixing any combination of three tones. Since we wanted to have six notes from a [http://en.wikipedia.org/wiki/Pentatonic_scale pentatonic scale], we needed two of these chips and used an [[Operational Amplifiers (Op-Amps)#Summer|summing opamp circuit]] to combine outputs from each chip. We envisioned a possibility of adding [http://en.wikipedia.org/wiki/Overtone overtones] to each note, to make them sound better and more like a real instrument, so we ended up having four YMZ284s attached to our board. When we tried adding an overtone an octave above the fundamental frequency, it ended up sounding harsh and whiny. We decided the tones sounded better with no overtones, so we are only using 2 of the 4 chips on our board.

The YMZ284 communicates with the PIC over an 8-bit databus, plus additional pins for chip select, address, write enable, and reset. All four of our YMZ284s shared all of their pins ''except'' the chip select line; each required their own individual chip select line so that the PIC could specify with which chips it wanted to talk. The circuit diagram below shows how the chips were connected to the PIC and the summing circuit that followed.

{{multiple image
| align = center
| width = 500
| image1 = T21_musicckt_png.PNG
| caption1 = Music circuit diagram. The summing amplifier is not shown.
| image2 = Solder board mfth.jpg
| alt2 = Red cartouche
| caption2 = Music chips are in the center of the board. H-bridge for motor driving is on the far right, along with the power supply plug. The left side is an unsuccessful attempt at moving the heart rate circuitry to the solder board
}}

===Tilt switches - Electrical Design===
In order to detect when the limbs of the user had moved past a certain critical angle, we chose to use tilt switches. We purchased our tilt switches for $2 each from [http://www.goldmine-elec-products.com/prodinfo.asp?number=G16881 Electronics Goldmine]. We chose to use tilt switches instead of an accelerometer because the switches were much cheaper and we figured they would be easier to work with.

The tilt switches we chose are optically-based with an emitter and detector that are selectively blocked by a small ball. When the critical angle is achieved, the tiny ball rolls up a ramp, allowing the emitter to shine directly on the detector, and current flows. When the angle is neutral, the ramp forces the ball to block the light, making current stop flowing through the phototransistor. The "ramp" is really an inverted cone, so the switch can be activated by a change in angle in any direction away from the neutral position. We purchased three different tilt switches to try, each with a different critical angle - 15, 30, and 45 degrees. The configuration we ended up using was:

*30 degrees for shoulders and ankles
*45 degrees for elbows

In hindsight, we would have used all 45-degree switches because they produced the sharpest jump from off to on. The 15-degree switches were practically unusable because they created a large amount of noise as they switched on and off.

We used the tilt switches to provide high-low inputs to the PIC to tell it when to turn on any of the six tones. By attaching these switches to the body such that they are in the neutral position when the body is relaxed, we were able to control the six tones by moving the body in relatively natural ways.

===Tilt switches - Mechanical Design===

[[Image:Wrist sensor mfth.JPG|thumb|200px|Wrist tilt sensor. Ankles are similar, with a larger strap.]]
The switches were attached to the user's body using adjustable straps and buckles. The wrist and ankle sensors were simply a loop of webbing with an adjustable buckle attached. The straps could be tightened or loosened to fit any size user. To attach the switch to the straps, we created an enclosure for each switch out of high-density foam (left over scraps from DSGN 307). The switch was jammed into a hole in the foam so that it could not easily be moved. The foam was then taped to the straps using electrical tape.

The shoulder straps were a bit more involved. Two loops with buckles, similar to the wrist and ankle straps, went over the user's shoulder and underneath their armpit. To keep these straps from sliding off the shoulders, a large strap across the user's back connected the two smaller straps together. This large strap was also used for mounting the solder board which gathered the wires from all six tilt switches and sent them to the PIC over one ribbon cable. Using this strap configuration, we found that the user could comfortably and securely wear the sensors.

[[Image:Shoulder sensors mfth.JPG|thumb|200px|Shoulder straps containing the tilt sensors.]]
To attach the switches to the shoulders, we again created a foam encasement. However, electrical tape was not secure enough to hold the foam pieces to the irregularly-shaped shoulder straps. Instead, we riveted a piece of canvas to the webbing straps. We chose to use rivets instead of sewing because the sewing machine could not tightly sew the foam encasement in place. With rivets, we were able to pull the canvas tightly around the foam so that it couldn't move.

=Code=
To download the entire C file, click [[Media:Main_music.c|here]]. Below, the file is split into sections for comments.

/**********************************************************
* main_music.c: Main c file for "Music Suit" project
*
* Thomas Peterson, James Rein, Eric West
* ME333 Winter 2010
**********************************************************/

#include <HardwareProfile.h>
#include <delays.c> //Delayms and Delayus functions

The first section defines all the input and output pins, used with the motor, sensor, and music circuits.

////////////////////////////////////////////////////
//Pin Defines

//YMZ Chip selects
#define CS1 LATCbits.LATC2
#define CS2 LATCbits.LATC3
#define CS3 LATCbits.LATC4
#define CS4 LATGbits.LATG6
//YMZ communication pins
#define NWR LATBbits.LATB0 //"Not WRite": active low write line
#define A0 LATBbits.LATB6 //Address 0
#define NIC LATCbits.LATC1 //"Not Input Clear": active low reset line
//YMZ data pins
#define D0 LATGbits.LATG9
#define D1 LATEbits.LATE8
#define D2 LATEbits.LATE9
#define D3 LATBbits.LATB5
#define D4 LATBbits.LATB4
#define D5 LATBbits.LATB3
#define D6 LATBbits.LATB2
#define D7 LATBbits.LATB1

//Tilt inputs
#define ENC PORTDbits.RD3
#define END PORTDbits.RD2
#define ENE PORTDbits.RD1
#define ENG PORTCbits.RC14
#define ENA PORTCbits.RC13
#define ENC5 PORTDbits.RD0

//Motor outputs
#define IN1 LATBbits.LATB7
#define IN2 LATAbits.LATA9
#define EN LATAbits.LATA10

///////////////////////////////////////
//Other defines
//Motor times
#define MS(x) x*312.5
#define DRIVETIME MS(100)
#define BACKTIME MS(75)
#define WAITTIME MS(150)
//Channels
#define CHNA 1
#define CHNB 2
#define CHNC 4

//////////////////////////////////////////
//Function definitions
void write_chip(int address, int data);
void portout(int byte);
void channelSw(int chip, int chn, int *mixer, int state);
//Global variables
int mixer1, mixer2;
int motorflag = 0;
The initialization function sets up various parts of the system.
/* init() : This function runs initializations, setting up the pic and music chips */
void init() {
int pbClk = SYSTEMConfigPerformance(SYS_FREQ);

/////////////////////////////////////////////
//Setup inputs / outputs
AD1PCFG = 0xFFFF; //All digital inputs
TRISG &= 0xFDBF; //sets G9,G6 to 0 (output); all else remains the same
TRISC &= 0xFFE1; //sets C4,C3,C2,C1 to 0s (outputs); all else remains the same
TRISB &= 0xFF80; //sets B0-B6 0 (output)
TRISE &= 0xFCFF; //sets E8,9 to output
TRISB |= 0xF000; //sets B12,B13,B14,B15 to 1s (inputs); all else remains the same
TRISC |= 0x6000; //sets C14,13 to inputs
TRISD |= 0x000F; //Sets D0,D1,D2,D3 to inputs
TRISDbits.TRISD4 = 0; //Output for clock
//Motor outputs
TRISAbits.TRISA9 = 0;
TRISAbits.TRISA10 = 0;
TRISBbits.TRISB7 = 0;
//Pulse inputs
TRISAbits.TRISA14 = 1;
TRISAbits.TRISA15 = 1;
//ODC setup
ODCCbits.ODCC1 = 1; //open drain control; can only float high (when set high) or pull low

/* Initialize outputs */
//YMZs
CS1 = 1;
CS2 = 1;
CS3 = 1;
CS4 = 1;
NWR = 1;
A0 = 0;
NIC = 1;
//Motor
IN2 = 0;
IN1 = 0;
EN = 0;

Delayms(100); //wait for power supply to ramp up
NIC = 0; //resets YMZ284s
Delayms(10);
NIC = 1;

In the init() function, the pic writes all the setup data to the music chips. This includes the frequency registers, which determine the frequency of each output, the mixer, which determines which channels are on or off (1 = off), and the volume registers, which determine the volume of each channel. After the setup, the only register that is changed in normal operation is the mixer register, which merely turns channels on and off.
//////////////////////////////////////////////////
//Setup music chips
//Setup Chip 1//
CS1 = 0;
write_chip(0x00,0xC7); //a low // C4
write_chip(0x01,0x01); //a high
write_chip(0x02,0x98); //b low // D
write_chip(0x03,0x01); //b high
write_chip(0x04,0x6E); //c low
write_chip(0x05,0x01); //c high // E
write_chip(0x07,0xFF); //mixer (0 enables)
write_chip(0x08, 0x0A); //level (volume) A
write_chip(0x09, 0x0A); //level (volume) B
write_chip(0x0A, 0x0A); //level (volume) C
CS1=1;
//Setup Chip 2//
CS2 = 0;
write_chip(0x00,0x2C); //a low //G 392
write_chip(0x01,0x01); //a high
write_chip(0x02,0x0D); //b low //A 440
write_chip(0x03,0x01); //b high
write_chip(0x04,0xE3); //c low //C5 523.25
write_chip(0x05,0x00); //c high
write_chip(0x07,0xFF); //mixer (0 enables)
write_chip(0x08, 0x0A); //level (volume) A
write_chip(0x09, 0x0A); //level (volume) B
write_chip(0x0A, 0x0A); //level (volume) C
CS2=1;

mixer1=0xFF;
mixer2=0xFF;
OC5 is used to create a PWM signal with 50% duty at 4Mhz, in effect creating a 4Mhz square wave. This is used by the music chips as a master clock.
//////////////////////////////////////////////
//Setup OC to create master clock for music chips (~4 Mhz)
OpenOC5( OC_ON | OC_TIMER2_SRC | OC_PWM_FAULT_PIN_DISABLE, 0, 0);
OpenTimer2( T2_ON | T2_PS_1_1 | T2_SOURCE_INT, 20);
SetDCOC5PWM(10);
The interrupts are used, as mentioned above, to control when the motor is driven. The motor should drive once every rising edge.
/////////////////////////////////////////////
//External interrupt setups (for motor) - INT3 (A14)
mINT3ClearIntFlag();
mINT3IntEnable(1);
mINT3SetIntPriority(6);
mINT3SetEdgeMode(1); //Rising edge
/////////////////////////////////////////////
//External interrupt setups (for motor) - INT4 (A15)
mINT4ClearIntFlag();
mINT4IntEnable(1);
mINT4SetIntPriority(5);
mINT4SetEdgeMode(0); //Falling edge
INTEnableSystemMultiVectoredInt();

/////////////////////////////////////////////
//Setup motor timer (used for timing delays)
OpenTimer3(T3_ON | T3_PS_1_256 | T3_SOURCE_INT, 0xFFFF);
ConfigIntTimer3(T3_INT_OFF);
}

Main function
/* Main function */
int main()
{
init(); /* Run initialization functions */
Delayms(1);

/* Main while loop: loop indefinietly */
while (1) {
In the main while loop, the PIC checks every cycle to see if an input has changed since the last cycle. Since the "mixer" variables store the current state, if an input does not match up with its valid mixer bit then it has changed recently. In this case, the channelSw() function is called to switch on or off the music channel controlled by that bit.
//Check for state changes in music notes
if (ENC != (mixer1 & 0x01)) { channelSw(1,CHNA,&mixer1,!ENC); } //If input ENC (enable C) is not equal to the state of channel A1 (note c), change the state
if (END != (mixer1 & 0x02)) { channelSw(1,CHNB,&mixer1,!END); }
if (ENE != (mixer1 & 0x04)) { channelSw(1,CHNC,&mixer1,!ENE); }
if (ENG != (mixer2 & 0x01)) { channelSw(2,CHNA,&mixer2,!ENG); }
if (ENA != (mixer2 & 0x02)) { channelSw(2,CHNB,&mixer2,!ENA); }
if (ENC5 != (mixer2 & 0x04)) { channelSw(2,CHNC,&mixer2,!ENC5); }
During the main while loop, the motor flag variable is checked to see if the motor should be driven. If so, it enters a sequence where it uses timer3 to determine the current stage in the motor cycle, changing the outputs as needed.
//Check for motor state changes
switch (motorflag) {
case 0: break; //Do nothing (motor off)
case 1: //Start motor cycle
WriteTimer3(0); //Reset timer to 0
IN1 = 0; //Set H bridge to forward drive
IN2 = 1;
EN = 1;
motorflag = 2; //In drivedown cycle
break;
case 2: //Drivedown cycle
if (ReadTimer3() > DRIVETIME) { //Wait for DRIVETIME to pass
WriteTimer3(0); //Reset timer to 0
motorflag = 3; //In driveup phase
IN2 = 0; //Switch H bridge
IN1 = 1;
}
break;
case 3: //Driveup cycle
if (ReadTimer3() > BACKTIME) { //Wait for BACKTIME to pass
WriteTimer3(0); //Reset timer to 0
motorflag = 4; //In coast/wait phase
EN = 0; //Turn off motor
}
break;
case 4: //coast / wait cycle
if (ReadTimer3() > WAITTIME) {
motorflag = 5; //more wait
WriteTimer3(0);
}
break;
case 5: //Additional wait cycle
if (ReadTimer3() > WAITTIME) {
//Done!
motorflag = 0; //Motor off (can now be triggered again)
}
break;
//Static wait cycles
case 6:
if (ReadTimer3() > WAITTIME) {
motorflag = 7;
WriteTimer3(0);
}
break;
case 7:
if (ReadTimer3() > WAITTIME) {
WriteTimer3(0);
motorflag = 8;
}
break;
case 8:
if (ReadTimer3() > WAITTIME) {
motorflag = 0;
}
break;
}

Delayms(10);
}
return 0;
}//end main

Write chip function, which is a support function that writes data to the music chips.
/* write_chip: This writes the given byte "data" to the "address" (0 or 1)
on a YMZ284. It is assumed that the chip select is already low */
void write_chip(int address,int data) {
//Write address
portout(address);
A0 = 0; //select address mode
Delayus(1); //setup time
NWR = 0; //Write cycle begin
Delayus(1); //hold time
NWR = 1; //Write cycle end

//Write data
portout(data);
A0 = 1; //select data mode
Delayus(1); //setup time
NWR = 0; //write cycle begin
Delayus(1); //hold time
NWR = 1; //write cycle end
}
Port out function
/* port_out: This function outputs a byte to the D0-D7 port */
void portout(int byte) {
// Note: !! converts an integer expression to a boolean (1 or 0).
D0 = !!(byte & 1);
D1 = !!(byte & 2);
D2 = !!(byte & 4);
D3 = !!(byte & 8);
D4 = !!(byte & 16);
D5 = !!(byte & 32);
D6 = !!(byte & 64);
D7 = !!(byte & 128);
}
Channel switch function, which writes a new mixer value to turn a channel on or off.
/* channelSw: Generic channel switch function
This writes a new mixer value to chip "chip". The mixer value
depends on "chn", the channel turning on or off, "state" whether
the channel is turning on or off, and "*mixer", a pointer to
the old mixer value. */
void channelSw(int chip, int chn, int *mixer, int state) {
/* Enable music chip */
switch(chip) {
case 1: CS1 = 0; break;
case 2: CS2 = 0; break;
case 3: CS3 = 0; break;
case 4: CS4 = 0; break;
}
/* Write mixer value */
/* This writes to channel 7 (mixer channel) the _new_ mixer value, which is
the old mixer value with a particular bit flipped based on "chn" and "state" */
write_chip(0x07, (*mixer) = state ? (*mixer) & (0xFF & ~chn) : (*mixer) | chn);
/* Disable chip */
switch(chip) {
case 1: CS1 = 1; break;
case 2: CS2 = 1; break;
case 3: CS3 = 1; break;
case 4: CS4 = 1; break;
}

}
Interrupt functions
//External interrupt for motor driving
void __ISR(_EXTERNAL_3_VECTOR, ipl6) _SingleVectorHandler(void) {
if (motorflag == 0) {
motorflag = 1; //Start motor cycle
}
//If on already, do nothing
mINT3ClearIntFlag();
}

//External interrupt for motor waiting
void __ISR(_EXTERNAL_4_VECTOR, ipl5) _SingleVectorHandler2(void) {
if (motorflag == 0) {
WriteTimer3(0);
motorflag = 6; //Start wait cycle
}
//If on already, do nothing
mINT4ClearIntFlag();
}

=Results=

The project turned out to be a mild success overall. The tilt switches worked very well for activating the music tones, but the heart rate monitor was less successful. One of the biggest issues was getting rid of very low frequency drift in the signal that made the peaks sometimes as high as 10V, but other times less 1V. Dealing with this fluctuation in peak size was the most difficult part of signal processing. As mentioned above, we tried FFT in order to establish a steady heart rate, but could not get the resolution we desired, thus we abandoned the idea.

'''PROBABLY NEED MORE TECHNICAL RESULTS HERE, BUT I'M NOT SURE WHAT TO SAY RIGHT NOW'''

The best result was that using the device was just plain fun. We each had a great time moving around and hearing the fun sounds that resulted, or if we were feeling ambitious, we would try to play a simple melody like "Mary Had a Little Lamb." It was rather difficult to play anything more complicated than that because it required lots of body control and precise movements.

=Reflections=

'''Successes'''
*tilt switches activated each of the six notes when they were supposed to
**the YMZ284 chips were able to produce all six notes at the same time, allowing cool chords
*tones were in tune and formed fun melodies and chords as the body moved
*drum actuator hit the drum reliably and with good tone
*heart rate monitor usually showed clear peaks on a scope, but was finnicky in practice

'''Room for improvements'''
*tilt switches sometimes bounced, so the beginning, or particularly the ends of the notes sounded jagged
**''Possible Solution:'' add a low pass filter to the switch signal so that the signal ramps up and down.
*the shoulder straps sometimes needed adjustments for each individual in order for the sensors to be in the correct position
**''Possible Solution:'' create straps with more constraints, such as a strap across the chest as well as the back, to ensure that the sensors are in the correct positions and orientations.
*the straps could be easier to put on
**''Possible Solution:'' maybe integrate them into a single garment, like a onesie
*the heart rate monitor was not reliable. Low frequency drift made setting a comparison level nearly impossible, especially for more than one specific user.
**''Possible Solution:'' improve FFT method so that desired resolution could be achieved in a short sample period (around 10 seconds). Or implement a complicated peak detection algorithm on the PIC.

'''JAMES SHOULD ADD SOME KIND OF HEARTWARMING CONCLUSION CUZ HE'S GOOD AT THAT STUFF'''

ME 333 final projects

2010-03-17T08:52:22Z

EricWest: /* Music from the Heart -- Music Suit */

See the '''[[ME 333 end of course schedule]]'''.

Final projects for ME 333 in years 2000-2007 can be found
'''[http://lims.mech.northwestern.edu/~design/mechatronics/ here]'''.

__TOC__

== ME 333 Final Projects 2010 ==

=== [[Sample Project Title]] ===

[[Image:Persistence of Vison Display|thumb|150px|Project photo caption.|right]]

You can copy and paste this wiki code to start your wiki page (but don't erase this code). Then replace this text with your own. A few sentences describing what your project does, with a link to a youtube video. Look at other final project wiki pages for ideas, but see [[ME 333 end of course schedule]] for more information on what should be included on your wiki page.

 

=== [[Furuta Pendulum]] ===

[[Image:Picture 1.png|thumb|150px|Furuta Pendulum|right]]

The Furuta pendulum, so named because it was first developed by Katsuhisa Furuta, is a rotational inverted pendulum. In other words, the horizontal arm, which rotates in the horizontal plane, drives the movement of the vertical arm, which is free to rotate in the vertical plane. Out objective was to build a Furuta pendulum that would hold the vertical arm up, as you can see from the [http://www.youtube.com/watch?v=7DtFLKgNUk4 demonstration video].

 

=== [[Music from the Heart -- Music Suit]] ===

[[Image:Music from the heart overview.jpg|thumb|150px|The "music suit" on James, with heart rate detector on his finger.|right]]

This project attempted to create a natural form of musical expression by connecting sensors to the body. Six tilt switches were attached to the wrist, ankles, and shoulders, each controlling a single pitch from the [http://en.wikipedia.org/wiki/Pentatonic_scale pentatonic scale]. The heart beat was obtained using [http://en.wikipedia.org/wiki/Photoplethysmograph photoplethysmography] on the user's finger, and this signal was used to strike a drum in sync with the heart beat.

For a video demonstration, click [http://www.youtube.com/watch?v=YyipByy7m6I here].

 

=== [[Conservation of Angular Momentum Locomotion Robot (Fluffbot)]] ===

[[Image:Persistence of Vison Display|thumb|150px|Project photo caption.|right]]

Cute fluffy robot that uses conservation of angular momentum to move forward and backward. The robot's momentum wheel accelerates in the floor-plane. The robot's net angular momentum must remain zero-- a steering wheel guides the Fluffbot to accelerate in the opposite direction. This moves the robot forward in a curved path. The momentum wheel and steering wheel then change direction of acceleration. This repeated process moves the Fluffbot forward in a sinusoidal path.

 

=== [[Differential Drive Mobile Robot]] ===

[[Image:Persistence of Vison Display|thumb|150px|Project photo caption.|right]]

The goal of this project was to create a small differential drive mobile robot that would act as a low cost replacement for the popular E-Puck Robot. The robot uses hybrid stepper motors to allow it to track its position through odometry, has a laser cut acrylic chassis for easy replication and replacement, and a 1500 mAh, 13.2V battery pack for long run time. The robot also uses the NU32 board for its control logic and a XBee chip for communication.

 

=== [[Ferrofluid Art Display]] ===

[[Image:Persistence of Vison Display|thumb|150px|Place holder text for caption .|right]]

A little blurb about our Ferrofluid Art Display will go here. Just a few sentences talking about blah blah lkasjdfal hfalsdjh.

 

=== [[Can Launching Fridge]] ===

[[Image:27_Fridge.jpg|thumb|150px|Project photo caption.|right]]

The goal of the can launching fridge was to create a fridge that would, when initiated by either a remote control or a wired push button, automatically load, aim, and fire a can to multiple predetermined locations. The fridge uses a combination of stepper motors, a DC motor, and solenoids to create the ultimate mix of convenience, fun, and refreshment.

 

=== [[High Speed Motor Control]] ===

[[Image:2dofArmSetUp.jpg|thumb|150px|Project photo caption.|right]]
The project suggested was to design a system for high speed motor control using the PIC 32. To demonstrate the motor control, a two degree of freedom (2-DOF) parallelogram robot arm was designed to follow paths specified in a MATLAB gui.

 

=== [[Variable Frequency Electrosense]] ===

[[Image:TR_JP_PP-sensor.jpg|thumb|150px|Project photo caption.|right]]

Our objective was to build upon existing research being done at Northwestern utilizing Electrosense technology by testing if information can be derived from varying the emitter frequency. We sought to send sinusoidal waves at discrete frequencies between 100 Hz and 10 kHz and to read in the sensed wave using a PIC 32’s ADC. We then sent the gathered information to a PC for plotting and analysis. By mounting the sensor on a one dimensional linear actuator we are able to gather additional data about objects and perform object detection and identification algorithms. While our initial results have revealed exciting trends, farther research is necessary before any significant conclusions can be made. A [http://www.youtube.com/watch?v=PJY097L2m1M video] of the project is available on YouTube.

 

=== [[Remote Controlled Wiitar]] ===

[[Image:Persistence of Vison Display|thumb|150px|Project photo caption.|right]]
This project uses an array of solenoids to depress stings on the neck of a guitar. A motor over the strings of the guitar turns an arm which strums the instrument, playing the chord depressed by the solenoids. The system is controlled by a Wii Remote.

 

=== [[6-DOF PPOD]] ===

[[Image:Persistence of Vison Display|thumb|150px|Project photo caption.|right]]
The PPOD-mini is a miniaturized version of the Programmable Part-feeding Oscillatory Device ([http://lims.mech.northwestern.edu/projects/frictioninducedforcefields/index.htm PPOD]) found in the Laboratory for Intelligent Mechanical Systems (LIMS).

 

== ME 333 Final Projects 2009 ==

=== [[Mozart's Right Hand]] ===
[[Image:mrh_box.JPG|thumb|150px|Mozart's Right Hand|right]]
Mozart's Right Hand is a musical instrument capable of playing two full octaves of the [http://en.wikipedia.org/wiki/Diatonic_scale Diatonic Scale.] The user wears a glove on his right hand and uses motions of the hand and fingers to create different notes that are played with a speaker. The pitch of the note is controlled by the orientation of the user's hand as he rotates it ether from the wrist, the elbow, or the shoulder. The LCD on the front of the box tells the user the pitch that corresponds to his or her current hand orientation. When the user touches together his thumb and index finger, the speaker plays the tone. A [http://www.youtube.com/watch?v=vec-W4QeHQU video] of Mozart's Right Hand in action is available on YouTube.

'''Chosen the OUTSTANDING PROJECT by the students of ME 333.'''

 

=== [[Persistence-of-Vision Display]] ===
[[Image:Persistence of Vison Display|right|thumb|150px]]
This is a fully customizable display implemented using the concept of Persistence of Vision. User-specified images (and even moving images) were displayed by rotating a column of LEDs at speeds faster than 300rpm. Each individual LED was modeled as a row of pixels. Conversely, the rotational position of the panel of LEDs represented the pixel columns of the display; the time interval and rotational speed determined the width of the pixel columns.

 

=== [[Rock Paper Scissors Machine]] ===
[[Image:rps whole thing.JPG|thumb|150px|Rock Paper Scissors Machine|right]]
A machine that will play a fully functioning, intuitive game of [http://en.wikipedia.org/wiki/Rock-paper-scissors Rock/Paper/Scissors] (abbreviated as RPS) with a user. The machine is represented by a human-like hand, capable of seperate and independant wrist, arm, finger and thumb motion. The players' hand goes into a glove equipped with flex sensors, which wirelessly transmits data to the machine based on what the player chose. The machine then reads this data, randomly chooses a throw of its own, and displays what the machine threw, what the human threw, total win/loss/tie info, and winner/loser both on an [http://en.wikipedia.org/wiki/Lcd LCD] screen and in the form of a thumbs up/down/side motion. Video of the machine in action can be found [http://www.youtube.com/watch?v=xbLNBSTTrcE here.]
 

=== [[Three-speaker Chladni Patterns]] ===
[[Image:chladni_660hz|right|thumb|150px]]
This project uses three speakers to generate shapes on a circular aluminum plate depending on which frequency the speakers are playing at. Once the speakers hit a resonant frequency of the plate, salt migrates to the nodes (zero amplitude) regions of the plate to form distinct patterns.
 

=== [[Basketball]] ===
[[Image:Mechatronics2009Bball|right|thumb|150px]]
This project consists of a throwing arm propelled by a Pittman motor is mounted on a turntable and throws the ball into the "hoop." The hoop is wrapped in reflective tape and an IR emitter, receiver pair is used to sense where the IR is reflected most (the hoop with highly reflective tape). An ultrasonic sensor then pings the hoop for the distance of the hoop. With this information, the arm is able to "make a basket." A video can be found [http://www.youtube.com/watch?v=Y466dzP-qiY here].
 

=== [[Robot Drummer]] ===
[[Image:Robot_Drummer.jpg|thumb|400pix|right|Robot Drummer]]
The Robot Drummer is a device that demonstrates high-speed motor control by being able to drum when given commands. Through an RS232 cable, Matlab sends commands to a "master" PIC. The master then sends the commands to two "slave" PICs through I2C communication. The slaves take the commands and implement PID control of the motors.
 

=== [[Automated Fish Refuge]] ===
[[Image:Entire Fish Refuge|right|thumb|200px]]
The automated fish refuge allows for the controlled movement of a fish refuge with the goal of recording specific behavior. The mechanical design is completely adjustable and allows adjustable degrees of oscillating movement and orientation of the refuge. The program is primarily in MATLAB for ease of use and the velocity profile can be a sine, square, triangle, or any function that the user inputs. [http://www.youtube.com/watch?v=wGOKujMhN88 Check out the video!]

 

=== [[Marionette]] ===
[[Image: MarionettePicForIntro.JPG|right|thumb]] The Marionette Project focused on using RC Servos to make a puppet that would do a dance with the press of a button. There were 5 different dances programmed for the marionette, showcasing different styles of movement. The movement had 2 degrees of freedom thanks to using 5 bar linkages and 2 RC servos for each arm. Two more RC Servos were used on the back of the marionette to create the appearance of leg movement. The movements included a Hula dance, Jumping Jacks, and even some moves right out of Saturday Night Fever.

 

=== [[Monkeybot]] ===
[[Image:monkeybot_pic|thumb|right|200px|Monkeybot]]
The monkeybot is a swinging robot capable of moving side to side and climbing. It consists of a two link, double pendulum system with an electro-magnet on each end. At the pivot is a DC motor, which provides an input torque and allows the swinging system to gain energy and climb. Check out the video of the monkeybot climbing [http://www.youtube.com/watch?v=TA2VcH_GDJ0 here] and a later brachiation video [http://www.youtube.com/watch?v=0hfwJEVQyeQ&feature=related here].
 

=== [[PPOD-mini: 6-DOF Shaker]] ===
[[Image:PPOD_mini.JPG|thumb|200x200 px|right|PPOD-mini 6-DOF Shaker]]
The PPOD-mini is a miniaturized version of the Programmable Part-feeding Oscillatory Device ([http://lims.mech.northwestern.edu/projects/frictioninducedforcefields/index.htm PPOD]) found in the Laboratory for Intelligent Mechanical Systems (LIMS) at Northwestern. The PPOD-mini utilizes six speakers that act like actuators. The speakers are connected to a acrylic plate via flexures of tygon and iron. In its current implementation, the phase of the speakers can be controlled independently, giving the device six degrees of freedom. The movement of objects placed on the acrylic plate can be controlled by changing the phases of the speakers.

 

=== [[Automated Xylophone]] ===
[[Image:AutomatedXylophonePicture1.jpg|thumb|200x200 px|right|Automated Xylophone]]
The Automated Xylophone controls several solenoids which hit various pitches on an actual xylophone based on the note selected. The device has two main modes: using the keypad, a user can choose to either play notes in real time or store songs to be played back later. A video of the Automated Xylophone playing in real time mode can be found [http://www.youtube.com/watch?v=_ubpAEyq9kg here].

 

=== [[Vision-based Cannon]] ===
[[Image:SM_Gun_Camera_PIC_Setup.JPG|thumb|200x200 px|right|Vision-based Cannon]]
This project uses a webcam and Matlab to analyze an image and direct a modified USB Missile Launcher to fire at targets found in the image.

 

=== [[Butterfly Rolling Manipulation]] ===
[[Image:Persistence of Vison Display|right|thumb|150px]]
The Butterfly emulates contact juggling by the stabilization of dynamic rolling. The apparatus rolls a cylinder by rotating the "hand" using a specific trajectory and is able to move the cylinder from one side to the other without losing contact. A video of the Butterfly captured in high speed can be found [http://www.youtube.com/watch?v=hFafcjA_p7E here].

 

== ME 333 Final Projects 2008 ==

=== [[IR Tracker]] ===

[[Image:IR_Tracker_Main.jpg|right|thumb|200px]]

The IR Tracker (aka "Spot") is a device that follows a moving infrared light. It continuously detects the position of an infrared emitter in two axes, and then tracks the emitter with a laser. [[Media:MT_MS_AZ_TrackerVideo.mp4|See Spot Run.]]

'''Chosen the OUTSTANDING PROJECT by the students of ME 333.'''

 

=== [[Robot Snake]] ===
[[Image:HLSSnakeMain.jpg|right|thumb|200px]]

This remote control robotic snake uses servo motors with a traveling sine wave motion profile to mimic serpentine motion. The robotic snake is capable of moving forward, left, right and in reverse.

[http://www.youtube.com/watch?v=r_GOOFLnI6w Video of the robot snake]

Featured on [http://blog.makezine.com/archive/2009/03/well_documented_robotic_snake.html Makezine.com].
 

=== [[Programmable Stiffness Joint]] ===

[[Image:SteelToePic2.jpg|thumb|200px|The 'Steel Toe' programmable stiffness joint|right]]

The Programmable Stiffness Joint varies rotational stiffness as desired by the user. It is the first step in modeling the mechanical impedance of the human ankle joint (both stiffness and damping) for the purpose of determining the respective breakdown of the two properties over the gait cycle.

 

=== [[Magnetic based sample purification]] ===

 

=== [[Continuously Variable Transmission]] ===

[[image:CVT_system.JPG|thumb|200px]]

This prototype is a proof of concept model of a variable ratio transmission to be implemented in the 2008-2009 Formula SAE competition vehicle. The gear ratio is determined by the distances between the pulley halves which are controllable electronically.

 

=== [[Granular Flow Rotating Sphere]] ===
[[Image:Team-21-main-picture.JPG|right|thumb|200px]]
This device will be used to study the granular flow of particles within a rotating sphere. The sphere is filled with grains of varying size and then rotated about two different axes according to a series of position and angular velocity inputs.

 

=== [[Vibratory Clock]] ===

[[Image:Vibratory_Clock.jpg|right|thumb|Vibratory Clock|200px]]

The Vibratory Clock allows a small object to act as an hour "hand" on a horizontal circular platform that is actuated from underneath by three speakers. The object slides around the circular platform, impelled by friction forces due to the vibration. [http://www.youtube.com/watch?v=KhgTNCfdwZw Check it out!]

 

=== [[WiiMouse]] ===

[[Image:HPIM1027.jpg|right|thumb|200px]]

The WiiMouse is a handheld remote that can be used to move a cursor on a windows-based PC, via accelerometer input captured through device movement.

 

=== [[Intelligent Oscillation Controller]] ===

[[image:ME333_learning_oscillator.jpg|thumb|200px]]

This device "learns" a forcing function that is applied to a spring and mass system to match an arbitrary, periodic acceleration profile.

 

=== [[Baseball]] ===

[[Image:Baseball_Playfield.jpg|Sweet Baseball Game|right|thumb|200px]]

An interactive baseball game inspired by pinball, featuring pitching, batting, light up bases and a scoreboard to keep track of the game.

 

=== [[Ball Balancing Challenge]] ===

[[Image:Ballbalancechallenge.JPG|right|thumb|200px]]

An interactive game involving ball balancing on a touchscreen with touchscreen feedback and joystick action.

File:Music from the heart overview.jpg

2010-03-17T08:51:03Z

EricWest: James wearing the music suit and connected to the heart monitor to drive the drum. For the Music from the Heart project.

James wearing the music suit and connected to the heart monitor to drive the drum. For the Music from the Heart project.

Music from the Heart -- Music Suit

2010-03-17T08:47:15Z

EricWest:

=Introduction=

This project attempted to create a natural form of musical expression by connecting sensors to the body. Six tilt switches were attached to the wrist, ankles, and shoulders, each controlling a single pitch from the [http://en.wikipedia.org/wiki/Pentatonic_scale pentatonic scale]. The heart beat was obtained using [http://en.wikipedia.org/wiki/Photoplethysmograph photoplethysmography] on the user's finger, and this signal was used to strike a drum in sync with the heart beat.

For a video demonstration, click [http://www.youtube.com/watch?v=YyipByy7m6I here].

==Team Members==

[[Image:Mfth team picture.JPG|thumb|200px|From left: Thomas, Eric, James]]
*Thomas Peterson (Computer Engineering, 2010)
*James Rein (Biomedical Engineering and Music Cognition, 2010)
*Eric West (Mechanical Engineering, 2011)

=Subsystems=

Although intended as a single, cohesive system that would allow the user to intuitively make music, the project was easily divided into three subsystems: heart rate monitor, drum actuation, and music tones. Below is more explanation about each subsystem.

==Heart rate monitor - Concepts==

In brainstorming how to translate a heart beat into a drum beat, we decided that the least intrusive method would be the best. Attaching electrodes to the user would simplify the process of identifying a heart beat, but attaching the sensors directly to the skin would be a time-consuming and personally-invasive process. Instead, we decided a finger tip sensor would be much more comfortable and easy to use.

To make a finger tip sensor, we used the concepts of [http://en.wikipedia.org/wiki/Photoplethysmograph photoplethysmography]. Photoplethysmography is typically used in [http://en.wikipedia.org/wiki/Pulse_oximeter pulse oximeters] and finger-tip sensors in commercially-available devices. We originally tried to hack a heart rate monitor that we had purchased, but this proved difficult, so we decided to make our own.

The basic concept of photoplethysmography is that blood reflects a certain amount of IR light, and the blood density in the finger changes as the heart pumps, so the IR reflectivity of the finger changes as the heart beats. Using an IR emitter-detector pair found in the mechatronics lab followed by lots of amplification and filtering, we were able to obtain a decent signal with peaks when the user's heart beat.

===Heart rate monitor - Electrical Design===

The signal coming directly out of the IR detector was very weak and noisy. To obtain just the information we desired, we ran it through the following filters and amplifiers:

# [[Passive Filters#High-Pass Filter (HPF)|Passive High-Pass Filter]]
# [[Operational Amplifiers (Op-Amps)#Inverting Amplifier|Inverting Amplifier]]: gain = -470
# [http://en.wikipedia.org/wiki/Low-pass_filter#Active_electronic_realization Active Low-pass filter]: cutoff frequency = 4.82Hz, gain = -70
# [http://www.electronics-tutorials.ws/filter/filter_7.html Band-pass filter]: Frequency range = 0.72 to 3.39Hz, inverting gain = -46.8
# [[Comparators|Comparator]]: output to the PIC pin A14, with pull-up resistor to 3.3V and capacitors to smooth out the signal.

The complete signal processing circuit is shown below.

[[Image:Heartrate monitor.PNG|thumb|center|900px|Heart rate monitor circuit diagram. Click for larger image.]]

===Heart rate monitor - Mechanical Design===

[[Image:Heart rate sensor mfth.JPG|thumb|200px|Heart rate sensor with the latex band pulled away so that the emitter-detector is revealed]]
The sensor itself was a QRB1114 emitter-detector pair that was encased in open-cell foam insulation. We inserted it into the foam by drilling and filing a hole in the foam to the appropriate size, and gluing the sensor in place. A round, finger-shaped groove was filed into the foam and the sensor sat flush with the bottom of this groove. The user's finger was held in the correct position with relatively constant pressure using a latex band around the finger and the foam enclosure.

==Drum actuator - Electrical design==

Once the signal from the heart rate sensor is sent to the PIC, the rising edge triggers an interrupt which starts the driving sequence for the motor that strikes the drum. The drive sequence was: drive down (into drum) 100ms, drive up 75ms, wait 150ms. The interrupt does not do the entire driving sequence, it merely flags a variable to start the sequence, which is done in the main loop, as seen in the code below.

An additional interrupt was triggered by the falling edge of the signal; this falling edge interrupt added additional wait time that prevented the PIC from being "fooled" by a noisy falling edge. For instance, if the falling signal had some noise in it, the rising edge interrupt would be triggered again, thus causing the drum to strike on both the rising and falling edges of the heartbeat. We only wanted one strike per heartbeat, so the falling edge interrupt was triggered by the ''first'' falling edge, and any noise in the falling edge was ignored because the PIC was told to wait for 300ms. With a maximum delay of 150 + 300 = 450ms from the two interrupts, and 100 + 75 = 175ms of drive time, the fastest heartbeat our drum could play was 96 beats per minute, but we did not expect anyone to come play the instrument after running, so this was plenty high for our purposes. '''IS MY MATH CORRECT?? SEEMS SLOW TO ME, BUT I GUESS WE HAD TO DO WHAT WE HAD TO DO'''

Initially, we tried skipping the comparator and sending the analog signal directly into one of the PICs analog inputs. Our intention was to use the fast Fourier transform (FFT) library to try to extract the dominant frequency (see [[PIC32MX: FFT of Analog Input]] for more information). Unfortunately, we ran into various problems. First, to get the accuracy we wanted for small frequencies, the sample window had to be very long (10 seconds or more), which made the output lag changes in heart rate. Additionally, the FFT was often "messy", which messed up our original algorithm of detecting the peak frequency between .5 and 2.5 hz. The system would sometimes randomly switch between very different frequencies, and although it was right most of the time it was enough to make the drum beating sound bad. We also tried algorithms to find the [http://en.wikipedia.org/wiki/Fundamental_frequency fundamental frequency] using the entire FFT (instead of just the .5-2.5 hz range), but this was still unreliable. We considered FFT peak detection algorithms, but they seemed to complex for the time and computing power we had available. Because of all this, we went with the simple comparator in the end.

The motor for driving the drumstick was driven by an [[media:L298N.pdf|L298 H-bridge]]. See [[Driving a high current DC Motor using an H-bridge]] for more information on how this works. Our particular circuit diagram is shown below:

[[Image:T21_motorckt_png.PNG|thumb|center|600px|Motor Circuit (non-motor PIC connections not shown). Click for larger image.]]

====Drum actuator - Mechanical Design====

[[Image:Drum stick mount mfth.jpg|thumb|200px|Attachment for the drumstick to the motor shaft.|right]]
We wanted to use a real drum for our drum beat, so our challenge was to attach a motor and drumstick to a drum. We chose a small rack tom for its resonant tone that is reminiscent of a heart beat.

To attach the drumstick to the motor shaft, we used a small block of acrylic (.5"x.75"x2"). The drumstick was cut down to 8" in length so that it would require less torque from the motor. In one end of the block, a hole was drilled and the drumstick was sanded to the correct diameter in order to snuggly fit into the hole. To ensure that the drumstick could not slide out of the block, a screw was placed in a hole drilled through both the stick and the block. The other end of the block was attached to the motor shaft using a split-clamp method: A hole the size of the motor shaft was drilled through the block, and then a slit was cut from the end of the block to the hole, allowing a screw to tightly clamp the block around the motor.

[[Image:Motor mount mfth.jpg|thumb|200px|Mounting bracket for the motor-stick assembly.|right]]
To attach the motor-stick assembly to the drum, we utilized the tuning screws on the drum and holes in the face of the motor. A sheet metal bracket with holes in the appropriate places attached the motor to two of the tuning screws. The bracket was easily made by cutting and bending a piece of 16 gauge steel sheet metal to the appropriate size. Ideally, this part would have been made out of one continuous piece of sheet metal, but we could not find a large enough sheet available in the shop, so we used rivets to connect two smaller pieces together.

After testing the drum striking, we decided it was too loud. To dampen the sound, we taped a piece of foam core and a shop rag to the head of the drum where the stick strikes it.

'''Parts list for drum actuator'''
*Bargain drumstick, at least .5" in diameter
*Small block of acrylic, .5"x.75"x2" (aluminum would work just as well, this is what was available)
*16 gauge steel sheet metal for bracket
*2 pop rivets
*Screws and nuts
*Foam core, shop rag, tape for dampening

==Music Tones - Electrical Design==
The music tones were activated by tilt switches and generated using a [http://pdf1.alldatasheet.com/datasheet-pdf/view/82065/YAMAHA/YMZ284.html YMZ284] chip and were output through a 1/8" jack to a standard set of computer speakers.

Each YMZ284 is capable of producing and mixing any combination of three tones. Since we wanted to have six notes from a [http://en.wikipedia.org/wiki/Pentatonic_scale pentatonic scale], we needed two of these chips and used an [[Operational Amplifiers (Op-Amps)#Summer|summing opamp circuit]] to combine outputs from each chip. We envisioned a possibility of adding [http://en.wikipedia.org/wiki/Overtone overtones] to each note, to make them sound better and more like a real instrument, so we ended up having four YMZ284s attached to our board. When we tried adding an overtone an octave above the fundamental frequency, it ended up sounding harsh and whiny. We decided the tones sounded better with no overtones, so we are only using 2 of the 4 chips on our board.

The YMZ284 communicates with the PIC over an 8-bit databus, plus additional pins for chip select, address, write enable, and reset. All four of our YMZ284s shared all of their pins ''except'' the chip select line; each required their own individual chip select line so that the PIC could specify with which chips it wanted to talk. The circuit diagram below shows how the chips were connected to the PIC and the summing circuit that followed.

{{multiple image
| align = center
| width = 500
| image1 = T21_musicckt_png.PNG
| caption1 = Music circuit diagram. The summing amplifier is not shown.
| image2 = Solder board mfth.jpg
| alt2 = Red cartouche
| caption2 = Music chips are in the center of the board. H-bridge for motor driving is on the far right, along with the power supply plug. The left side is an unsuccessful attempt at moving the heart rate circuitry to the solder board
}}

===Tilt switches - Electrical Design===
In order to detect when the limbs of the user had moved past a certain critical angle, we chose to use tilt switches. We purchased our tilt switches for $2 each from [http://www.goldmine-elec-products.com/prodinfo.asp?number=G16881 Electronics Goldmine]. We chose to use tilt switches instead of an accelerometer because the switches were much cheaper and we figured they would be easier to work with.

The tilt switches we chose are optically-based with an emitter and detector that are selectively blocked by a small ball. When the critical angle is achieved, the tiny ball rolls up a ramp, allowing the emitter to shine directly on the detector, and current flows. When the angle is neutral, the ramp forces the ball to block the light, making current stop flowing through the phototransistor. The "ramp" is really an inverted cone, so the switch can be activated by a change in angle in any direction away from the neutral position. We purchased three different tilt switches to try, each with a different critical angle - 15, 30, and 45 degrees. The configuration we ended up using was:

*30 degrees for shoulders and ankles
*45 degrees for elbows

In hindsight, we would have used all 45-degree switches because they produced the sharpest jump from off to on. The 15-degree switches were practically unusable because they created a large amount of noise as they switched on and off.

We used the tilt switches to provide high-low inputs to the PIC to tell it when to turn on any of the six tones. By attaching these switches to the body such that they are in the neutral position when the body is relaxed, we were able to control the six tones by moving the body in relatively natural ways.

===Tilt switches - Mechanical Design===

[[Image:Wrist sensor mfth.JPG|thumb|200px|Wrist tilt sensor. Ankles are similar, with a larger strap.]]
The switches were attached to the user's body using adjustable straps and buckles. The wrist and ankle sensors were simply a loop of webbing with an adjustable buckle attached. The straps could be tightened or loosened to fit any size user. To attach the switch to the straps, we created an enclosure for each switch out of high-density foam (left over scraps from DSGN 307). The switch was jammed into a hole in the foam so that it could not easily be moved. The foam was then taped to the straps using electrical tape.

The shoulder straps were a bit more involved. Two loops with buckles, similar to the wrist and ankle straps, went over the user's shoulder and underneath their armpit. To keep these straps from sliding off the shoulders, a large strap across the user's back connected the two smaller straps together. This large strap was also used for mounting the solder board which gathered the wires from all six tilt switches and sent them to the PIC over one ribbon cable. Using this strap configuration, we found that the user could comfortably and securely wear the sensors.

[[Image:Shoulder sensors mfth.JPG|thumb|200px|Shoulder straps containing the tilt sensors.]]
To attach the switches to the shoulders, we again created a foam encasement. However, electrical tape was not secure enough to hold the foam pieces to the irregularly-shaped shoulder straps. Instead, we riveted a piece of canvas to the webbing straps. We chose to use rivets instead of sewing because the sewing machine could not tightly sew the foam encasement in place. With rivets, we were able to pull the canvas tightly around the foam so that it couldn't move.

=Code=
To download the entire C file, click [[Media:Main_music.c|here]]. Below, the file is split into sections for comments.

/**********************************************************
* main_music.c: Main c file for "Music Suit" project
*
* Thomas Peterson, James Rein, Eric West
* ME333 Winter 2010
**********************************************************/

#include <HardwareProfile.h>
#include <delays.c> //Delayms and Delayus functions

The first section defines all the input and output pins, used with the motor, sensor, and music circuits.

////////////////////////////////////////////////////
//Pin Defines

//YMZ Chip selects
#define CS1 LATCbits.LATC2
#define CS2 LATCbits.LATC3
#define CS3 LATCbits.LATC4
#define CS4 LATGbits.LATG6
//YMZ communication pins
#define NWR LATBbits.LATB0 //"Not WRite": active low write line
#define A0 LATBbits.LATB6 //Address 0
#define NIC LATCbits.LATC1 //"Not Input Clear": active low reset line
//YMZ data pins
#define D0 LATGbits.LATG9
#define D1 LATEbits.LATE8
#define D2 LATEbits.LATE9
#define D3 LATBbits.LATB5
#define D4 LATBbits.LATB4
#define D5 LATBbits.LATB3
#define D6 LATBbits.LATB2
#define D7 LATBbits.LATB1

//Tilt inputs
#define ENC PORTDbits.RD3
#define END PORTDbits.RD2
#define ENE PORTDbits.RD1
#define ENG PORTCbits.RC14
#define ENA PORTCbits.RC13
#define ENC5 PORTDbits.RD0

//Motor outputs
#define IN1 LATBbits.LATB7
#define IN2 LATAbits.LATA9
#define EN LATAbits.LATA10

///////////////////////////////////////
//Other defines
//Motor times
#define MS(x) x*312.5
#define DRIVETIME MS(100)
#define BACKTIME MS(75)
#define WAITTIME MS(150)
//Channels
#define CHNA 1
#define CHNB 2
#define CHNC 4

//////////////////////////////////////////
//Function definitions
void write_chip(int address, int data);
void portout(int byte);
void channelSw(int chip, int chn, int *mixer, int state);
//Global variables
int mixer1, mixer2;
int motorflag = 0;
The initialization function sets up various parts of the system.
/* init() : This function runs initializations, setting up the pic and music chips */
void init() {
int pbClk = SYSTEMConfigPerformance(SYS_FREQ);

/////////////////////////////////////////////
//Setup inputs / outputs
AD1PCFG = 0xFFFF; //All digital inputs
TRISG &= 0xFDBF; //sets G9,G6 to 0 (output); all else remains the same
TRISC &= 0xFFE1; //sets C4,C3,C2,C1 to 0s (outputs); all else remains the same
TRISB &= 0xFF80; //sets B0-B6 0 (output)
TRISE &= 0xFCFF; //sets E8,9 to output
TRISB |= 0xF000; //sets B12,B13,B14,B15 to 1s (inputs); all else remains the same
TRISC |= 0x6000; //sets C14,13 to inputs
TRISD |= 0x000F; //Sets D0,D1,D2,D3 to inputs
TRISDbits.TRISD4 = 0; //Output for clock
//Motor outputs
TRISAbits.TRISA9 = 0;
TRISAbits.TRISA10 = 0;
TRISBbits.TRISB7 = 0;
//Pulse inputs
TRISAbits.TRISA14 = 1;
TRISAbits.TRISA15 = 1;
//ODC setup
ODCCbits.ODCC1 = 1; //open drain control; can only float high (when set high) or pull low

/* Initialize outputs */
//YMZs
CS1 = 1;
CS2 = 1;
CS3 = 1;
CS4 = 1;
NWR = 1;
A0 = 0;
NIC = 1;
//Motor
IN2 = 0;
IN1 = 0;
EN = 0;

Delayms(100); //wait for power supply to ramp up
NIC = 0; //resets YMZ284s
Delayms(10);
NIC = 1;

In the init() function, the pic writes all the setup data to the music chips. This includes the frequency registers, which determine the frequency of each output, the mixer, which determines which channels are on or off (1 = off), and the volume registers, which determine the volume of each channel. After the setup, the only register that is changed in normal operation is the mixer register, which merely turns channels on and off.
//////////////////////////////////////////////////
//Setup music chips
//Setup Chip 1//
CS1 = 0;
write_chip(0x00,0xC7); //a low // C4
write_chip(0x01,0x01); //a high
write_chip(0x02,0x98); //b low // D
write_chip(0x03,0x01); //b high
write_chip(0x04,0x6E); //c low
write_chip(0x05,0x01); //c high // E
write_chip(0x07,0xFF); //mixer (0 enables)
write_chip(0x08, 0x0A); //level (volume) A
write_chip(0x09, 0x0A); //level (volume) B
write_chip(0x0A, 0x0A); //level (volume) C
CS1=1;
//Setup Chip 2//
CS2 = 0;
write_chip(0x00,0x2C); //a low //G 392
write_chip(0x01,0x01); //a high
write_chip(0x02,0x0D); //b low //A 440
write_chip(0x03,0x01); //b high
write_chip(0x04,0xE3); //c low //C5 523.25
write_chip(0x05,0x00); //c high
write_chip(0x07,0xFF); //mixer (0 enables)
write_chip(0x08, 0x0A); //level (volume) A
write_chip(0x09, 0x0A); //level (volume) B
write_chip(0x0A, 0x0A); //level (volume) C
CS2=1;

mixer1=0xFF;
mixer2=0xFF;
OC5 is used to create a PWM signal with 50% duty at 4Mhz, in effect creating a 4Mhz square wave. This is used by the music chips as a master clock.
//////////////////////////////////////////////
//Setup OC to create master clock for music chips (~4 Mhz)
OpenOC5( OC_ON | OC_TIMER2_SRC | OC_PWM_FAULT_PIN_DISABLE, 0, 0);
OpenTimer2( T2_ON | T2_PS_1_1 | T2_SOURCE_INT, 20);
SetDCOC5PWM(10);
The interrupts are used, as mentioned above, to control when the motor is driven. The motor should drive once every rising edge.
/////////////////////////////////////////////
//External interrupt setups (for motor) - INT3 (A14)
mINT3ClearIntFlag();
mINT3IntEnable(1);
mINT3SetIntPriority(6);
mINT3SetEdgeMode(1); //Rising edge
/////////////////////////////////////////////
//External interrupt setups (for motor) - INT4 (A15)
mINT4ClearIntFlag();
mINT4IntEnable(1);
mINT4SetIntPriority(5);
mINT4SetEdgeMode(0); //Falling edge
INTEnableSystemMultiVectoredInt();

/////////////////////////////////////////////
//Setup motor timer (used for timing delays)
OpenTimer3(T3_ON | T3_PS_1_256 | T3_SOURCE_INT, 0xFFFF);
ConfigIntTimer3(T3_INT_OFF);
}

Main function
/* Main function */
int main()
{
init(); /* Run initialization functions */
Delayms(1);

/* Main while loop: loop indefinietly */
while (1) {
In the main while loop, the PIC checks every cycle to see if an input has changed since the last cycle. Since the "mixer" variables store the current state, if an input does not match up with its valid mixer bit then it has changed recently. In this case, the channelSw() function is called to switch on or off the music channel controlled by that bit.
//Check for state changes in music notes
if (ENC != (mixer1 & 0x01)) { channelSw(1,CHNA,&mixer1,!ENC); } //If input ENC (enable C) is not equal to the state of channel A1 (note c), change the state
if (END != (mixer1 & 0x02)) { channelSw(1,CHNB,&mixer1,!END); }
if (ENE != (mixer1 & 0x04)) { channelSw(1,CHNC,&mixer1,!ENE); }
if (ENG != (mixer2 & 0x01)) { channelSw(2,CHNA,&mixer2,!ENG); }
if (ENA != (mixer2 & 0x02)) { channelSw(2,CHNB,&mixer2,!ENA); }
if (ENC5 != (mixer2 & 0x04)) { channelSw(2,CHNC,&mixer2,!ENC5); }
During the main while loop, the motor flag variable is checked to see if the motor should be driven. If so, it enters a sequence where it uses timer3 to determine the current stage in the motor cycle, changing the outputs as needed.
//Check for motor state changes
switch (motorflag) {
case 0: break; //Do nothing (motor off)
case 1: //Start motor cycle
WriteTimer3(0); //Reset timer to 0
IN1 = 0; //Set H bridge to forward drive
IN2 = 1;
EN = 1;
motorflag = 2; //In drivedown cycle
break;
case 2: //Drivedown cycle
if (ReadTimer3() > DRIVETIME) { //Wait for DRIVETIME to pass
WriteTimer3(0); //Reset timer to 0
motorflag = 3; //In driveup phase
IN2 = 0; //Switch H bridge
IN1 = 1;
}
break;
case 3: //Driveup cycle
if (ReadTimer3() > BACKTIME) { //Wait for BACKTIME to pass
WriteTimer3(0); //Reset timer to 0
motorflag = 4; //In coast/wait phase
EN = 0; //Turn off motor
}
break;
case 4: //coast / wait cycle
if (ReadTimer3() > WAITTIME) {
motorflag = 5; //more wait
WriteTimer3(0);
}
break;
case 5: //Additional wait cycle
if (ReadTimer3() > WAITTIME) {
//Done!
motorflag = 0; //Motor off (can now be triggered again)
}
break;
//Static wait cycles
case 6:
if (ReadTimer3() > WAITTIME) {
motorflag = 7;
WriteTimer3(0);
}
break;
case 7:
if (ReadTimer3() > WAITTIME) {
WriteTimer3(0);
motorflag = 8;
}
break;
case 8:
if (ReadTimer3() > WAITTIME) {
motorflag = 0;
}
break;
}

Delayms(10);
}
return 0;
}//end main

Write chip function, which is a support function that writes data to the music chips.
/* write_chip: This writes the given byte "data" to the "address" (0 or 1)
on a YMZ284. It is assumed that the chip select is already low */
void write_chip(int address,int data) {
//Write address
portout(address);
A0 = 0; //select address mode
Delayus(1); //setup time
NWR = 0; //Write cycle begin
Delayus(1); //hold time
NWR = 1; //Write cycle end

//Write data
portout(data);
A0 = 1; //select data mode
Delayus(1); //setup time
NWR = 0; //write cycle begin
Delayus(1); //hold time
NWR = 1; //write cycle end
}
Port out function
/* port_out: This function outputs a byte to the D0-D7 port */
void portout(int byte) {
// Note: !! converts an integer expression to a boolean (1 or 0).
D0 = !!(byte & 1);
D1 = !!(byte & 2);
D2 = !!(byte & 4);
D3 = !!(byte & 8);
D4 = !!(byte & 16);
D5 = !!(byte & 32);
D6 = !!(byte & 64);
D7 = !!(byte & 128);
}
Channel switch function, which writes a new mixer value to turn a channel on or off.
/* channelSw: Generic channel switch function
This writes a new mixer value to chip "chip". The mixer value
depends on "chn", the channel turning on or off, "state" whether
the channel is turning on or off, and "*mixer", a pointer to
the old mixer value. */
void channelSw(int chip, int chn, int *mixer, int state) {
/* Enable music chip */
switch(chip) {
case 1: CS1 = 0; break;
case 2: CS2 = 0; break;
case 3: CS3 = 0; break;
case 4: CS4 = 0; break;
}
/* Write mixer value */
/* This writes to channel 7 (mixer channel) the _new_ mixer value, which is
the old mixer value with a particular bit flipped based on "chn" and "state" */
write_chip(0x07, (*mixer) = state ? (*mixer) & (0xFF & ~chn) : (*mixer) | chn);
/* Disable chip */
switch(chip) {
case 1: CS1 = 1; break;
case 2: CS2 = 1; break;
case 3: CS3 = 1; break;
case 4: CS4 = 1; break;
}

}
Interrupt functions
//External interrupt for motor driving
void __ISR(_EXTERNAL_3_VECTOR, ipl6) _SingleVectorHandler(void) {
if (motorflag == 0) {
motorflag = 1; //Start motor cycle
}
//If on already, do nothing
mINT3ClearIntFlag();
}

//External interrupt for motor waiting
void __ISR(_EXTERNAL_4_VECTOR, ipl5) _SingleVectorHandler2(void) {
if (motorflag == 0) {
WriteTimer3(0);
motorflag = 6; //Start wait cycle
}
//If on already, do nothing
mINT4ClearIntFlag();
}

=Results=

The project turned out to be a mild success overall. The tilt switches worked very well for activating the music tones, but the heart rate monitor was less successful. One of the biggest issues was getting rid of very low frequency drift in the signal that made the peaks sometimes as high as 10V, but other times less 1V. Dealing with this fluctuation in peak size was the most difficult part of signal processing. As mentioned above, we tried FFT in order to establish a steady heart rate, but could not get the resolution we desired, thus we abandoned the idea.

'''PROBABLY NEED MORE TECHNICAL RESULTS HERE, BUT I'M NOT SURE WHAT TO SAY RIGHT NOW'''

The best result was that using the device was just plain fun. We each had a great time moving around and hearing the fun sounds that resulted, or if we were feeling ambitious, we would try to play a simple melody like "Mary Had a Little Lamb." It was rather difficult to play anything more complicated than that because it required lots of body control and precise movements.

=Reflections=

'''Successes'''
*tilt switches activated each of the six notes when they were supposed to
**the YMZ284 chips were able to produce all six notes at the same time, allowing cool chords
*tones were in tune and formed fun melodies and chords as the body moved
*drum actuator hit the drum reliably and with good tone
*heart rate monitor usually showed clear peaks on a scope, but was finnicky in practice

'''Room for improvements'''
*tilt switches sometimes bounced, so the beginning, or particularly the ends of the notes sounded jagged
**''Possible Solution:'' add a low pass filter to the switch signal so that the signal ramps up and down.
*the shoulder straps sometimes needed adjustments for each individual in order for the sensors to be in the correct position
**''Possible Solution:'' create straps with more constraints, such as a strap across the chest as well as the back, to ensure that the sensors are in the correct positions and orientations.
*the straps could be easier to put on
**''Possible Solution:'' maybe integrate them into a single garment, like a onesie
*the heart rate monitor was not reliable. Low frequency drift made setting a comparison level nearly impossible, especially for more than one specific user.
**''Possible Solution:'' improve FFT method so that desired resolution could be achieved in a short sample period (around 10 seconds). Or implement a complicated peak detection algorithm on the PIC.

'''JAMES SHOULD ADD SOME KIND OF HEARTWARMING CONCLUSION CUZ HE'S GOOD AT THAT STUFF'''

Music from the Heart -- Music Suit

2010-03-17T08:46:40Z

EricWest: /* Drum actuator - Electrical design */

=Introduction=

This project attempted to create a natural form of musical expression by connecting sensors to the body. Six tilt switches were attached to the wrist, ankles, and shoulders, each controlling a single pitch from the [http://en.wikipedia.org/wiki/Pentatonic_scale pentatonic scale]. The heart beat was obtained using [http://en.wikipedia.org/wiki/Photoplethysmograph photoplethysmography] on the user's finger, and this signal was used to strike a drum in sync with the heart beat.

For a video demonstration, click [http://www.youtube.com/watch?v=YyipByy7m6I here].

==Team Members==

[[Image:Mfth team picture.JPG|thumb|200px|From left: Thomas, Eric, James]]
*Thomas Peterson (Computer Engineering, 2010)
*James Rein (Biomedical Engineering and Music Cognition, 2010)
*Eric West (Mechanical Engineering, 2011)

=Subsystems=

Although intended as a single, cohesive system that would allow the user to intuitively make music, the project was easily divided into three subsystems: heart rate monitor, drum actuation, and music tones. Below is more explanation about each subsystem.

==Heart rate monitor - Concepts==

In brainstorming how to translate a heart beat into a drum beat, we decided that the least intrusive method would be the best. Attaching electrodes to the user would simplify the process of identifying a heart beat, but attaching the sensors directly to the skin would be a time-consuming and personally-invasive process. Instead, we decided a finger tip sensor would be much more comfortable and easy to use.

To make a finger tip sensor, we used the concepts of [http://en.wikipedia.org/wiki/Photoplethysmograph photoplethysmography]. Photoplethysmography is typically used in [http://en.wikipedia.org/wiki/Pulse_oximeter pulse oximeters] and finger-tip sensors in commercially-available devices. We originally tried to hack a heart rate monitor that we had purchased, but this proved difficult, so we decided to make our own.

The basic concept of photoplethysmography is that blood reflects a certain amount of IR light, and the blood density in the finger changes as the heart pumps, so the IR reflectivity of the finger changes as the heart beats. Using an IR emitter-detector pair found in the mechatronics lab followed by lots of amplification and filtering, we were able to obtain a decent signal with peaks when the user's heart beat.

===Heart rate monitor - Electrical Design===

The signal coming directly out of the IR detector was very weak and noisy. To obtain just the information we desired, we ran it through the following filters and amplifiers:

# [[Passive Filters#High-Pass Filter (HPF)|Passive High-Pass Filter]]
# [[Operational Amplifiers (Op-Amps)#Inverting Amplifier|Inverting Amplifier]]: gain = -470
# [http://en.wikipedia.org/wiki/Low-pass_filter#Active_electronic_realization Active Low-pass filter]: cutoff frequency = 4.82Hz, gain = -70
# [http://www.electronics-tutorials.ws/filter/filter_7.html Band-pass filter]: Frequency range = 0.72 to 3.39Hz, inverting gain = -46.8
# [[Comparators|Comparator]]: output to the PIC pin A14, with pull-up resistor to 3.3V and capacitors to smooth out the signal.

The complete signal processing circuit is shown below.

[[Image:Heartrate monitor.PNG|thumb|center|900px|Heart rate monitor circuit diagram. Click for larger image.]]

===Heart rate monitor - Mechanical Design===

[[Image:Heart rate sensor mfth.JPG|thumb|200px|Heart rate sensor with the latex band pulled away so that the emitter-detector is revealed]]
The sensor itself was a QRB1114 emitter-detector pair that was encased in open-cell foam insulation. We inserted it into the foam by drilling and filing a hole in the foam to the appropriate size, and gluing the sensor in place. A round, finger-shaped groove was filed into the foam and the sensor sat flush with the bottom of this groove. The user's finger was held in the correct position with relatively constant pressure using a latex band around the finger and the foam enclosure.

==Drum actuator - Electrical design==

Once the signal from the heart rate sensor is sent to the PIC, the rising edge triggers an interrupt which starts the driving sequence for the motor that strikes the drum. The drive sequence was: drive down (into drum) 100ms, drive up 75ms, wait 150ms. The interrupt does not do the entire driving sequence, it merely flags a variable to start the sequence, which is done in the main loop, as seen in the code below.

An additional interrupt was triggered by the falling edge of the signal; this falling edge interrupt added additional wait time that prevented the PIC from being "fooled" by a noisy falling edge. For instance, if the falling signal had some noise in it, the rising edge interrupt would be triggered again, thus causing the drum to strike on both the rising and falling edges of the heartbeat. We only wanted one strike per heartbeat, so the falling edge interrupt was triggered by the ''first'' falling edge, and any noise in the falling edge was ignored because the PIC was told to wait for 300ms. With a maximum delay of 150 + 300 = 450ms from the two interrupts, and 100 + 75 = 175ms of drive time, the fastest heartbeat our drum could play was 96 beats per minute, but we did not expect anyone to come play the instrument after running, so this was plenty high for our purposes. '''IS MY MATH CORRECT?? SEEMS SLOW TO ME, BUT I GUESS WE HAD TO DO WHAT WE HAD TO DO'''

Initially, we tried skipping the comparator and sending the analog signal directly into one of the PICs analog inputs. Our intention was to use the fast Fourier transform (FFT) library to try to extract the dominant frequency (see [[PIC32MX: FFT of Analog Input]] for more information). Unfortunately, we ran into various problems. First, to get the accuracy we wanted for small frequencies, the sample window had to be very long (10 seconds or more), which made the output lag changes in heart rate. Additionally, the FFT was often "messy", which messed up our original algorithm of detecting the peak frequency between .5 and 2.5 hz. The system would sometimes randomly switch between very different frequencies, and although it was right most of the time it was enough to make the drum beating sound bad. We also tried algorithms to find the [http://en.wikipedia.org/wiki/Fundamental_frequency fundamental frequency] using the entire FFT (instead of just the .5-2.5 hz range), but this was still unreliable. We considered FFT peak detection algorithms, but they seemed to complex for the time and computing power we had available. Because of all this, we went with the simple comparator in the end.

The motor for driving the drumstick was driven by an [[media:L298N.pdf|L298 H-bridge]]. See [[Driving a high current DC Motor using an H-bridge]] for more information on how this works. Our particular circuit diagram is shown below:

[[Image:T21_motorckt_png.PNG|thumb|center|600px|Motor Circuit (non-motor PIC connections not shown). Click for larger image.]]

====Drum actuator - Mechanical Design====

[[Image:Drum stick mount mfth.jpg|thumb|200px|Attachment for the drumstick to the motor shaft.|right]]
We wanted to use a real drum for our drum beat, so our challenge was to attach a motor and drumstick to a drum. We chose a small rack tom for its resonant tone that is reminiscent of a heart beat.

To attach the drumstick to the motor shaft, we used a small block of acrylic (.5"x.75"x2"). The drumstick was cut down to 8" in length so that it would require less torque from the motor. In one end of the block, a hole was drilled and the drumstick was sanded to the correct diameter in order to snuggly fit into the hole. To ensure that the drumstick could not slide out of the block, a screw was placed in a hole drilled through both the stick and the block. The other end of the block was attached to the motor shaft using a split-clamp method: A hole the size of the motor shaft was drilled through the block, and then a slit was cut from the end of the block to the hole, allowing a screw to tightly clamp the block around the motor.

[[Image:Motor mount mfth.jpg|thumb|200px|Mounting bracket for the motor-stick assembly.|right]]
To attach the motor-stick assembly to the drum, we utilized the tuning screws on the drum and holes in the face of the motor. A sheet metal bracket with holes in the appropriate places attached the motor to two of the tuning screws. The bracket was easily made by cutting and bending a piece of 16 gauge steel sheet metal to the appropriate size. Ideally, this part would have been made out of one continuous piece of sheet metal, but we could not find a large enough sheet available in the shop, so we used rivets to connect two smaller pieces together.

After testing the drum striking, we decided it was too loud. To dampen the sound, we taped a piece of foam core and a shop rag to the head of the drum where the stick strikes it.

'''Parts list for drum actuator'''
*Bargain drumstick, at least .5" in diameter
*Small block of acrylic, .5"x.75"x2" (aluminum would work just as well, this is what was available)
*16 gauge steel sheet metal for bracket
*2 pop rivets
*Screws and nuts
*Foam core, shop rag, tape for dampening

==Music Tones - Electrical Design==
The music tones were activated by tilt switches and generated using a [http://pdf1.alldatasheet.com/datasheet-pdf/view/82065/YAMAHA/YMZ284.html YMZ284] chip and were output through a 1/8" jack to a standard set of computer speakers.

Each YMZ284 is capable of producing and mixing any combination of three tones. Since we wanted to have six notes from a [http://en.wikipedia.org/wiki/Pentatonic_scale pentatonic scale], we needed two of these chips and used an [[Operational Amplifiers (Op-Amps)#Summer|summing opamp circuit]] to combine outputs from each chip. We envisioned a possibility of adding [http://en.wikipedia.org/wiki/Overtone overtones] to each note, to make them sound better and more like a real instrument, so we ended up having four YMZ284s attached to our board. When we tried adding an overtone an octave above the fundamental frequency, it ended up sounding harsh and whiny. We decided the tones sounded better with no overtones, so we are only using 2 of the 4 chips on our board.

The YMZ284 communicates with the PIC over an 8-bit databus, plus additional pins for chip select, address, write enable, and reset. All four of our YMZ284s shared all of their pins ''except'' the chip select line; each required their own individual chip select line so that the PIC could specify with which chips it wanted to talk. The circuit diagram below shows how the chips were connected to the PIC and the summing circuit that followed.

{{multiple image
| align = center
| width = 500
| image1 = T21_musicckt_png.PNG
| caption1 = Music circuit diagram. The summing amplifier is not shown.
| image2 = Solder board mfth.jpg
| alt2 = Red cartouche
| caption2 = Music chips are in the center of the board. H-bridge for motor driving is on the far right, along with the power supply plug. The left side is an unsuccessful attempt at moving the heart rate circuitry to the solder board
}}

===Tilt switches - Electrical Design===
In order to detect when the limbs of the user had moved past a certain critical angle, we chose to use tilt switches. We purchased our tilt switches for $2 each from [http://www.goldmine-elec-products.com/prodinfo.asp?number=G16881 Electronics Goldmine]. We chose to use tilt switches instead of an accelerometer because the switches were much cheaper and we figured they would be easier to work with.

The tilt switches we chose are optically-based with an emitter and detector that are selectively blocked by a small ball. When the critical angle is achieved, the tiny ball rolls up a ramp, allowing the emitter to shine directly on the detector, and current flows. When the angle is neutral, the ramp forces the ball to block the light, making current stop flowing through the phototransistor. The "ramp" is really an inverted cone, so the switch can be activated by a change in angle in any direction away from the neutral position. We purchased three different tilt switches to try, each with a different critical angle - 15, 30, and 45 degrees. The configuration we ended up using was:

*30 degrees for shoulders and ankles
*45 degrees for elbows

In hindsight, we would have used all 45-degree switches because they produced the sharpest jump from off to on. The 15-degree switches were practically unusable because they created a large amount of noise as they switched on and off.

We used the tilt switches to provide high-low inputs to the PIC to tell it when to turn on any of the six tones. By attaching these switches to the body such that they are in the neutral position when the body is relaxed, we were able to control the six tones by moving the body in relatively natural ways.

===Tilt switches - Mechanical Design===

[[Image:Wrist sensor mfth.JPG|thumb|200px|Wrist tilt sensor. Ankles are similar, with a larger strap.]]
The switches were attached to the user's body using adjustable straps and buckles. The wrist and ankle sensors were simply a loop of webbing with an adjustable buckle attached. The straps could be tightened or loosened to fit any size user. To attach the switch to the straps, we created an enclosure for each switch out of high-density foam (left over scraps from DSGN 307). The switch was jammed into a hole in the foam so that it could not easily be moved. The foam was then taped to the straps using electrical tape.

The shoulder straps were a bit more involved. Two loops with buckles, similar to the wrist and ankle straps, went over the user's shoulder and underneath their armpit. To keep these straps from sliding off the shoulders, a large strap across the user's back connected the two smaller straps together. This large strap was also used for mounting the solder board which gathered the wires from all six tilt switches and sent them to the PIC over one ribbon cable. Using this strap configuration, we found that the user could comfortably and securely wear the sensors.

[[Image:Shoulder sensors mfth.JPG|thumb|200px|Shoulder straps containing the tilt sensors.]]
To attach the switches to the shoulders, we again created a foam encasement. However, electrical tape was not secure enough to hold the foam pieces to the irregularly-shaped shoulder straps. Instead, we riveted a piece of canvas to the webbing straps. We chose to use rivets instead of sewing because the sewing machine could not tightly sew the foam encasement in place. With rivets, we were able to pull the canvas tightly around the foam so that it couldn't move.

=Code=
To download the entire C file, click [[Media:Main_music.c|here]]. Below, the file is split into sections for comments.

/**********************************************************
* main_music.c: Main c file for "Music Suit" project
*
* Thomas Peterson, James Rein, Eric West
* ME333 Winter 2010
**********************************************************/

#include <HardwareProfile.h>
#include <delays.c> //Delayms and Delayus functions

The first section defines all the input and output pins, used with the motor, sensor, and music circuits.

////////////////////////////////////////////////////
//Pin Defines

//YMZ Chip selects
#define CS1 LATCbits.LATC2
#define CS2 LATCbits.LATC3
#define CS3 LATCbits.LATC4
#define CS4 LATGbits.LATG6
//YMZ communication pins
#define NWR LATBbits.LATB0 //"Not WRite": active low write line
#define A0 LATBbits.LATB6 //Address 0
#define NIC LATCbits.LATC1 //"Not Input Clear": active low reset line
//YMZ data pins
#define D0 LATGbits.LATG9
#define D1 LATEbits.LATE8
#define D2 LATEbits.LATE9
#define D3 LATBbits.LATB5
#define D4 LATBbits.LATB4
#define D5 LATBbits.LATB3
#define D6 LATBbits.LATB2
#define D7 LATBbits.LATB1

//Tilt inputs
#define ENC PORTDbits.RD3
#define END PORTDbits.RD2
#define ENE PORTDbits.RD1
#define ENG PORTCbits.RC14
#define ENA PORTCbits.RC13
#define ENC5 PORTDbits.RD0

//Motor outputs
#define IN1 LATBbits.LATB7
#define IN2 LATAbits.LATA9
#define EN LATAbits.LATA10

///////////////////////////////////////
//Other defines
//Motor times
#define MS(x) x*312.5
#define DRIVETIME MS(100)
#define BACKTIME MS(75)
#define WAITTIME MS(150)
//Channels
#define CHNA 1
#define CHNB 2
#define CHNC 4

//////////////////////////////////////////
//Function definitions
void write_chip(int address, int data);
void portout(int byte);
void channelSw(int chip, int chn, int *mixer, int state);
//Global variables
int mixer1, mixer2;
int motorflag = 0;
The initialization function sets up various parts of the system.
/* init() : This function runs initializations, setting up the pic and music chips */
void init() {
int pbClk = SYSTEMConfigPerformance(SYS_FREQ);

/////////////////////////////////////////////
//Setup inputs / outputs
AD1PCFG = 0xFFFF; //All digital inputs
TRISG &= 0xFDBF; //sets G9,G6 to 0 (output); all else remains the same
TRISC &= 0xFFE1; //sets C4,C3,C2,C1 to 0s (outputs); all else remains the same
TRISB &= 0xFF80; //sets B0-B6 0 (output)
TRISE &= 0xFCFF; //sets E8,9 to output
TRISB |= 0xF000; //sets B12,B13,B14,B15 to 1s (inputs); all else remains the same
TRISC |= 0x6000; //sets C14,13 to inputs
TRISD |= 0x000F; //Sets D0,D1,D2,D3 to inputs
TRISDbits.TRISD4 = 0; //Output for clock
//Motor outputs
TRISAbits.TRISA9 = 0;
TRISAbits.TRISA10 = 0;
TRISBbits.TRISB7 = 0;
//Pulse inputs
TRISAbits.TRISA14 = 1;
TRISAbits.TRISA15 = 1;
//ODC setup
ODCCbits.ODCC1 = 1; //open drain control; can only float high (when set high) or pull low

/* Initialize outputs */
//YMZs
CS1 = 1;
CS2 = 1;
CS3 = 1;
CS4 = 1;
NWR = 1;
A0 = 0;
NIC = 1;
//Motor
IN2 = 0;
IN1 = 0;
EN = 0;

Delayms(100); //wait for power supply to ramp up
NIC = 0; //resets YMZ284s
Delayms(10);
NIC = 1;

In the init() function, the pic writes all the setup data to the music chips. This includes the frequency registers, which determine the frequency of each output, the mixer, which determines which channels are on or off (1 = off), and the volume registers, which determine the volume of each channel. After the setup, the only register that is changed in normal operation is the mixer register, which merely turns channels on and off.
//////////////////////////////////////////////////
//Setup music chips
//Setup Chip 1//
CS1 = 0;
write_chip(0x00,0xC7); //a low // C4
write_chip(0x01,0x01); //a high
write_chip(0x02,0x98); //b low // D
write_chip(0x03,0x01); //b high
write_chip(0x04,0x6E); //c low
write_chip(0x05,0x01); //c high // E
write_chip(0x07,0xFF); //mixer (0 enables)
write_chip(0x08, 0x0A); //level (volume) A
write_chip(0x09, 0x0A); //level (volume) B
write_chip(0x0A, 0x0A); //level (volume) C
CS1=1;
//Setup Chip 2//
CS2 = 0;
write_chip(0x00,0x2C); //a low //G 392
write_chip(0x01,0x01); //a high
write_chip(0x02,0x0D); //b low //A 440
write_chip(0x03,0x01); //b high
write_chip(0x04,0xE3); //c low //C5 523.25
write_chip(0x05,0x00); //c high
write_chip(0x07,0xFF); //mixer (0 enables)
write_chip(0x08, 0x0A); //level (volume) A
write_chip(0x09, 0x0A); //level (volume) B
write_chip(0x0A, 0x0A); //level (volume) C
CS2=1;

mixer1=0xFF;
mixer2=0xFF;
OC5 is used to create a PWM signal with 50% duty at 4Mhz, in effect creating a 4Mhz square wave. This is used by the music chips as a master clock.
//////////////////////////////////////////////
//Setup OC to create master clock for music chips (~4 Mhz)
OpenOC5( OC_ON | OC_TIMER2_SRC | OC_PWM_FAULT_PIN_DISABLE, 0, 0);
OpenTimer2( T2_ON | T2_PS_1_1 | T2_SOURCE_INT, 20);
SetDCOC5PWM(10);
The interrupts are used, as mentioned above, to control when the motor is driven. The motor should drive once every rising edge.
/////////////////////////////////////////////
//External interrupt setups (for motor) - INT3 (A14)
mINT3ClearIntFlag();
mINT3IntEnable(1);
mINT3SetIntPriority(6);
mINT3SetEdgeMode(1); //Rising edge
/////////////////////////////////////////////
//External interrupt setups (for motor) - INT4 (A15)
mINT4ClearIntFlag();
mINT4IntEnable(1);
mINT4SetIntPriority(5);
mINT4SetEdgeMode(0); //Falling edge
INTEnableSystemMultiVectoredInt();

/////////////////////////////////////////////
//Setup motor timer (used for timing delays)
OpenTimer3(T3_ON | T3_PS_1_256 | T3_SOURCE_INT, 0xFFFF);
ConfigIntTimer3(T3_INT_OFF);
}

Main function
/* Main function */
int main()
{
init(); /* Run initialization functions */
Delayms(1);

/* Main while loop: loop indefinietly */
while (1) {
In the main while loop, the PIC checks every cycle to see if an input has changed since the last cycle. Since the "mixer" variables store the current state, if an input does not match up with its valid mixer bit then it has changed recently. In this case, the channelSw() function is called to switch on or off the music channel controlled by that bit.
//Check for state changes in music notes
if (ENC != (mixer1 & 0x01)) { channelSw(1,CHNA,&mixer1,!ENC); } //If input ENC (enable C) is not equal to the state of channel A1 (note c), change the state
if (END != (mixer1 & 0x02)) { channelSw(1,CHNB,&mixer1,!END); }
if (ENE != (mixer1 & 0x04)) { channelSw(1,CHNC,&mixer1,!ENE); }
if (ENG != (mixer2 & 0x01)) { channelSw(2,CHNA,&mixer2,!ENG); }
if (ENA != (mixer2 & 0x02)) { channelSw(2,CHNB,&mixer2,!ENA); }
if (ENC5 != (mixer2 & 0x04)) { channelSw(2,CHNC,&mixer2,!ENC5); }
During the main while loop, the motor flag variable is checked to see if the motor should be driven. If so, it enters a sequence where it uses timer3 to determine the current stage in the motor cycle, changing the outputs as needed.
//Check for motor state changes
switch (motorflag) {
case 0: break; //Do nothing (motor off)
case 1: //Start motor cycle
WriteTimer3(0); //Reset timer to 0
IN1 = 0; //Set H bridge to forward drive
IN2 = 1;
EN = 1;
motorflag = 2; //In drivedown cycle
break;
case 2: //Drivedown cycle
if (ReadTimer3() > DRIVETIME) { //Wait for DRIVETIME to pass
WriteTimer3(0); //Reset timer to 0
motorflag = 3; //In driveup phase
IN2 = 0; //Switch H bridge
IN1 = 1;
}
break;
case 3: //Driveup cycle
if (ReadTimer3() > BACKTIME) { //Wait for BACKTIME to pass
WriteTimer3(0); //Reset timer to 0
motorflag = 4; //In coast/wait phase
EN = 0; //Turn off motor
}
break;
case 4: //coast / wait cycle
if (ReadTimer3() > WAITTIME) {
motorflag = 5; //more wait
WriteTimer3(0);
}
break;
case 5: //Additional wait cycle
if (ReadTimer3() > WAITTIME) {
//Done!
motorflag = 0; //Motor off (can now be triggered again)
}
break;
//Static wait cycles
case 6:
if (ReadTimer3() > WAITTIME) {
motorflag = 7;
WriteTimer3(0);
}
break;
case 7:
if (ReadTimer3() > WAITTIME) {
WriteTimer3(0);
motorflag = 8;
}
break;
case 8:
if (ReadTimer3() > WAITTIME) {
motorflag = 0;
}
break;
}

Delayms(10);
}
return 0;
}//end main

Write chip function, which is a support function that writes data to the music chips.
/* write_chip: This writes the given byte "data" to the "address" (0 or 1)
on a YMZ284. It is assumed that the chip select is already low */
void write_chip(int address,int data) {
//Write address
portout(address);
A0 = 0; //select address mode
Delayus(1); //setup time
NWR = 0; //Write cycle begin
Delayus(1); //hold time
NWR = 1; //Write cycle end

//Write data
portout(data);
A0 = 1; //select data mode
Delayus(1); //setup time
NWR = 0; //write cycle begin
Delayus(1); //hold time
NWR = 1; //write cycle end
}
Port out function
/* port_out: This function outputs a byte to the D0-D7 port */
void portout(int byte) {
// Note: !! converts an integer expression to a boolean (1 or 0).
D0 = !!(byte & 1);
D1 = !!(byte & 2);
D2 = !!(byte & 4);
D3 = !!(byte & 8);
D4 = !!(byte & 16);
D5 = !!(byte & 32);
D6 = !!(byte & 64);
D7 = !!(byte & 128);
}
Channel switch function, which writes a new mixer value to turn a channel on or off.
/* channelSw: Generic channel switch function
This writes a new mixer value to chip "chip". The mixer value
depends on "chn", the channel turning on or off, "state" whether
the channel is turning on or off, and "*mixer", a pointer to
the old mixer value. */
void channelSw(int chip, int chn, int *mixer, int state) {
/* Enable music chip */
switch(chip) {
case 1: CS1 = 0; break;
case 2: CS2 = 0; break;
case 3: CS3 = 0; break;
case 4: CS4 = 0; break;
}
/* Write mixer value */
/* This writes to channel 7 (mixer channel) the _new_ mixer value, which is
the old mixer value with a particular bit flipped based on "chn" and "state" */
write_chip(0x07, (*mixer) = state ? (*mixer) & (0xFF & ~chn) : (*mixer) | chn);
/* Disable chip */
switch(chip) {
case 1: CS1 = 1; break;
case 2: CS2 = 1; break;
case 3: CS3 = 1; break;
case 4: CS4 = 1; break;
}

}
Interrupt functions
//External interrupt for motor driving
void __ISR(_EXTERNAL_3_VECTOR, ipl6) _SingleVectorHandler(void) {
if (motorflag == 0) {
motorflag = 1; //Start motor cycle
}
//If on already, do nothing
mINT3ClearIntFlag();
}

//External interrupt for motor waiting
void __ISR(_EXTERNAL_4_VECTOR, ipl5) _SingleVectorHandler2(void) {
if (motorflag == 0) {
WriteTimer3(0);
motorflag = 6; //Start wait cycle
}
//If on already, do nothing
mINT4ClearIntFlag();
}

=Results=

The project turned out to be a mild success overall. The tilt switches worked very well for activating the music tones, but the heart rate monitor was less successful. One of the biggest issues was getting rid of very low frequency drift in the signal that made the peaks sometimes as high as 10V, but other times less 1V. Dealing with this fluctuation in peak size was the most difficult part of signal processing. As mentioned above, we tried FFT in order to establish a steady heart rate, but could not get the resolution we desired, thus we abandoned the idea.

'''PROBABLY NEED MORE TECHNICAL RESULTS HERE, BUT I'M NOT SURE WHAT TO SAY RIGHT NOW'''

The best result was that using the device was just plain fun. We each had a great time moving around and hearing the fun sounds that resulted, or if we were feeling ambitious, we would try to play a simple melody like "Mary Had a Little Lamb." It was rather difficult to play anything more complicated than that because it required lots of body control and precise movements.

=Reflections=

'''Successes'''
*tilt switches activated each of the six notes when they were supposed to
**the YMZ284 chips were able to produce all six notes at the same time, allowing cool chords
*tones were in tune and formed fun melodies and chords as the body moved
*drum actuator hit the drum reliably and with good tone
*heart rate monitor usually showed clear peaks on a scope, but was finnicky in practice

'''Room for improvements'''
*tilt switches sometimes bounced, so the beginning, or particularly the ends of the notes sounded jagged
**''Possible Solution:'' add a low pass filter to the switch signal so that the signal ramps up and down.
*the shoulder straps sometimes needed adjustments for each individual in order for the sensors to be in the correct position
**''Possible Solution:'' create straps with more constraints, such as a strap across the chest as well as the back, to ensure that the sensors are in the correct positions and orientations.
*the straps could be easier to put on
**''Possible Solution:'' maybe integrate them into a single garment, like a onesie
*the heart rate monitor was not reliable. Low frequency drift made setting a comparison level nearly impossible, especially for more than one specific user.
**''Possible Solution:'' improve FFT method so that desired resolution could be achieved in a short sample period (around 10 seconds). Or implement a complicated peak detection algorithm on the PIC.

'''JAMES SHOULD ADD SOME KIND OF HEARTWARMING CONCLUSION CUZ HE'S GOOD AT THAT STUFF'''

Music from the Heart -- Music Suit

2010-03-17T08:43:59Z

EricWest: /* Drum actuator - Electrical design */

=Introduction=

This project attempted to create a natural form of musical expression by connecting sensors to the body. Six tilt switches were attached to the wrist, ankles, and shoulders, each controlling a single pitch from the [http://en.wikipedia.org/wiki/Pentatonic_scale pentatonic scale]. The heart beat was obtained using [http://en.wikipedia.org/wiki/Photoplethysmograph photoplethysmography] on the user's finger, and this signal was used to strike a drum in sync with the heart beat.

For a video demonstration, click [http://www.youtube.com/watch?v=YyipByy7m6I here].

==Team Members==

[[Image:Mfth team picture.JPG|thumb|200px|From left: Thomas, Eric, James]]
*Thomas Peterson (Computer Engineering, 2010)
*James Rein (Biomedical Engineering and Music Cognition, 2010)
*Eric West (Mechanical Engineering, 2011)

=Subsystems=

Although intended as a single, cohesive system that would allow the user to intuitively make music, the project was easily divided into three subsystems: heart rate monitor, drum actuation, and music tones. Below is more explanation about each subsystem.

==Heart rate monitor - Concepts==

In brainstorming how to translate a heart beat into a drum beat, we decided that the least intrusive method would be the best. Attaching electrodes to the user would simplify the process of identifying a heart beat, but attaching the sensors directly to the skin would be a time-consuming and personally-invasive process. Instead, we decided a finger tip sensor would be much more comfortable and easy to use.

To make a finger tip sensor, we used the concepts of [http://en.wikipedia.org/wiki/Photoplethysmograph photoplethysmography]. Photoplethysmography is typically used in [http://en.wikipedia.org/wiki/Pulse_oximeter pulse oximeters] and finger-tip sensors in commercially-available devices. We originally tried to hack a heart rate monitor that we had purchased, but this proved difficult, so we decided to make our own.

The basic concept of photoplethysmography is that blood reflects a certain amount of IR light, and the blood density in the finger changes as the heart pumps, so the IR reflectivity of the finger changes as the heart beats. Using an IR emitter-detector pair found in the mechatronics lab followed by lots of amplification and filtering, we were able to obtain a decent signal with peaks when the user's heart beat.

===Heart rate monitor - Electrical Design===

The signal coming directly out of the IR detector was very weak and noisy. To obtain just the information we desired, we ran it through the following filters and amplifiers:

# [[Passive Filters#High-Pass Filter (HPF)|Passive High-Pass Filter]]
# [[Operational Amplifiers (Op-Amps)#Inverting Amplifier|Inverting Amplifier]]: gain = -470
# [http://en.wikipedia.org/wiki/Low-pass_filter#Active_electronic_realization Active Low-pass filter]: cutoff frequency = 4.82Hz, gain = -70
# [http://www.electronics-tutorials.ws/filter/filter_7.html Band-pass filter]: Frequency range = 0.72 to 3.39Hz, inverting gain = -46.8
# [[Comparators|Comparator]]: output to the PIC pin A14, with pull-up resistor to 3.3V and capacitors to smooth out the signal.

The complete signal processing circuit is shown below.

[[Image:Heartrate monitor.PNG|thumb|center|900px|Heart rate monitor circuit diagram. Click for larger image.]]

===Heart rate monitor - Mechanical Design===

[[Image:Heart rate sensor mfth.JPG|thumb|200px|Heart rate sensor with the latex band pulled away so that the emitter-detector is revealed]]
The sensor itself was a QRB1114 emitter-detector pair that was encased in open-cell foam insulation. We inserted it into the foam by drilling and filing a hole in the foam to the appropriate size, and gluing the sensor in place. A round, finger-shaped groove was filed into the foam and the sensor sat flush with the bottom of this groove. The user's finger was held in the correct position with relatively constant pressure using a latex band around the finger and the foam enclosure.

==Drum actuator - Electrical design==

Once the signal from the heart rate sensor is sent to the PIC, the rising edge triggers an interrupt which starts the driving sequence for the motor that strikes the drum. The drive sequence was: drive down (into drum) 100ms, drive up 75ms, wait 150ms. The interrupt does not do the entire driving sequence, it merely flags a variable to start the sequence, which is done in the main loop, as seen in the code below.

An additional interrupt was triggered by the falling edge of the signal; this falling edge interrupt added additional wait time that prevented the PIC from being "fooled" by a noisy falling edge. For instance, if the falling signal had some noise in it, the rising edge interrupt would be triggered again, thus causing the drum to strike on both the rising and falling edges of the heartbeat. We only wanted one strike per heartbeat, so the falling edge interrupt was triggered by the ''first'' falling edge, and any noise in the falling edge was ignored because the PIC was told to wait for 300ms. With a maximum delay of 150 + 300 = 450ms from the two interrupts, the fastest heartbeat our drum could play was 133 beats per minute, but we did not expect anyone to come play the instrument after running, so this was plenty high for our purposes.

Initially, we tried skipping the comparator and sending the analog signal directly into one of the PICs analog inputs. Our intention was to use the fast Fourier transform (FFT) library to try to extract the dominant frequency (see [[PIC32MX: FFT of Analog Input]] for more information). Unfortunately, we ran into various problems. First, to get the accuracy we wanted for small frequencies, the sample window had to be very long (10 seconds or more), which made the output lag changes in heart rate. Additionally, the FFT was often "messy", which messed up our original algorithm of detecting the peak frequency between .5 and 2.5 hz. The system would sometimes randomly switch between very different frequencies, and although it was right most of the time it was enough to make the drum beating sound bad. We also tried algorithms to find the [http://en.wikipedia.org/wiki/Fundamental_frequency fundamental frequency] using the entire FFT (instead of just the .5-2.5 hz range), but this was still unreliable. We considered FFT peak detection algorithms, but they seemed to complex for the time and computing power we had available. Because of all this, we went with the simple comparator in the end.

The motor for driving the drumstick was driven by an [[media:L298N.pdf|L298 H-bridge]]. See [[Driving a high current DC Motor using an H-bridge]] for more information on how this works. Our particular circuit diagram is shown below:

[[Image:T21_motorckt_png.PNG|thumb|center|600px|Motor Circuit (non-motor PIC connections not shown). Click for larger image.]]

====Drum actuator - Mechanical Design====

[[Image:Drum stick mount mfth.jpg|thumb|200px|Attachment for the drumstick to the motor shaft.|right]]
We wanted to use a real drum for our drum beat, so our challenge was to attach a motor and drumstick to a drum. We chose a small rack tom for its resonant tone that is reminiscent of a heart beat.

To attach the drumstick to the motor shaft, we used a small block of acrylic (.5"x.75"x2"). The drumstick was cut down to 8" in length so that it would require less torque from the motor. In one end of the block, a hole was drilled and the drumstick was sanded to the correct diameter in order to snuggly fit into the hole. To ensure that the drumstick could not slide out of the block, a screw was placed in a hole drilled through both the stick and the block. The other end of the block was attached to the motor shaft using a split-clamp method: A hole the size of the motor shaft was drilled through the block, and then a slit was cut from the end of the block to the hole, allowing a screw to tightly clamp the block around the motor.

[[Image:Motor mount mfth.jpg|thumb|200px|Mounting bracket for the motor-stick assembly.|right]]
To attach the motor-stick assembly to the drum, we utilized the tuning screws on the drum and holes in the face of the motor. A sheet metal bracket with holes in the appropriate places attached the motor to two of the tuning screws. The bracket was easily made by cutting and bending a piece of 16 gauge steel sheet metal to the appropriate size. Ideally, this part would have been made out of one continuous piece of sheet metal, but we could not find a large enough sheet available in the shop, so we used rivets to connect two smaller pieces together.

After testing the drum striking, we decided it was too loud. To dampen the sound, we taped a piece of foam core and a shop rag to the head of the drum where the stick strikes it.

'''Parts list for drum actuator'''
*Bargain drumstick, at least .5" in diameter
*Small block of acrylic, .5"x.75"x2" (aluminum would work just as well, this is what was available)
*16 gauge steel sheet metal for bracket
*2 pop rivets
*Screws and nuts
*Foam core, shop rag, tape for dampening

==Music Tones - Electrical Design==
The music tones were activated by tilt switches and generated using a [http://pdf1.alldatasheet.com/datasheet-pdf/view/82065/YAMAHA/YMZ284.html YMZ284] chip and were output through a 1/8" jack to a standard set of computer speakers.

Each YMZ284 is capable of producing and mixing any combination of three tones. Since we wanted to have six notes from a [http://en.wikipedia.org/wiki/Pentatonic_scale pentatonic scale], we needed two of these chips and used an [[Operational Amplifiers (Op-Amps)#Summer|summing opamp circuit]] to combine outputs from each chip. We envisioned a possibility of adding [http://en.wikipedia.org/wiki/Overtone overtones] to each note, to make them sound better and more like a real instrument, so we ended up having four YMZ284s attached to our board. When we tried adding an overtone an octave above the fundamental frequency, it ended up sounding harsh and whiny. We decided the tones sounded better with no overtones, so we are only using 2 of the 4 chips on our board.

The YMZ284 communicates with the PIC over an 8-bit databus, plus additional pins for chip select, address, write enable, and reset. All four of our YMZ284s shared all of their pins ''except'' the chip select line; each required their own individual chip select line so that the PIC could specify with which chips it wanted to talk. The circuit diagram below shows how the chips were connected to the PIC and the summing circuit that followed.

{{multiple image
| align = center
| width = 500
| image1 = T21_musicckt_png.PNG
| caption1 = Music circuit diagram. The summing amplifier is not shown.
| image2 = Solder board mfth.jpg
| alt2 = Red cartouche
| caption2 = Music chips are in the center of the board. H-bridge for motor driving is on the far right, along with the power supply plug. The left side is an unsuccessful attempt at moving the heart rate circuitry to the solder board
}}

===Tilt switches - Electrical Design===
In order to detect when the limbs of the user had moved past a certain critical angle, we chose to use tilt switches. We purchased our tilt switches for $2 each from [http://www.goldmine-elec-products.com/prodinfo.asp?number=G16881 Electronics Goldmine]. We chose to use tilt switches instead of an accelerometer because the switches were much cheaper and we figured they would be easier to work with.

The tilt switches we chose are optically-based with an emitter and detector that are selectively blocked by a small ball. When the critical angle is achieved, the tiny ball rolls up a ramp, allowing the emitter to shine directly on the detector, and current flows. When the angle is neutral, the ramp forces the ball to block the light, making current stop flowing through the phototransistor. The "ramp" is really an inverted cone, so the switch can be activated by a change in angle in any direction away from the neutral position. We purchased three different tilt switches to try, each with a different critical angle - 15, 30, and 45 degrees. The configuration we ended up using was:

*30 degrees for shoulders and ankles
*45 degrees for elbows

In hindsight, we would have used all 45-degree switches because they produced the sharpest jump from off to on. The 15-degree switches were practically unusable because they created a large amount of noise as they switched on and off.

We used the tilt switches to provide high-low inputs to the PIC to tell it when to turn on any of the six tones. By attaching these switches to the body such that they are in the neutral position when the body is relaxed, we were able to control the six tones by moving the body in relatively natural ways.

===Tilt switches - Mechanical Design===

[[Image:Wrist sensor mfth.JPG|thumb|200px|Wrist tilt sensor. Ankles are similar, with a larger strap.]]
The switches were attached to the user's body using adjustable straps and buckles. The wrist and ankle sensors were simply a loop of webbing with an adjustable buckle attached. The straps could be tightened or loosened to fit any size user. To attach the switch to the straps, we created an enclosure for each switch out of high-density foam (left over scraps from DSGN 307). The switch was jammed into a hole in the foam so that it could not easily be moved. The foam was then taped to the straps using electrical tape.

The shoulder straps were a bit more involved. Two loops with buckles, similar to the wrist and ankle straps, went over the user's shoulder and underneath their armpit. To keep these straps from sliding off the shoulders, a large strap across the user's back connected the two smaller straps together. This large strap was also used for mounting the solder board which gathered the wires from all six tilt switches and sent them to the PIC over one ribbon cable. Using this strap configuration, we found that the user could comfortably and securely wear the sensors.

[[Image:Shoulder sensors mfth.JPG|thumb|200px|Shoulder straps containing the tilt sensors.]]
To attach the switches to the shoulders, we again created a foam encasement. However, electrical tape was not secure enough to hold the foam pieces to the irregularly-shaped shoulder straps. Instead, we riveted a piece of canvas to the webbing straps. We chose to use rivets instead of sewing because the sewing machine could not tightly sew the foam encasement in place. With rivets, we were able to pull the canvas tightly around the foam so that it couldn't move.

=Code=
To download the entire C file, click [[Media:Main_music.c|here]]. Below, the file is split into sections for comments.

/**********************************************************
* main_music.c: Main c file for "Music Suit" project
*
* Thomas Peterson, James Rein, Eric West
* ME333 Winter 2010
**********************************************************/

#include <HardwareProfile.h>
#include <delays.c> //Delayms and Delayus functions

The first section defines all the input and output pins, used with the motor, sensor, and music circuits.

////////////////////////////////////////////////////
//Pin Defines

//YMZ Chip selects
#define CS1 LATCbits.LATC2
#define CS2 LATCbits.LATC3
#define CS3 LATCbits.LATC4
#define CS4 LATGbits.LATG6
//YMZ communication pins
#define NWR LATBbits.LATB0 //"Not WRite": active low write line
#define A0 LATBbits.LATB6 //Address 0
#define NIC LATCbits.LATC1 //"Not Input Clear": active low reset line
//YMZ data pins
#define D0 LATGbits.LATG9
#define D1 LATEbits.LATE8
#define D2 LATEbits.LATE9
#define D3 LATBbits.LATB5
#define D4 LATBbits.LATB4
#define D5 LATBbits.LATB3
#define D6 LATBbits.LATB2
#define D7 LATBbits.LATB1

//Tilt inputs
#define ENC PORTDbits.RD3
#define END PORTDbits.RD2
#define ENE PORTDbits.RD1
#define ENG PORTCbits.RC14
#define ENA PORTCbits.RC13
#define ENC5 PORTDbits.RD0

//Motor outputs
#define IN1 LATBbits.LATB7
#define IN2 LATAbits.LATA9
#define EN LATAbits.LATA10

///////////////////////////////////////
//Other defines
//Motor times
#define MS(x) x*312.5
#define DRIVETIME MS(100)
#define BACKTIME MS(75)
#define WAITTIME MS(150)
//Channels
#define CHNA 1
#define CHNB 2
#define CHNC 4

//////////////////////////////////////////
//Function definitions
void write_chip(int address, int data);
void portout(int byte);
void channelSw(int chip, int chn, int *mixer, int state);
//Global variables
int mixer1, mixer2;
int motorflag = 0;
The initialization function sets up various parts of the system.
/* init() : This function runs initializations, setting up the pic and music chips */
void init() {
int pbClk = SYSTEMConfigPerformance(SYS_FREQ);

/////////////////////////////////////////////
//Setup inputs / outputs
AD1PCFG = 0xFFFF; //All digital inputs
TRISG &= 0xFDBF; //sets G9,G6 to 0 (output); all else remains the same
TRISC &= 0xFFE1; //sets C4,C3,C2,C1 to 0s (outputs); all else remains the same
TRISB &= 0xFF80; //sets B0-B6 0 (output)
TRISE &= 0xFCFF; //sets E8,9 to output
TRISB |= 0xF000; //sets B12,B13,B14,B15 to 1s (inputs); all else remains the same
TRISC |= 0x6000; //sets C14,13 to inputs
TRISD |= 0x000F; //Sets D0,D1,D2,D3 to inputs
TRISDbits.TRISD4 = 0; //Output for clock
//Motor outputs
TRISAbits.TRISA9 = 0;
TRISAbits.TRISA10 = 0;
TRISBbits.TRISB7 = 0;
//Pulse inputs
TRISAbits.TRISA14 = 1;
TRISAbits.TRISA15 = 1;
//ODC setup
ODCCbits.ODCC1 = 1; //open drain control; can only float high (when set high) or pull low

/* Initialize outputs */
//YMZs
CS1 = 1;
CS2 = 1;
CS3 = 1;
CS4 = 1;
NWR = 1;
A0 = 0;
NIC = 1;
//Motor
IN2 = 0;
IN1 = 0;
EN = 0;

Delayms(100); //wait for power supply to ramp up
NIC = 0; //resets YMZ284s
Delayms(10);
NIC = 1;

In the init() function, the pic writes all the setup data to the music chips. This includes the frequency registers, which determine the frequency of each output, the mixer, which determines which channels are on or off (1 = off), and the volume registers, which determine the volume of each channel. After the setup, the only register that is changed in normal operation is the mixer register, which merely turns channels on and off.
//////////////////////////////////////////////////
//Setup music chips
//Setup Chip 1//
CS1 = 0;
write_chip(0x00,0xC7); //a low // C4
write_chip(0x01,0x01); //a high
write_chip(0x02,0x98); //b low // D
write_chip(0x03,0x01); //b high
write_chip(0x04,0x6E); //c low
write_chip(0x05,0x01); //c high // E
write_chip(0x07,0xFF); //mixer (0 enables)
write_chip(0x08, 0x0A); //level (volume) A
write_chip(0x09, 0x0A); //level (volume) B
write_chip(0x0A, 0x0A); //level (volume) C
CS1=1;
//Setup Chip 2//
CS2 = 0;
write_chip(0x00,0x2C); //a low //G 392
write_chip(0x01,0x01); //a high
write_chip(0x02,0x0D); //b low //A 440
write_chip(0x03,0x01); //b high
write_chip(0x04,0xE3); //c low //C5 523.25
write_chip(0x05,0x00); //c high
write_chip(0x07,0xFF); //mixer (0 enables)
write_chip(0x08, 0x0A); //level (volume) A
write_chip(0x09, 0x0A); //level (volume) B
write_chip(0x0A, 0x0A); //level (volume) C
CS2=1;

mixer1=0xFF;
mixer2=0xFF;
OC5 is used to create a PWM signal with 50% duty at 4Mhz, in effect creating a 4Mhz square wave. This is used by the music chips as a master clock.
//////////////////////////////////////////////
//Setup OC to create master clock for music chips (~4 Mhz)
OpenOC5( OC_ON | OC_TIMER2_SRC | OC_PWM_FAULT_PIN_DISABLE, 0, 0);
OpenTimer2( T2_ON | T2_PS_1_1 | T2_SOURCE_INT, 20);
SetDCOC5PWM(10);
The interrupts are used, as mentioned above, to control when the motor is driven. The motor should drive once every rising edge.
/////////////////////////////////////////////
//External interrupt setups (for motor) - INT3 (A14)
mINT3ClearIntFlag();
mINT3IntEnable(1);
mINT3SetIntPriority(6);
mINT3SetEdgeMode(1); //Rising edge
/////////////////////////////////////////////
//External interrupt setups (for motor) - INT4 (A15)
mINT4ClearIntFlag();
mINT4IntEnable(1);
mINT4SetIntPriority(5);
mINT4SetEdgeMode(0); //Falling edge
INTEnableSystemMultiVectoredInt();

/////////////////////////////////////////////
//Setup motor timer (used for timing delays)
OpenTimer3(T3_ON | T3_PS_1_256 | T3_SOURCE_INT, 0xFFFF);
ConfigIntTimer3(T3_INT_OFF);
}

Main function
/* Main function */
int main()
{
init(); /* Run initialization functions */
Delayms(1);

/* Main while loop: loop indefinietly */
while (1) {
In the main while loop, the PIC checks every cycle to see if an input has changed since the last cycle. Since the "mixer" variables store the current state, if an input does not match up with its valid mixer bit then it has changed recently. In this case, the channelSw() function is called to switch on or off the music channel controlled by that bit.
//Check for state changes in music notes
if (ENC != (mixer1 & 0x01)) { channelSw(1,CHNA,&mixer1,!ENC); } //If input ENC (enable C) is not equal to the state of channel A1 (note c), change the state
if (END != (mixer1 & 0x02)) { channelSw(1,CHNB,&mixer1,!END); }
if (ENE != (mixer1 & 0x04)) { channelSw(1,CHNC,&mixer1,!ENE); }
if (ENG != (mixer2 & 0x01)) { channelSw(2,CHNA,&mixer2,!ENG); }
if (ENA != (mixer2 & 0x02)) { channelSw(2,CHNB,&mixer2,!ENA); }
if (ENC5 != (mixer2 & 0x04)) { channelSw(2,CHNC,&mixer2,!ENC5); }
During the main while loop, the motor flag variable is checked to see if the motor should be driven. If so, it enters a sequence where it uses timer3 to determine the current stage in the motor cycle, changing the outputs as needed.
//Check for motor state changes
switch (motorflag) {
case 0: break; //Do nothing (motor off)
case 1: //Start motor cycle
WriteTimer3(0); //Reset timer to 0
IN1 = 0; //Set H bridge to forward drive
IN2 = 1;
EN = 1;
motorflag = 2; //In drivedown cycle
break;
case 2: //Drivedown cycle
if (ReadTimer3() > DRIVETIME) { //Wait for DRIVETIME to pass
WriteTimer3(0); //Reset timer to 0
motorflag = 3; //In driveup phase
IN2 = 0; //Switch H bridge
IN1 = 1;
}
break;
case 3: //Driveup cycle
if (ReadTimer3() > BACKTIME) { //Wait for BACKTIME to pass
WriteTimer3(0); //Reset timer to 0
motorflag = 4; //In coast/wait phase
EN = 0; //Turn off motor
}
break;
case 4: //coast / wait cycle
if (ReadTimer3() > WAITTIME) {
motorflag = 5; //more wait
WriteTimer3(0);
}
break;
case 5: //Additional wait cycle
if (ReadTimer3() > WAITTIME) {
//Done!
motorflag = 0; //Motor off (can now be triggered again)
}
break;
//Static wait cycles
case 6:
if (ReadTimer3() > WAITTIME) {
motorflag = 7;
WriteTimer3(0);
}
break;
case 7:
if (ReadTimer3() > WAITTIME) {
WriteTimer3(0);
motorflag = 8;
}
break;
case 8:
if (ReadTimer3() > WAITTIME) {
motorflag = 0;
}
break;
}

Delayms(10);
}
return 0;
}//end main

Write chip function, which is a support function that writes data to the music chips.
/* write_chip: This writes the given byte "data" to the "address" (0 or 1)
on a YMZ284. It is assumed that the chip select is already low */
void write_chip(int address,int data) {
//Write address
portout(address);
A0 = 0; //select address mode
Delayus(1); //setup time
NWR = 0; //Write cycle begin
Delayus(1); //hold time
NWR = 1; //Write cycle end

//Write data
portout(data);
A0 = 1; //select data mode
Delayus(1); //setup time
NWR = 0; //write cycle begin
Delayus(1); //hold time
NWR = 1; //write cycle end
}
Port out function
/* port_out: This function outputs a byte to the D0-D7 port */
void portout(int byte) {
// Note: !! converts an integer expression to a boolean (1 or 0).
D0 = !!(byte & 1);
D1 = !!(byte & 2);
D2 = !!(byte & 4);
D3 = !!(byte & 8);
D4 = !!(byte & 16);
D5 = !!(byte & 32);
D6 = !!(byte & 64);
D7 = !!(byte & 128);
}
Channel switch function, which writes a new mixer value to turn a channel on or off.
/* channelSw: Generic channel switch function
This writes a new mixer value to chip "chip". The mixer value
depends on "chn", the channel turning on or off, "state" whether
the channel is turning on or off, and "*mixer", a pointer to
the old mixer value. */
void channelSw(int chip, int chn, int *mixer, int state) {
/* Enable music chip */
switch(chip) {
case 1: CS1 = 0; break;
case 2: CS2 = 0; break;
case 3: CS3 = 0; break;
case 4: CS4 = 0; break;
}
/* Write mixer value */
/* This writes to channel 7 (mixer channel) the _new_ mixer value, which is
the old mixer value with a particular bit flipped based on "chn" and "state" */
write_chip(0x07, (*mixer) = state ? (*mixer) & (0xFF & ~chn) : (*mixer) | chn);
/* Disable chip */
switch(chip) {
case 1: CS1 = 1; break;
case 2: CS2 = 1; break;
case 3: CS3 = 1; break;
case 4: CS4 = 1; break;
}

}
Interrupt functions
//External interrupt for motor driving
void __ISR(_EXTERNAL_3_VECTOR, ipl6) _SingleVectorHandler(void) {
if (motorflag == 0) {
motorflag = 1; //Start motor cycle
}
//If on already, do nothing
mINT3ClearIntFlag();
}

//External interrupt for motor waiting
void __ISR(_EXTERNAL_4_VECTOR, ipl5) _SingleVectorHandler2(void) {
if (motorflag == 0) {
WriteTimer3(0);
motorflag = 6; //Start wait cycle
}
//If on already, do nothing
mINT4ClearIntFlag();
}

=Results=

The project turned out to be a mild success overall. The tilt switches worked very well for activating the music tones, but the heart rate monitor was less successful. One of the biggest issues was getting rid of very low frequency drift in the signal that made the peaks sometimes as high as 10V, but other times less 1V. Dealing with this fluctuation in peak size was the most difficult part of signal processing. As mentioned above, we tried FFT in order to establish a steady heart rate, but could not get the resolution we desired, thus we abandoned the idea.

'''PROBABLY NEED MORE TECHNICAL RESULTS HERE, BUT I'M NOT SURE WHAT TO SAY RIGHT NOW'''

The best result was that using the device was just plain fun. We each had a great time moving around and hearing the fun sounds that resulted, or if we were feeling ambitious, we would try to play a simple melody like "Mary Had a Little Lamb." It was rather difficult to play anything more complicated than that because it required lots of body control and precise movements.

=Reflections=

'''Successes'''
*tilt switches activated each of the six notes when they were supposed to
**the YMZ284 chips were able to produce all six notes at the same time, allowing cool chords
*tones were in tune and formed fun melodies and chords as the body moved
*drum actuator hit the drum reliably and with good tone
*heart rate monitor usually showed clear peaks on a scope, but was finnicky in practice

'''Room for improvements'''
*tilt switches sometimes bounced, so the beginning, or particularly the ends of the notes sounded jagged
**''Possible Solution:'' add a low pass filter to the switch signal so that the signal ramps up and down.
*the shoulder straps sometimes needed adjustments for each individual in order for the sensors to be in the correct position
**''Possible Solution:'' create straps with more constraints, such as a strap across the chest as well as the back, to ensure that the sensors are in the correct positions and orientations.
*the straps could be easier to put on
**''Possible Solution:'' maybe integrate them into a single garment, like a onesie
*the heart rate monitor was not reliable. Low frequency drift made setting a comparison level nearly impossible, especially for more than one specific user.
**''Possible Solution:'' improve FFT method so that desired resolution could be achieved in a short sample period (around 10 seconds). Or implement a complicated peak detection algorithm on the PIC.

'''JAMES SHOULD ADD SOME KIND OF HEARTWARMING CONCLUSION CUZ HE'S GOOD AT THAT STUFF'''

Music from the Heart -- Music Suit

2010-03-17T08:40:53Z

EricWest: /* Music Tones - Electrical Design */

=Introduction=

This project attempted to create a natural form of musical expression by connecting sensors to the body. Six tilt switches were attached to the wrist, ankles, and shoulders, each controlling a single pitch from the [http://en.wikipedia.org/wiki/Pentatonic_scale pentatonic scale]. The heart beat was obtained using [http://en.wikipedia.org/wiki/Photoplethysmograph photoplethysmography] on the user's finger, and this signal was used to strike a drum in sync with the heart beat.

For a video demonstration, click [http://www.youtube.com/watch?v=YyipByy7m6I here].

==Team Members==

[[Image:Mfth team picture.JPG|thumb|200px|From left: Thomas, Eric, James]]
*Thomas Peterson (Computer Engineering, 2010)
*James Rein (Biomedical Engineering and Music Cognition, 2010)
*Eric West (Mechanical Engineering, 2011)

=Subsystems=

Although intended as a single, cohesive system that would allow the user to intuitively make music, the project was easily divided into three subsystems: heart rate monitor, drum actuation, and music tones. Below is more explanation about each subsystem.

==Heart rate monitor - Concepts==

In brainstorming how to translate a heart beat into a drum beat, we decided that the least intrusive method would be the best. Attaching electrodes to the user would simplify the process of identifying a heart beat, but attaching the sensors directly to the skin would be a time-consuming and personally-invasive process. Instead, we decided a finger tip sensor would be much more comfortable and easy to use.

To make a finger tip sensor, we used the concepts of [http://en.wikipedia.org/wiki/Photoplethysmograph photoplethysmography]. Photoplethysmography is typically used in [http://en.wikipedia.org/wiki/Pulse_oximeter pulse oximeters] and finger-tip sensors in commercially-available devices. We originally tried to hack a heart rate monitor that we had purchased, but this proved difficult, so we decided to make our own.

The basic concept of photoplethysmography is that blood reflects a certain amount of IR light, and the blood density in the finger changes as the heart pumps, so the IR reflectivity of the finger changes as the heart beats. Using an IR emitter-detector pair found in the mechatronics lab followed by lots of amplification and filtering, we were able to obtain a decent signal with peaks when the user's heart beat.

===Heart rate monitor - Electrical Design===

The signal coming directly out of the IR detector was very weak and noisy. To obtain just the information we desired, we ran it through the following filters and amplifiers:

# [[Passive Filters#High-Pass Filter (HPF)|Passive High-Pass Filter]]
# [[Operational Amplifiers (Op-Amps)#Inverting Amplifier|Inverting Amplifier]]: gain = -470
# [http://en.wikipedia.org/wiki/Low-pass_filter#Active_electronic_realization Active Low-pass filter]: cutoff frequency = 4.82Hz, gain = -70
# [http://www.electronics-tutorials.ws/filter/filter_7.html Band-pass filter]: Frequency range = 0.72 to 3.39Hz, inverting gain = -46.8
# [[Comparators|Comparator]]: output to the PIC pin A14, with pull-up resistor to 3.3V and capacitors to smooth out the signal.

The complete signal processing circuit is shown below.

[[Image:Heartrate monitor.PNG|thumb|center|900px|Heart rate monitor circuit diagram. Click for larger image.]]

===Heart rate monitor - Mechanical Design===

[[Image:Heart rate sensor mfth.JPG|thumb|200px|Heart rate sensor with the latex band pulled away so that the emitter-detector is revealed]]
The sensor itself was a QRB1114 emitter-detector pair that was encased in open-cell foam insulation. We inserted it into the foam by drilling and filing a hole in the foam to the appropriate size, and gluing the sensor in place. A round, finger-shaped groove was filed into the foam and the sensor sat flush with the bottom of this groove. The user's finger was held in the correct position with relatively constant pressure using a latex band around the finger and the foam enclosure.

==Drum actuator - Electrical design==

Once the signal from the heart rate sensor is sent to the PIC, the rising edge triggers an interrupt which starts the driving sequence for the motor that strikes the drum. The drive sequence was: drive down (into drum) 100ms, drive up 75ms, wait 150ms. The interrupt does not do the entire driving sequence, it merely flags a variable to start the sequence, which is done in the main loop, as seen in the code below.

An additional interrupt was triggered by the falling edge of the signal; this falling edge interrupt added additional wait time that prevented the PIC from being "fooled" by a noisy falling edge. For instance, if the falling signal had some noise in it, the rising edge interrupt would be triggered again, thus causing the drum to strike on both the rising and falling edges of the heartbeat. We only wanted one strike per heartbeat, so the falling edge interrupt was triggered by the ''first'' falling edge, and any noise in the falling edge was ignored because the PIC was told to wait for 300ms. With a maximum delay of 150 + 300 = 450ms from the two interrupts, the fastest heartbeat our drum could play was 133 beats per minute, but we did not expect anyone to come play the instrument after running, so this was plenty high for our purposes.

Initially, we tried skipping the comparator and sending the analog signal directly into one of the PICs analog inputs. Our intention was to use the fast Fourier transform (FFT) library to try to extract the dominant frequency. Unfortunately, we ran into various problems. First, to get the accuracy we wanted for small frequencies, the sample window had to be very long (10 seconds or more), which made the output lag changes in heart rate. Additionally, the FFT was often "messy", which messed up our original algorithm of detecting the peak frequency between .5 and 2.5 hz. The system would sometimes randomly switch between very different frequencies, and although it was right most of the time it was enough to make the drum beating sound bad. We also tried algorithms to find the [http://en.wikipedia.org/wiki/Fundamental_frequency fundamental frequency] using the entire FFT (instead of just the .5-2.5 hz range), but this was still unreliable. We considered FFT peak detection algorithms, but they seemed to complex for the time and computing power we had available. Because of all this, we went with the simple comparator in the end.

The motor for driving the drumstick was driven by an [[media:L298N.pdf|L298 H-bridge]]. See [[Driving a high current DC Motor using an H-bridge]] for more information on how this works. Our particular circuit diagram is shown below:

[[Image:T21_motorckt_png.PNG|thumb|center|600px|Motor Circuit (non-motor PIC connections not shown). Click for larger image.]]

====Drum actuator - Mechanical Design====

[[Image:Drum stick mount mfth.jpg|thumb|200px|Attachment for the drumstick to the motor shaft.|right]]
We wanted to use a real drum for our drum beat, so our challenge was to attach a motor and drumstick to a drum. We chose a small rack tom for its resonant tone that is reminiscent of a heart beat.

To attach the drumstick to the motor shaft, we used a small block of acrylic (.5"x.75"x2"). The drumstick was cut down to 8" in length so that it would require less torque from the motor. In one end of the block, a hole was drilled and the drumstick was sanded to the correct diameter in order to snuggly fit into the hole. To ensure that the drumstick could not slide out of the block, a screw was placed in a hole drilled through both the stick and the block. The other end of the block was attached to the motor shaft using a split-clamp method: A hole the size of the motor shaft was drilled through the block, and then a slit was cut from the end of the block to the hole, allowing a screw to tightly clamp the block around the motor.

[[Image:Motor mount mfth.jpg|thumb|200px|Mounting bracket for the motor-stick assembly.|right]]
To attach the motor-stick assembly to the drum, we utilized the tuning screws on the drum and holes in the face of the motor. A sheet metal bracket with holes in the appropriate places attached the motor to two of the tuning screws. The bracket was easily made by cutting and bending a piece of 16 gauge steel sheet metal to the appropriate size. Ideally, this part would have been made out of one continuous piece of sheet metal, but we could not find a large enough sheet available in the shop, so we used rivets to connect two smaller pieces together.

After testing the drum striking, we decided it was too loud. To dampen the sound, we taped a piece of foam core and a shop rag to the head of the drum where the stick strikes it.

'''Parts list for drum actuator'''
*Bargain drumstick, at least .5" in diameter
*Small block of acrylic, .5"x.75"x2" (aluminum would work just as well, this is what was available)
*16 gauge steel sheet metal for bracket
*2 pop rivets
*Screws and nuts
*Foam core, shop rag, tape for dampening

==Music Tones - Electrical Design==
The music tones were activated by tilt switches and generated using a [http://pdf1.alldatasheet.com/datasheet-pdf/view/82065/YAMAHA/YMZ284.html YMZ284] chip and were output through a 1/8" jack to a standard set of computer speakers.

Each YMZ284 is capable of producing and mixing any combination of three tones. Since we wanted to have six notes from a [http://en.wikipedia.org/wiki/Pentatonic_scale pentatonic scale], we needed two of these chips and used an [[Operational Amplifiers (Op-Amps)#Summer|summing opamp circuit]] to combine outputs from each chip. We envisioned a possibility of adding [http://en.wikipedia.org/wiki/Overtone overtones] to each note, to make them sound better and more like a real instrument, so we ended up having four YMZ284s attached to our board. When we tried adding an overtone an octave above the fundamental frequency, it ended up sounding harsh and whiny. We decided the tones sounded better with no overtones, so we are only using 2 of the 4 chips on our board.

The YMZ284 communicates with the PIC over an 8-bit databus, plus additional pins for chip select, address, write enable, and reset. All four of our YMZ284s shared all of their pins ''except'' the chip select line; each required their own individual chip select line so that the PIC could specify with which chips it wanted to talk. The circuit diagram below shows how the chips were connected to the PIC and the summing circuit that followed.

{{multiple image
| align = center
| width = 500
| image1 = T21_musicckt_png.PNG
| caption1 = Music circuit diagram. The summing amplifier is not shown.
| image2 = Solder board mfth.jpg
| alt2 = Red cartouche
| caption2 = Music chips are in the center of the board. H-bridge for motor driving is on the far right, along with the power supply plug. The left side is an unsuccessful attempt at moving the heart rate circuitry to the solder board
}}

===Tilt switches - Electrical Design===
In order to detect when the limbs of the user had moved past a certain critical angle, we chose to use tilt switches. We purchased our tilt switches for $2 each from [http://www.goldmine-elec-products.com/prodinfo.asp?number=G16881 Electronics Goldmine]. We chose to use tilt switches instead of an accelerometer because the switches were much cheaper and we figured they would be easier to work with.

The tilt switches we chose are optically-based with an emitter and detector that are selectively blocked by a small ball. When the critical angle is achieved, the tiny ball rolls up a ramp, allowing the emitter to shine directly on the detector, and current flows. When the angle is neutral, the ramp forces the ball to block the light, making current stop flowing through the phototransistor. The "ramp" is really an inverted cone, so the switch can be activated by a change in angle in any direction away from the neutral position. We purchased three different tilt switches to try, each with a different critical angle - 15, 30, and 45 degrees. The configuration we ended up using was:

*30 degrees for shoulders and ankles
*45 degrees for elbows

In hindsight, we would have used all 45-degree switches because they produced the sharpest jump from off to on. The 15-degree switches were practically unusable because they created a large amount of noise as they switched on and off.

We used the tilt switches to provide high-low inputs to the PIC to tell it when to turn on any of the six tones. By attaching these switches to the body such that they are in the neutral position when the body is relaxed, we were able to control the six tones by moving the body in relatively natural ways.

===Tilt switches - Mechanical Design===

[[Image:Wrist sensor mfth.JPG|thumb|200px|Wrist tilt sensor. Ankles are similar, with a larger strap.]]
The switches were attached to the user's body using adjustable straps and buckles. The wrist and ankle sensors were simply a loop of webbing with an adjustable buckle attached. The straps could be tightened or loosened to fit any size user. To attach the switch to the straps, we created an enclosure for each switch out of high-density foam (left over scraps from DSGN 307). The switch was jammed into a hole in the foam so that it could not easily be moved. The foam was then taped to the straps using electrical tape.

The shoulder straps were a bit more involved. Two loops with buckles, similar to the wrist and ankle straps, went over the user's shoulder and underneath their armpit. To keep these straps from sliding off the shoulders, a large strap across the user's back connected the two smaller straps together. This large strap was also used for mounting the solder board which gathered the wires from all six tilt switches and sent them to the PIC over one ribbon cable. Using this strap configuration, we found that the user could comfortably and securely wear the sensors.

[[Image:Shoulder sensors mfth.JPG|thumb|200px|Shoulder straps containing the tilt sensors.]]
To attach the switches to the shoulders, we again created a foam encasement. However, electrical tape was not secure enough to hold the foam pieces to the irregularly-shaped shoulder straps. Instead, we riveted a piece of canvas to the webbing straps. We chose to use rivets instead of sewing because the sewing machine could not tightly sew the foam encasement in place. With rivets, we were able to pull the canvas tightly around the foam so that it couldn't move.

=Code=
To download the entire C file, click [[Media:Main_music.c|here]]. Below, the file is split into sections for comments.

/**********************************************************
* main_music.c: Main c file for "Music Suit" project
*
* Thomas Peterson, James Rein, Eric West
* ME333 Winter 2010
**********************************************************/

#include <HardwareProfile.h>
#include <delays.c> //Delayms and Delayus functions

The first section defines all the input and output pins, used with the motor, sensor, and music circuits.

////////////////////////////////////////////////////
//Pin Defines

//YMZ Chip selects
#define CS1 LATCbits.LATC2
#define CS2 LATCbits.LATC3
#define CS3 LATCbits.LATC4
#define CS4 LATGbits.LATG6
//YMZ communication pins
#define NWR LATBbits.LATB0 //"Not WRite": active low write line
#define A0 LATBbits.LATB6 //Address 0
#define NIC LATCbits.LATC1 //"Not Input Clear": active low reset line
//YMZ data pins
#define D0 LATGbits.LATG9
#define D1 LATEbits.LATE8
#define D2 LATEbits.LATE9
#define D3 LATBbits.LATB5
#define D4 LATBbits.LATB4
#define D5 LATBbits.LATB3
#define D6 LATBbits.LATB2
#define D7 LATBbits.LATB1

//Tilt inputs
#define ENC PORTDbits.RD3
#define END PORTDbits.RD2
#define ENE PORTDbits.RD1
#define ENG PORTCbits.RC14
#define ENA PORTCbits.RC13
#define ENC5 PORTDbits.RD0

//Motor outputs
#define IN1 LATBbits.LATB7
#define IN2 LATAbits.LATA9
#define EN LATAbits.LATA10

///////////////////////////////////////
//Other defines
//Motor times
#define MS(x) x*312.5
#define DRIVETIME MS(100)
#define BACKTIME MS(75)
#define WAITTIME MS(150)
//Channels
#define CHNA 1
#define CHNB 2
#define CHNC 4

//////////////////////////////////////////
//Function definitions
void write_chip(int address, int data);
void portout(int byte);
void channelSw(int chip, int chn, int *mixer, int state);
//Global variables
int mixer1, mixer2;
int motorflag = 0;
The initialization function sets up various parts of the system.
/* init() : This function runs initializations, setting up the pic and music chips */
void init() {
int pbClk = SYSTEMConfigPerformance(SYS_FREQ);

/////////////////////////////////////////////
//Setup inputs / outputs
AD1PCFG = 0xFFFF; //All digital inputs
TRISG &= 0xFDBF; //sets G9,G6 to 0 (output); all else remains the same
TRISC &= 0xFFE1; //sets C4,C3,C2,C1 to 0s (outputs); all else remains the same
TRISB &= 0xFF80; //sets B0-B6 0 (output)
TRISE &= 0xFCFF; //sets E8,9 to output
TRISB |= 0xF000; //sets B12,B13,B14,B15 to 1s (inputs); all else remains the same
TRISC |= 0x6000; //sets C14,13 to inputs
TRISD |= 0x000F; //Sets D0,D1,D2,D3 to inputs
TRISDbits.TRISD4 = 0; //Output for clock
//Motor outputs
TRISAbits.TRISA9 = 0;
TRISAbits.TRISA10 = 0;
TRISBbits.TRISB7 = 0;
//Pulse inputs
TRISAbits.TRISA14 = 1;
TRISAbits.TRISA15 = 1;
//ODC setup
ODCCbits.ODCC1 = 1; //open drain control; can only float high (when set high) or pull low

/* Initialize outputs */
//YMZs
CS1 = 1;
CS2 = 1;
CS3 = 1;
CS4 = 1;
NWR = 1;
A0 = 0;
NIC = 1;
//Motor
IN2 = 0;
IN1 = 0;
EN = 0;

Delayms(100); //wait for power supply to ramp up
NIC = 0; //resets YMZ284s
Delayms(10);
NIC = 1;

In the init() function, the pic writes all the setup data to the music chips. This includes the frequency registers, which determine the frequency of each output, the mixer, which determines which channels are on or off (1 = off), and the volume registers, which determine the volume of each channel. After the setup, the only register that is changed in normal operation is the mixer register, which merely turns channels on and off.
//////////////////////////////////////////////////
//Setup music chips
//Setup Chip 1//
CS1 = 0;
write_chip(0x00,0xC7); //a low // C4
write_chip(0x01,0x01); //a high
write_chip(0x02,0x98); //b low // D
write_chip(0x03,0x01); //b high
write_chip(0x04,0x6E); //c low
write_chip(0x05,0x01); //c high // E
write_chip(0x07,0xFF); //mixer (0 enables)
write_chip(0x08, 0x0A); //level (volume) A
write_chip(0x09, 0x0A); //level (volume) B
write_chip(0x0A, 0x0A); //level (volume) C
CS1=1;
//Setup Chip 2//
CS2 = 0;
write_chip(0x00,0x2C); //a low //G 392
write_chip(0x01,0x01); //a high
write_chip(0x02,0x0D); //b low //A 440
write_chip(0x03,0x01); //b high
write_chip(0x04,0xE3); //c low //C5 523.25
write_chip(0x05,0x00); //c high
write_chip(0x07,0xFF); //mixer (0 enables)
write_chip(0x08, 0x0A); //level (volume) A
write_chip(0x09, 0x0A); //level (volume) B
write_chip(0x0A, 0x0A); //level (volume) C
CS2=1;

mixer1=0xFF;
mixer2=0xFF;
OC5 is used to create a PWM signal with 50% duty at 4Mhz, in effect creating a 4Mhz square wave. This is used by the music chips as a master clock.
//////////////////////////////////////////////
//Setup OC to create master clock for music chips (~4 Mhz)
OpenOC5( OC_ON | OC_TIMER2_SRC | OC_PWM_FAULT_PIN_DISABLE, 0, 0);
OpenTimer2( T2_ON | T2_PS_1_1 | T2_SOURCE_INT, 20);
SetDCOC5PWM(10);
The interrupts are used, as mentioned above, to control when the motor is driven. The motor should drive once every rising edge.
/////////////////////////////////////////////
//External interrupt setups (for motor) - INT3 (A14)
mINT3ClearIntFlag();
mINT3IntEnable(1);
mINT3SetIntPriority(6);
mINT3SetEdgeMode(1); //Rising edge
/////////////////////////////////////////////
//External interrupt setups (for motor) - INT4 (A15)
mINT4ClearIntFlag();
mINT4IntEnable(1);
mINT4SetIntPriority(5);
mINT4SetEdgeMode(0); //Falling edge
INTEnableSystemMultiVectoredInt();

/////////////////////////////////////////////
//Setup motor timer (used for timing delays)
OpenTimer3(T3_ON | T3_PS_1_256 | T3_SOURCE_INT, 0xFFFF);
ConfigIntTimer3(T3_INT_OFF);
}

Main function
/* Main function */
int main()
{
init(); /* Run initialization functions */
Delayms(1);

/* Main while loop: loop indefinietly */
while (1) {
In the main while loop, the PIC checks every cycle to see if an input has changed since the last cycle. Since the "mixer" variables store the current state, if an input does not match up with its valid mixer bit then it has changed recently. In this case, the channelSw() function is called to switch on or off the music channel controlled by that bit.
//Check for state changes in music notes
if (ENC != (mixer1 & 0x01)) { channelSw(1,CHNA,&mixer1,!ENC); } //If input ENC (enable C) is not equal to the state of channel A1 (note c), change the state
if (END != (mixer1 & 0x02)) { channelSw(1,CHNB,&mixer1,!END); }
if (ENE != (mixer1 & 0x04)) { channelSw(1,CHNC,&mixer1,!ENE); }
if (ENG != (mixer2 & 0x01)) { channelSw(2,CHNA,&mixer2,!ENG); }
if (ENA != (mixer2 & 0x02)) { channelSw(2,CHNB,&mixer2,!ENA); }
if (ENC5 != (mixer2 & 0x04)) { channelSw(2,CHNC,&mixer2,!ENC5); }
During the main while loop, the motor flag variable is checked to see if the motor should be driven. If so, it enters a sequence where it uses timer3 to determine the current stage in the motor cycle, changing the outputs as needed.
//Check for motor state changes
switch (motorflag) {
case 0: break; //Do nothing (motor off)
case 1: //Start motor cycle
WriteTimer3(0); //Reset timer to 0
IN1 = 0; //Set H bridge to forward drive
IN2 = 1;
EN = 1;
motorflag = 2; //In drivedown cycle
break;
case 2: //Drivedown cycle
if (ReadTimer3() > DRIVETIME) { //Wait for DRIVETIME to pass
WriteTimer3(0); //Reset timer to 0
motorflag = 3; //In driveup phase
IN2 = 0; //Switch H bridge
IN1 = 1;
}
break;
case 3: //Driveup cycle
if (ReadTimer3() > BACKTIME) { //Wait for BACKTIME to pass
WriteTimer3(0); //Reset timer to 0
motorflag = 4; //In coast/wait phase
EN = 0; //Turn off motor
}
break;
case 4: //coast / wait cycle
if (ReadTimer3() > WAITTIME) {
motorflag = 5; //more wait
WriteTimer3(0);
}
break;
case 5: //Additional wait cycle
if (ReadTimer3() > WAITTIME) {
//Done!
motorflag = 0; //Motor off (can now be triggered again)
}
break;
//Static wait cycles
case 6:
if (ReadTimer3() > WAITTIME) {
motorflag = 7;
WriteTimer3(0);
}
break;
case 7:
if (ReadTimer3() > WAITTIME) {
WriteTimer3(0);
motorflag = 8;
}
break;
case 8:
if (ReadTimer3() > WAITTIME) {
motorflag = 0;
}
break;
}

Delayms(10);
}
return 0;
}//end main

Write chip function, which is a support function that writes data to the music chips.
/* write_chip: This writes the given byte "data" to the "address" (0 or 1)
on a YMZ284. It is assumed that the chip select is already low */
void write_chip(int address,int data) {
//Write address
portout(address);
A0 = 0; //select address mode
Delayus(1); //setup time
NWR = 0; //Write cycle begin
Delayus(1); //hold time
NWR = 1; //Write cycle end

//Write data
portout(data);
A0 = 1; //select data mode
Delayus(1); //setup time
NWR = 0; //write cycle begin
Delayus(1); //hold time
NWR = 1; //write cycle end
}
Port out function
/* port_out: This function outputs a byte to the D0-D7 port */
void portout(int byte) {
// Note: !! converts an integer expression to a boolean (1 or 0).
D0 = !!(byte & 1);
D1 = !!(byte & 2);
D2 = !!(byte & 4);
D3 = !!(byte & 8);
D4 = !!(byte & 16);
D5 = !!(byte & 32);
D6 = !!(byte & 64);
D7 = !!(byte & 128);
}
Channel switch function, which writes a new mixer value to turn a channel on or off.
/* channelSw: Generic channel switch function
This writes a new mixer value to chip "chip". The mixer value
depends on "chn", the channel turning on or off, "state" whether
the channel is turning on or off, and "*mixer", a pointer to
the old mixer value. */
void channelSw(int chip, int chn, int *mixer, int state) {
/* Enable music chip */
switch(chip) {
case 1: CS1 = 0; break;
case 2: CS2 = 0; break;
case 3: CS3 = 0; break;
case 4: CS4 = 0; break;
}
/* Write mixer value */
/* This writes to channel 7 (mixer channel) the _new_ mixer value, which is
the old mixer value with a particular bit flipped based on "chn" and "state" */
write_chip(0x07, (*mixer) = state ? (*mixer) & (0xFF & ~chn) : (*mixer) | chn);
/* Disable chip */
switch(chip) {
case 1: CS1 = 1; break;
case 2: CS2 = 1; break;
case 3: CS3 = 1; break;
case 4: CS4 = 1; break;
}

}
Interrupt functions
//External interrupt for motor driving
void __ISR(_EXTERNAL_3_VECTOR, ipl6) _SingleVectorHandler(void) {
if (motorflag == 0) {
motorflag = 1; //Start motor cycle
}
//If on already, do nothing
mINT3ClearIntFlag();
}

//External interrupt for motor waiting
void __ISR(_EXTERNAL_4_VECTOR, ipl5) _SingleVectorHandler2(void) {
if (motorflag == 0) {
WriteTimer3(0);
motorflag = 6; //Start wait cycle
}
//If on already, do nothing
mINT4ClearIntFlag();
}

=Results=

The project turned out to be a mild success overall. The tilt switches worked very well for activating the music tones, but the heart rate monitor was less successful. One of the biggest issues was getting rid of very low frequency drift in the signal that made the peaks sometimes as high as 10V, but other times less 1V. Dealing with this fluctuation in peak size was the most difficult part of signal processing. As mentioned above, we tried FFT in order to establish a steady heart rate, but could not get the resolution we desired, thus we abandoned the idea.

'''PROBABLY NEED MORE TECHNICAL RESULTS HERE, BUT I'M NOT SURE WHAT TO SAY RIGHT NOW'''

The best result was that using the device was just plain fun. We each had a great time moving around and hearing the fun sounds that resulted, or if we were feeling ambitious, we would try to play a simple melody like "Mary Had a Little Lamb." It was rather difficult to play anything more complicated than that because it required lots of body control and precise movements.

=Reflections=

'''Successes'''
*tilt switches activated each of the six notes when they were supposed to
**the YMZ284 chips were able to produce all six notes at the same time, allowing cool chords
*tones were in tune and formed fun melodies and chords as the body moved
*drum actuator hit the drum reliably and with good tone
*heart rate monitor usually showed clear peaks on a scope, but was finnicky in practice

'''Room for improvements'''
*tilt switches sometimes bounced, so the beginning, or particularly the ends of the notes sounded jagged
**''Possible Solution:'' add a low pass filter to the switch signal so that the signal ramps up and down.
*the shoulder straps sometimes needed adjustments for each individual in order for the sensors to be in the correct position
**''Possible Solution:'' create straps with more constraints, such as a strap across the chest as well as the back, to ensure that the sensors are in the correct positions and orientations.
*the straps could be easier to put on
**''Possible Solution:'' maybe integrate them into a single garment, like a onesie
*the heart rate monitor was not reliable. Low frequency drift made setting a comparison level nearly impossible, especially for more than one specific user.
**''Possible Solution:'' improve FFT method so that desired resolution could be achieved in a short sample period (around 10 seconds). Or implement a complicated peak detection algorithm on the PIC.

'''JAMES SHOULD ADD SOME KIND OF HEARTWARMING CONCLUSION CUZ HE'S GOOD AT THAT STUFF'''

File:Solder board mfth.jpg

2010-03-17T08:18:00Z

EricWest: Solder board with music-generating chips, motor-driving h-bridges, and unused heart rate monitoring circuitry attached to a PIC32. Used in the Music from the Heart project.

Solder board with music-generating chips, motor-driving h-bridges, and unused heart rate monitoring circuitry attached to a PIC32. Used in the Music from the Heart project.

Music from the Heart -- Music Suit

2010-03-17T08:00:41Z

EricWest: /* Drum actuator - Mechanical Design */

=Introduction=

This project attempted to create a natural form of musical expression by connecting sensors to the body. Six tilt switches were attached to the wrist, ankles, and shoulders, each controlling a single pitch from the [http://en.wikipedia.org/wiki/Pentatonic_scale pentatonic scale]. The heart beat was obtained using [http://en.wikipedia.org/wiki/Photoplethysmograph photoplethysmography] on the user's finger, and this signal was used to strike a drum in sync with the heart beat.

For a video demonstration, click [http://www.youtube.com/watch?v=YyipByy7m6I here].

==Team Members==

[[Image:Mfth team picture.JPG|thumb|200px|From left: Thomas, Eric, James]]
*Thomas Peterson (Computer Engineering, 2010)
*James Rein (Biomedical Engineering and Music Cognition, 2010)
*Eric West (Mechanical Engineering, 2011)

=Subsystems=

Although intended as a single, cohesive system that would allow the user to intuitively make music, the project was easily divided into three subsystems: heart rate monitor, drum actuation, and music tones. Below is more explanation about each subsystem.

==Heart rate monitor - Concepts==

In brainstorming how to translate a heart beat into a drum beat, we decided that the least intrusive method would be the best. Attaching electrodes to the user would simplify the process of identifying a heart beat, but attaching the sensors directly to the skin would be a time-consuming and personally-invasive process. Instead, we decided a finger tip sensor would be much more comfortable and easy to use.

To make a finger tip sensor, we used the concepts of [http://en.wikipedia.org/wiki/Photoplethysmograph photoplethysmography]. Photoplethysmography is typically used in [http://en.wikipedia.org/wiki/Pulse_oximeter pulse oximeters] and finger-tip sensors in commercially-available devices. We originally tried to hack a heart rate monitor that we had purchased, but this proved difficult, so we decided to make our own.

The basic concept of photoplethysmography is that blood reflects a certain amount of IR light, and the blood density in the finger changes as the heart pumps, so the IR reflectivity of the finger changes as the heart beats. Using an IR emitter-detector pair found in the mechatronics lab followed by lots of amplification and filtering, we were able to obtain a decent signal with peaks when the user's heart beat.

===Heart rate monitor - Electrical Design===

The signal coming directly out of the IR detector was very weak and noisy. To obtain just the information we desired, we ran it through the following filters and amplifiers:

# [[Passive Filters#High-Pass Filter (HPF)|Passive High-Pass Filter]]
# [[Operational Amplifiers (Op-Amps)#Inverting Amplifier|Inverting Amplifier]]: gain = -470
# [http://en.wikipedia.org/wiki/Low-pass_filter#Active_electronic_realization Active Low-pass filter]: cutoff frequency = 4.82Hz, gain = -70
# [http://www.electronics-tutorials.ws/filter/filter_7.html Band-pass filter]: Frequency range = 0.72 to 3.39Hz, inverting gain = -46.8
# [[Comparators|Comparator]]: output to the PIC pin A14, with pull-up resistor to 3.3V and capacitors to smooth out the signal.

The complete signal processing circuit is shown below.

[[Image:Heartrate monitor.PNG|thumb|center|900px|Heart rate monitor circuit diagram. Click for larger image.]]

===Heart rate monitor - Mechanical Design===

[[Image:Heart rate sensor mfth.JPG|thumb|200px|Heart rate sensor with the latex band pulled away so that the emitter-detector is revealed]]
The sensor itself was a QRB1114 emitter-detector pair that was encased in open-cell foam insulation. We inserted it into the foam by drilling and filing a hole in the foam to the appropriate size, and gluing the sensor in place. A round, finger-shaped groove was filed into the foam and the sensor sat flush with the bottom of this groove. The user's finger was held in the correct position with relatively constant pressure using a latex band around the finger and the foam enclosure.

==Drum actuator - Electrical design==

Once the signal from the heart rate sensor is sent to the PIC, the rising edge triggers an interrupt which starts the driving sequence for the motor that strikes the drum. The drive sequence was: drive down (into drum) 100ms, drive up 75ms, wait 150ms. The interrupt does not do the entire driving sequence, it merely flags a variable to start the sequence, which is done in the main loop, as seen in the code below.

An additional interrupt was triggered by the falling edge of the signal; this falling edge interrupt added additional wait time that prevented the PIC from being "fooled" by a noisy falling edge. For instance, if the falling signal had some noise in it, the rising edge interrupt would be triggered again, thus causing the drum to strike on both the rising and falling edges of the heartbeat. We only wanted one strike per heartbeat, so the falling edge interrupt was triggered by the ''first'' falling edge, and any noise in the falling edge was ignored because the PIC was told to wait for 300ms. With a maximum delay of 150 + 300 = 450ms from the two interrupts, the fastest heartbeat our drum could play was 133 beats per minute, but we did not expect anyone to come play the instrument after running, so this was plenty high for our purposes.

Initially, we tried skipping the comparator and sending the analog signal directly into one of the PICs analog inputs. Our intention was to use the fast Fourier transform (FFT) library to try to extract the dominant frequency. Unfortunately, we ran into various problems. First, to get the accuracy we wanted for small frequencies, the sample window had to be very long (10 seconds or more), which made the output lag changes in heart rate. Additionally, the FFT was often "messy", which messed up our original algorithm of detecting the peak frequency between .5 and 2.5 hz. The system would sometimes randomly switch between very different frequencies, and although it was right most of the time it was enough to make the drum beating sound bad. We also tried algorithms to find the [http://en.wikipedia.org/wiki/Fundamental_frequency fundamental frequency] using the entire FFT (instead of just the .5-2.5 hz range), but this was still unreliable. We considered FFT peak detection algorithms, but they seemed to complex for the time and computing power we had available. Because of all this, we went with the simple comparator in the end.

The motor for driving the drumstick was driven by an [[media:L298N.pdf|L298 H-bridge]]. See [[Driving a high current DC Motor using an H-bridge]] for more information on how this works. Our particular circuit diagram is shown below:

[[Image:T21_motorckt_png.PNG|thumb|center|600px|Motor Circuit (non-motor PIC connections not shown). Click for larger image.]]

====Drum actuator - Mechanical Design====

[[Image:Drum stick mount mfth.jpg|thumb|200px|Attachment for the drumstick to the motor shaft.|right]]
We wanted to use a real drum for our drum beat, so our challenge was to attach a motor and drumstick to a drum. We chose a small rack tom for its resonant tone that is reminiscent of a heart beat.

To attach the drumstick to the motor shaft, we used a small block of acrylic (.5"x.75"x2"). The drumstick was cut down to 8" in length so that it would require less torque from the motor. In one end of the block, a hole was drilled and the drumstick was sanded to the correct diameter in order to snuggly fit into the hole. To ensure that the drumstick could not slide out of the block, a screw was placed in a hole drilled through both the stick and the block. The other end of the block was attached to the motor shaft using a split-clamp method: A hole the size of the motor shaft was drilled through the block, and then a slit was cut from the end of the block to the hole, allowing a screw to tightly clamp the block around the motor.

[[Image:Motor mount mfth.jpg|thumb|200px|Mounting bracket for the motor-stick assembly.|right]]
To attach the motor-stick assembly to the drum, we utilized the tuning screws on the drum and holes in the face of the motor. A sheet metal bracket with holes in the appropriate places attached the motor to two of the tuning screws. The bracket was easily made by cutting and bending a piece of 16 gauge steel sheet metal to the appropriate size. Ideally, this part would have been made out of one continuous piece of sheet metal, but we could not find a large enough sheet available in the shop, so we used rivets to connect two smaller pieces together.

After testing the drum striking, we decided it was too loud. To dampen the sound, we taped a piece of foam core and a shop rag to the head of the drum where the stick strikes it.

'''Parts list for drum actuator'''
*Bargain drumstick, at least .5" in diameter
*Small block of acrylic, .5"x.75"x2" (aluminum would work just as well, this is what was available)
*16 gauge steel sheet metal for bracket
*2 pop rivets
*Screws and nuts
*Foam core, shop rag, tape for dampening

==Music Tones - Electrical Design==
The music tones were activated by tilt switches and generated using a [http://pdf1.alldatasheet.com/datasheet-pdf/view/82065/YAMAHA/YMZ284.html YMZ284] chip and were output through a 1/8" jack to a standard set of computer speakers.

Each YMZ284 is capable of producing and mixing any combination of three tones. Since we wanted to have six notes from a [http://en.wikipedia.org/wiki/Pentatonic_scale pentatonic scale], we needed two of these chips and used an [[Operational Amplifiers (Op-Amps)#Summer|summing opamp circuit]] to combine outputs from each chip. We envisioned a possibility of adding [http://en.wikipedia.org/wiki/Overtone overtones] to each note, to make them sound better and more like a real instrument, so we ended up having four YMZ284s attached to our board. When we tried adding an overtone an octave above the fundamental frequency, it ended up sounding harsh and whiny. We decided the tones sounded better with no overtones, so we are only using 2 of the 4 chips on our board.

The YMZ284 communicates with the PIC over an 8-bit databus, plus additional pins for chip select, address, write enable, and reset. All four of our YMZ284s shared all of their pins ''except'' the chip select line; each required their own individual chip select line so that the PIC could specify with which chips it wanted to talk. The circuit diagram below shows how the chips were connected to the PIC and the summing circuit that followed.

[[Image:T21_musicckt_png.PNG|thumb|center|600px|Music circuit diagram. The summing amplifier is not shown. Click for larger image.]]

===Tilt switches - Electrical Design===
In order to detect when the limbs of the user had moved past a certain critical angle, we chose to use tilt switches. We purchased our tilt switches for $2 each from [http://www.goldmine-elec-products.com/prodinfo.asp?number=G16881 Electronics Goldmine]. We chose to use tilt switches instead of an accelerometer because the switches were much cheaper and we figured they would be easier to work with.

The tilt switches we chose are optically-based with an emitter and detector that are selectively blocked by a small ball. When the critical angle is achieved, the tiny ball rolls up a ramp, allowing the emitter to shine directly on the detector, and current flows. When the angle is neutral, the ramp forces the ball to block the light, making current stop flowing through the phototransistor. The "ramp" is really an inverted cone, so the switch can be activated by a change in angle in any direction away from the neutral position. We purchased three different tilt switches to try, each with a different critical angle - 15, 30, and 45 degrees. The configuration we ended up using was:

*30 degrees for shoulders and ankles
*45 degrees for elbows

In hindsight, we would have used all 45-degree switches because they produced the sharpest jump from off to on. The 15-degree switches were practically unusable because they created a large amount of noise as they switched on and off.

We used the tilt switches to provide high-low inputs to the PIC to tell it when to turn on any of the six tones. By attaching these switches to the body such that they are in the neutral position when the body is relaxed, we were able to control the six tones by moving the body in relatively natural ways.

===Tilt switches - Mechanical Design===

[[Image:Wrist sensor mfth.JPG|thumb|200px|Wrist tilt sensor. Ankles are similar, with a larger strap.]]
The switches were attached to the user's body using adjustable straps and buckles. The wrist and ankle sensors were simply a loop of webbing with an adjustable buckle attached. The straps could be tightened or loosened to fit any size user. To attach the switch to the straps, we created an enclosure for each switch out of high-density foam (left over scraps from DSGN 307). The switch was jammed into a hole in the foam so that it could not easily be moved. The foam was then taped to the straps using electrical tape.

The shoulder straps were a bit more involved. Two loops with buckles, similar to the wrist and ankle straps, went over the user's shoulder and underneath their armpit. To keep these straps from sliding off the shoulders, a large strap across the user's back connected the two smaller straps together. This large strap was also used for mounting the solder board which gathered the wires from all six tilt switches and sent them to the PIC over one ribbon cable. Using this strap configuration, we found that the user could comfortably and securely wear the sensors.

[[Image:Shoulder sensors mfth.JPG|thumb|200px|Shoulder straps containing the tilt sensors.]]
To attach the switches to the shoulders, we again created a foam encasement. However, electrical tape was not secure enough to hold the foam pieces to the irregularly-shaped shoulder straps. Instead, we riveted a piece of canvas to the webbing straps. We chose to use rivets instead of sewing because the sewing machine could not tightly sew the foam encasement in place. With rivets, we were able to pull the canvas tightly around the foam so that it couldn't move.

=Code=
To download the entire C file, click [[Media:Main_music.c|here]]. Below, the file is split into sections for comments.

/**********************************************************
* main_music.c: Main c file for "Music Suit" project
*
* Thomas Peterson, James Rein, Eric West
* ME333 Winter 2010
**********************************************************/

#include <HardwareProfile.h>
#include <delays.c> //Delayms and Delayus functions

The first section defines all the input and output pins, used with the motor, sensor, and music circuits.

////////////////////////////////////////////////////
//Pin Defines

//YMZ Chip selects
#define CS1 LATCbits.LATC2
#define CS2 LATCbits.LATC3
#define CS3 LATCbits.LATC4
#define CS4 LATGbits.LATG6
//YMZ communication pins
#define NWR LATBbits.LATB0 //"Not WRite": active low write line
#define A0 LATBbits.LATB6 //Address 0
#define NIC LATCbits.LATC1 //"Not Input Clear": active low reset line
//YMZ data pins
#define D0 LATGbits.LATG9
#define D1 LATEbits.LATE8
#define D2 LATEbits.LATE9
#define D3 LATBbits.LATB5
#define D4 LATBbits.LATB4
#define D5 LATBbits.LATB3
#define D6 LATBbits.LATB2
#define D7 LATBbits.LATB1

//Tilt inputs
#define ENC PORTDbits.RD3
#define END PORTDbits.RD2
#define ENE PORTDbits.RD1
#define ENG PORTCbits.RC14
#define ENA PORTCbits.RC13
#define ENC5 PORTDbits.RD0

//Motor outputs
#define IN1 LATBbits.LATB7
#define IN2 LATAbits.LATA9
#define EN LATAbits.LATA10

///////////////////////////////////////
//Other defines
//Motor times
#define MS(x) x*312.5
#define DRIVETIME MS(100)
#define BACKTIME MS(75)
#define WAITTIME MS(150)
//Channels
#define CHNA 1
#define CHNB 2
#define CHNC 4

//////////////////////////////////////////
//Function definitions
void write_chip(int address, int data);
void portout(int byte);
void channelSw(int chip, int chn, int *mixer, int state);
//Global variables
int mixer1, mixer2;
int motorflag = 0;
The initialization function sets up various parts of the system.
/* init() : This function runs initializations, setting up the pic and music chips */
void init() {
int pbClk = SYSTEMConfigPerformance(SYS_FREQ);

/////////////////////////////////////////////
//Setup inputs / outputs
AD1PCFG = 0xFFFF; //All digital inputs
TRISG &= 0xFDBF; //sets G9,G6 to 0 (output); all else remains the same
TRISC &= 0xFFE1; //sets C4,C3,C2,C1 to 0s (outputs); all else remains the same
TRISB &= 0xFF80; //sets B0-B6 0 (output)
TRISE &= 0xFCFF; //sets E8,9 to output
TRISB |= 0xF000; //sets B12,B13,B14,B15 to 1s (inputs); all else remains the same
TRISC |= 0x6000; //sets C14,13 to inputs
TRISD |= 0x000F; //Sets D0,D1,D2,D3 to inputs
TRISDbits.TRISD4 = 0; //Output for clock
//Motor outputs
TRISAbits.TRISA9 = 0;
TRISAbits.TRISA10 = 0;
TRISBbits.TRISB7 = 0;
//Pulse inputs
TRISAbits.TRISA14 = 1;
TRISAbits.TRISA15 = 1;
//ODC setup
ODCCbits.ODCC1 = 1; //open drain control; can only float high (when set high) or pull low

/* Initialize outputs */
//YMZs
CS1 = 1;
CS2 = 1;
CS3 = 1;
CS4 = 1;
NWR = 1;
A0 = 0;
NIC = 1;
//Motor
IN2 = 0;
IN1 = 0;
EN = 0;

Delayms(100); //wait for power supply to ramp up
NIC = 0; //resets YMZ284s
Delayms(10);
NIC = 1;

In the init() function, the pic writes all the setup data to the music chips. This includes the frequency registers, which determine the frequency of each output, the mixer, which determines which channels are on or off (1 = off), and the volume registers, which determine the volume of each channel. After the setup, the only register that is changed in normal operation is the mixer register, which merely turns channels on and off.
//////////////////////////////////////////////////
//Setup music chips
//Setup Chip 1//
CS1 = 0;
write_chip(0x00,0xC7); //a low // C4
write_chip(0x01,0x01); //a high
write_chip(0x02,0x98); //b low // D
write_chip(0x03,0x01); //b high
write_chip(0x04,0x6E); //c low
write_chip(0x05,0x01); //c high // E
write_chip(0x07,0xFF); //mixer (0 enables)
write_chip(0x08, 0x0A); //level (volume) A
write_chip(0x09, 0x0A); //level (volume) B
write_chip(0x0A, 0x0A); //level (volume) C
CS1=1;
//Setup Chip 2//
CS2 = 0;
write_chip(0x00,0x2C); //a low //G 392
write_chip(0x01,0x01); //a high
write_chip(0x02,0x0D); //b low //A 440
write_chip(0x03,0x01); //b high
write_chip(0x04,0xE3); //c low //C5 523.25
write_chip(0x05,0x00); //c high
write_chip(0x07,0xFF); //mixer (0 enables)
write_chip(0x08, 0x0A); //level (volume) A
write_chip(0x09, 0x0A); //level (volume) B
write_chip(0x0A, 0x0A); //level (volume) C
CS2=1;

mixer1=0xFF;
mixer2=0xFF;
OC5 is used to create a PWM signal with 50% duty at 4Mhz, in effect creating a 4Mhz square wave. This is used by the music chips as a master clock.
//////////////////////////////////////////////
//Setup OC to create master clock for music chips (~4 Mhz)
OpenOC5( OC_ON | OC_TIMER2_SRC | OC_PWM_FAULT_PIN_DISABLE, 0, 0);
OpenTimer2( T2_ON | T2_PS_1_1 | T2_SOURCE_INT, 20);
SetDCOC5PWM(10);
The interrupts are used, as mentioned above, to control when the motor is driven. The motor should drive once every rising edge.
/////////////////////////////////////////////
//External interrupt setups (for motor) - INT3 (A14)
mINT3ClearIntFlag();
mINT3IntEnable(1);
mINT3SetIntPriority(6);
mINT3SetEdgeMode(1); //Rising edge
/////////////////////////////////////////////
//External interrupt setups (for motor) - INT4 (A15)
mINT4ClearIntFlag();
mINT4IntEnable(1);
mINT4SetIntPriority(5);
mINT4SetEdgeMode(0); //Falling edge
INTEnableSystemMultiVectoredInt();

/////////////////////////////////////////////
//Setup motor timer (used for timing delays)
OpenTimer3(T3_ON | T3_PS_1_256 | T3_SOURCE_INT, 0xFFFF);
ConfigIntTimer3(T3_INT_OFF);
}

Main function
/* Main function */
int main()
{
init(); /* Run initialization functions */
Delayms(1);

/* Main while loop: loop indefinietly */
while (1) {
In the main while loop, the PIC checks every cycle to see if an input has changed since the last cycle. Since the "mixer" variables store the current state, if an input does not match up with its valid mixer bit then it has changed recently. In this case, the channelSw() function is called to switch on or off the music channel controlled by that bit.
//Check for state changes in music notes
if (ENC != (mixer1 & 0x01)) { channelSw(1,CHNA,&mixer1,!ENC); } //If input ENC (enable C) is not equal to the state of channel A1 (note c), change the state
if (END != (mixer1 & 0x02)) { channelSw(1,CHNB,&mixer1,!END); }
if (ENE != (mixer1 & 0x04)) { channelSw(1,CHNC,&mixer1,!ENE); }
if (ENG != (mixer2 & 0x01)) { channelSw(2,CHNA,&mixer2,!ENG); }
if (ENA != (mixer2 & 0x02)) { channelSw(2,CHNB,&mixer2,!ENA); }
if (ENC5 != (mixer2 & 0x04)) { channelSw(2,CHNC,&mixer2,!ENC5); }
During the main while loop, the motor flag variable is checked to see if the motor should be driven. If so, it enters a sequence where it uses timer3 to determine the current stage in the motor cycle, changing the outputs as needed.
//Check for motor state changes
switch (motorflag) {
case 0: break; //Do nothing (motor off)
case 1: //Start motor cycle
WriteTimer3(0); //Reset timer to 0
IN1 = 0; //Set H bridge to forward drive
IN2 = 1;
EN = 1;
motorflag = 2; //In drivedown cycle
break;
case 2: //Drivedown cycle
if (ReadTimer3() > DRIVETIME) { //Wait for DRIVETIME to pass
WriteTimer3(0); //Reset timer to 0
motorflag = 3; //In driveup phase
IN2 = 0; //Switch H bridge
IN1 = 1;
}
break;
case 3: //Driveup cycle
if (ReadTimer3() > BACKTIME) { //Wait for BACKTIME to pass
WriteTimer3(0); //Reset timer to 0
motorflag = 4; //In coast/wait phase
EN = 0; //Turn off motor
}
break;
case 4: //coast / wait cycle
if (ReadTimer3() > WAITTIME) {
motorflag = 5; //more wait
WriteTimer3(0);
}
break;
case 5: //Additional wait cycle
if (ReadTimer3() > WAITTIME) {
//Done!
motorflag = 0; //Motor off (can now be triggered again)
}
break;
//Static wait cycles
case 6:
if (ReadTimer3() > WAITTIME) {
motorflag = 7;
WriteTimer3(0);
}
break;
case 7:
if (ReadTimer3() > WAITTIME) {
WriteTimer3(0);
motorflag = 8;
}
break;
case 8:
if (ReadTimer3() > WAITTIME) {
motorflag = 0;
}
break;
}

Delayms(10);
}
return 0;
}//end main

Write chip function, which is a support function that writes data to the music chips.
/* write_chip: This writes the given byte "data" to the "address" (0 or 1)
on a YMZ284. It is assumed that the chip select is already low */
void write_chip(int address,int data) {
//Write address
portout(address);
A0 = 0; //select address mode
Delayus(1); //setup time
NWR = 0; //Write cycle begin
Delayus(1); //hold time
NWR = 1; //Write cycle end

//Write data
portout(data);
A0 = 1; //select data mode
Delayus(1); //setup time
NWR = 0; //write cycle begin
Delayus(1); //hold time
NWR = 1; //write cycle end
}
Port out function
/* port_out: This function outputs a byte to the D0-D7 port */
void portout(int byte) {
// Note: !! converts an integer expression to a boolean (1 or 0).
D0 = !!(byte & 1);
D1 = !!(byte & 2);
D2 = !!(byte & 4);
D3 = !!(byte & 8);
D4 = !!(byte & 16);
D5 = !!(byte & 32);
D6 = !!(byte & 64);
D7 = !!(byte & 128);
}
Channel switch function, which writes a new mixer value to turn a channel on or off.
/* channelSw: Generic channel switch function
This writes a new mixer value to chip "chip". The mixer value
depends on "chn", the channel turning on or off, "state" whether
the channel is turning on or off, and "*mixer", a pointer to
the old mixer value. */
void channelSw(int chip, int chn, int *mixer, int state) {
/* Enable music chip */
switch(chip) {
case 1: CS1 = 0; break;
case 2: CS2 = 0; break;
case 3: CS3 = 0; break;
case 4: CS4 = 0; break;
}
/* Write mixer value */
/* This writes to channel 7 (mixer channel) the _new_ mixer value, which is
the old mixer value with a particular bit flipped based on "chn" and "state" */
write_chip(0x07, (*mixer) = state ? (*mixer) & (0xFF & ~chn) : (*mixer) | chn);
/* Disable chip */
switch(chip) {
case 1: CS1 = 1; break;
case 2: CS2 = 1; break;
case 3: CS3 = 1; break;
case 4: CS4 = 1; break;
}

}
Interrupt functions
//External interrupt for motor driving
void __ISR(_EXTERNAL_3_VECTOR, ipl6) _SingleVectorHandler(void) {
if (motorflag == 0) {
motorflag = 1; //Start motor cycle
}
//If on already, do nothing
mINT3ClearIntFlag();
}

//External interrupt for motor waiting
void __ISR(_EXTERNAL_4_VECTOR, ipl5) _SingleVectorHandler2(void) {
if (motorflag == 0) {
WriteTimer3(0);
motorflag = 6; //Start wait cycle
}
//If on already, do nothing
mINT4ClearIntFlag();
}

=Results=

The project turned out to be a mild success overall. The tilt switches worked very well for activating the music tones, but the heart rate monitor was less successful. One of the biggest issues was getting rid of very low frequency drift in the signal that made the peaks sometimes as high as 10V, but other times less 1V. Dealing with this fluctuation in peak size was the most difficult part of signal processing. As mentioned above, we tried FFT in order to establish a steady heart rate, but could not get the resolution we desired, thus we abandoned the idea.

'''PROBABLY NEED MORE TECHNICAL RESULTS HERE, BUT I'M NOT SURE WHAT TO SAY RIGHT NOW'''

The best result was that using the device was just plain fun. We each had a great time moving around and hearing the fun sounds that resulted, or if we were feeling ambitious, we would try to play a simple melody like "Mary Had a Little Lamb." It was rather difficult to play anything more complicated than that because it required lots of body control and precise movements.

=Reflections=

'''Successes'''
*tilt switches activated each of the six notes when they were supposed to
**the YMZ284 chips were able to produce all six notes at the same time, allowing cool chords
*tones were in tune and formed fun melodies and chords as the body moved
*drum actuator hit the drum reliably and with good tone
*heart rate monitor usually showed clear peaks on a scope, but was finnicky in practice

'''Room for improvements'''
*tilt switches sometimes bounced, so the beginning, or particularly the ends of the notes sounded jagged
**''Possible Solution:'' add a low pass filter to the switch signal so that the signal ramps up and down.
*the shoulder straps sometimes needed adjustments for each individual in order for the sensors to be in the correct position
**''Possible Solution:'' create straps with more constraints, such as a strap across the chest as well as the back, to ensure that the sensors are in the correct positions and orientations.
*the straps could be easier to put on
**''Possible Solution:'' maybe integrate them into a single garment, like a onesie
*the heart rate monitor was not reliable. Low frequency drift made setting a comparison level nearly impossible, especially for more than one specific user.
**''Possible Solution:'' improve FFT method so that desired resolution could be achieved in a short sample period (around 10 seconds). Or implement a complicated peak detection algorithm on the PIC.

'''JAMES SHOULD ADD SOME KIND OF HEARTWARMING CONCLUSION CUZ HE'S GOOD AT THAT STUFF'''

File:Motor mount mfth.jpg

2010-03-17T07:57:46Z

EricWest: Bracket mount for the motor-stick assembly. The existing tuning screws were used to secure the bracket to the drum.

Bracket mount for the motor-stick assembly. The existing tuning screws were used to secure the bracket to the drum.

File:Drum stick mount mfth.jpg

2010-03-17T07:52:59Z

EricWest: Mount to attach the drum stick to the drive shaft of the motor for the Music from the Heart project.

Mount to attach the drum stick to the drive shaft of the motor for the Music from the Heart project.

ME 333 final projects

2010-03-17T07:45:26Z

EricWest: /* Music from the Heart -- Music Suit */

See the '''[[ME 333 end of course schedule]]'''.

Final projects for ME 333 in years 2000-2007 can be found
'''[http://lims.mech.northwestern.edu/~design/mechatronics/ here]'''.

__TOC__

== ME 333 Final Projects 2010 ==

=== [[Sample Project Title]] ===

[[Image:Persistence of Vison Display|thumb|150px|Project photo caption.|right]]

You can copy and paste this wiki code to start your wiki page (but don't erase this code). Then replace this text with your own. A few sentences describing what your project does, with a link to a youtube video. Look at other final project wiki pages for ideas, but see [[ME 333 end of course schedule]] for more information on what should be included on your wiki page.

 

=== [[Furuta Pendulum]] ===

[[Image:Picture 1.png|thumb|150px|Furuta Pendulum|right]]

The Furuta pendulum, so named because it was first developed by Katsuhisa Furuta, is a rotational inverted pendulum. In other words, the horizontal arm, which rotates in the horizontal plane, drives the movement of the vertical arm, which is free to rotate in the vertical plane. Out objective was to build a Furuta pendulum that would hold the vertical arm up, as you can see from the [http://www.youtube.com/watch?v=7DtFLKgNUk4 demonstration video].

 

=== [[Music from the Heart -- Music Suit]] ===

[[Image:Persistence of Vison Display|thumb|150px|Project photo caption.|right]]

This project attempted to create a natural form of musical expression by connecting sensors to the body. Six tilt switches were attached to the wrist, ankles, and shoulders, each controlling a single pitch from the [http://en.wikipedia.org/wiki/Pentatonic_scale pentatonic scale]. The heart beat was obtained using [http://en.wikipedia.org/wiki/Photoplethysmograph photoplethysmography] on the user's finger, and this signal was used to strike a drum in sync with the heart beat.

For a video demonstration, click [http://www.youtube.com/watch?v=YyipByy7m6I here].

 

=== [[Conservation of Angular Momentum Locomotion Robot (Fluffbot)]] ===

[[Image:Persistence of Vison Display|thumb|150px|Project photo caption.|right]]

Cute fluffy robot that uses conservation of angular momentum to move forward and backward. The robot's momentum wheel accelerates in the floor-plane. The robot's net angular momentum must remain zero-- a steering wheel guides the Fluffbot to accelerate in the opposite direction. This moves the robot forward in a curved path. The momentum wheel and steering wheel then change direction of acceleration. This repeated process moves the Fluffbot forward in a sinusoidal path.

 

=== [[Differential Drive Mobile Robot]] ===

[[Image:Persistence of Vison Display|thumb|150px|Project photo caption.|right]]

The goal of this project was to create a small differential drive mobile robot that would act as a low cost replacement for the popular E-Puck Robot. The robot uses hybrid stepper motors to allow it to track its position through odometry, has a laser cut acrylic chassis for easy replication and replacement, and a 1500 mAh, 13.2V battery pack for long run time. The robot also uses the NU32 board for its control logic and a XBee chip for communication.

 

=== [[Ferrofluid Art Display]] ===

[[Image:Persistence of Vison Display|thumb|150px|Place holder text for caption .|right]]

A little blurb about our Ferrofluid Art Display will go here. Just a few sentences talking about blah blah lkasjdfal hfalsdjh.

 

=== [[Can Launching Fridge]] ===

[[Image:27_Fridge.jpg|thumb|150px|Project photo caption.|right]]

The goal of the can launching fridge was to create a fridge that would, when initiated by either a remote control or a wired push button, automatically load, aim, and fire a can to multiple predetermined locations. The fridge uses a combination of stepper motors, a DC motor, and solenoids to create the ultimate mix of convenience, fun, and refreshment.

 

=== [[High Speed Motor Control]] ===

[[Image:2dofArmSetUp.jpg|thumb|150px|Project photo caption.|right]]
The project suggested was to design a system for high speed motor control using the PIC 32. To demonstrate the motor control, a two degree of freedom (2-DOF) parallelogram robot arm was designed to follow paths specified in a MATLAB gui.

 

=== [[Variable Frequency Electrosense]] ===

[[Image:TR_JP_PP-sensor.jpg|thumb|150px|Project photo caption.|right]]

Our objective was to build upon existing research being done at Northwestern utilizing Electrosense technology by testing if information can be derived from varying the emitter frequency. We sought to send sinusoidal waves at discrete frequencies between 100 Hz and 10 kHz and to read in the sensed wave using a PIC 32’s ADC. We then sent the gathered information to a PC for plotting and analysis. By mounting the sensor on a one dimensional linear actuator we are able to gather additional data about objects and perform object detection and identification algorithms. While our initial results have revealed exciting trends, farther research is necessary before any significant conclusions can be made. A [http://www.youtube.com/watch?v=PJY097L2m1M video] of the project is available on YouTube.

 

=== [[Remote Controlled Wiitar]] ===

[[Image:Persistence of Vison Display|thumb|150px|Project photo caption.|right]]
This project uses an array of solenoids to depress stings on the neck of a guitar. A motor over the strings of the guitar turns an arm which strums the instrument, playing the chord depressed by the solenoids. The system is controlled by a Wii Remote.

 

=== [[6-DOF PPOD]] ===

[[Image:Persistence of Vison Display|thumb|150px|Project photo caption.|right]]
The PPOD-mini is a miniaturized version of the Programmable Part-feeding Oscillatory Device ([http://lims.mech.northwestern.edu/projects/frictioninducedforcefields/index.htm PPOD]) found in the Laboratory for Intelligent Mechanical Systems (LIMS).

 

== ME 333 Final Projects 2009 ==

=== [[Mozart's Right Hand]] ===
[[Image:mrh_box.JPG|thumb|150px|Mozart's Right Hand|right]]
Mozart's Right Hand is a musical instrument capable of playing two full octaves of the [http://en.wikipedia.org/wiki/Diatonic_scale Diatonic Scale.] The user wears a glove on his right hand and uses motions of the hand and fingers to create different notes that are played with a speaker. The pitch of the note is controlled by the orientation of the user's hand as he rotates it ether from the wrist, the elbow, or the shoulder. The LCD on the front of the box tells the user the pitch that corresponds to his or her current hand orientation. When the user touches together his thumb and index finger, the speaker plays the tone. A [http://www.youtube.com/watch?v=vec-W4QeHQU video] of Mozart's Right Hand in action is available on YouTube.

'''Chosen the OUTSTANDING PROJECT by the students of ME 333.'''

 

=== [[Persistence-of-Vision Display]] ===
[[Image:Persistence of Vison Display|right|thumb|150px]]
This is a fully customizable display implemented using the concept of Persistence of Vision. User-specified images (and even moving images) were displayed by rotating a column of LEDs at speeds faster than 300rpm. Each individual LED was modeled as a row of pixels. Conversely, the rotational position of the panel of LEDs represented the pixel columns of the display; the time interval and rotational speed determined the width of the pixel columns.

 

=== [[Rock Paper Scissors Machine]] ===
[[Image:rps whole thing.JPG|thumb|150px|Rock Paper Scissors Machine|right]]
A machine that will play a fully functioning, intuitive game of [http://en.wikipedia.org/wiki/Rock-paper-scissors Rock/Paper/Scissors] (abbreviated as RPS) with a user. The machine is represented by a human-like hand, capable of seperate and independant wrist, arm, finger and thumb motion. The players' hand goes into a glove equipped with flex sensors, which wirelessly transmits data to the machine based on what the player chose. The machine then reads this data, randomly chooses a throw of its own, and displays what the machine threw, what the human threw, total win/loss/tie info, and winner/loser both on an [http://en.wikipedia.org/wiki/Lcd LCD] screen and in the form of a thumbs up/down/side motion. Video of the machine in action can be found [http://www.youtube.com/watch?v=xbLNBSTTrcE here.]
 

=== [[Three-speaker Chladni Patterns]] ===
[[Image:chladni_660hz|right|thumb|150px]]
This project uses three speakers to generate shapes on a circular aluminum plate depending on which frequency the speakers are playing at. Once the speakers hit a resonant frequency of the plate, salt migrates to the nodes (zero amplitude) regions of the plate to form distinct patterns.
 

=== [[Basketball]] ===
[[Image:Mechatronics2009Bball|right|thumb|150px]]
This project consists of a throwing arm propelled by a Pittman motor is mounted on a turntable and throws the ball into the "hoop." The hoop is wrapped in reflective tape and an IR emitter, receiver pair is used to sense where the IR is reflected most (the hoop with highly reflective tape). An ultrasonic sensor then pings the hoop for the distance of the hoop. With this information, the arm is able to "make a basket." A video can be found [http://www.youtube.com/watch?v=Y466dzP-qiY here].
 

=== [[Robot Drummer]] ===
[[Image:Robot_Drummer.jpg|thumb|400pix|right|Robot Drummer]]
The Robot Drummer is a device that demonstrates high-speed motor control by being able to drum when given commands. Through an RS232 cable, Matlab sends commands to a "master" PIC. The master then sends the commands to two "slave" PICs through I2C communication. The slaves take the commands and implement PID control of the motors.
 

=== [[Automated Fish Refuge]] ===
[[Image:Entire Fish Refuge|right|thumb|200px]]
The automated fish refuge allows for the controlled movement of a fish refuge with the goal of recording specific behavior. The mechanical design is completely adjustable and allows adjustable degrees of oscillating movement and orientation of the refuge. The program is primarily in MATLAB for ease of use and the velocity profile can be a sine, square, triangle, or any function that the user inputs. [http://www.youtube.com/watch?v=wGOKujMhN88 Check out the video!]

 

=== [[Marionette]] ===
[[Image: MarionettePicForIntro.JPG|right|thumb]] The Marionette Project focused on using RC Servos to make a puppet that would do a dance with the press of a button. There were 5 different dances programmed for the marionette, showcasing different styles of movement. The movement had 2 degrees of freedom thanks to using 5 bar linkages and 2 RC servos for each arm. Two more RC Servos were used on the back of the marionette to create the appearance of leg movement. The movements included a Hula dance, Jumping Jacks, and even some moves right out of Saturday Night Fever.

 

=== [[Monkeybot]] ===
[[Image:monkeybot_pic|thumb|right|200px|Monkeybot]]
The monkeybot is a swinging robot capable of moving side to side and climbing. It consists of a two link, double pendulum system with an electro-magnet on each end. At the pivot is a DC motor, which provides an input torque and allows the swinging system to gain energy and climb. Check out the video of the monkeybot climbing [http://www.youtube.com/watch?v=TA2VcH_GDJ0 here] and a later brachiation video [http://www.youtube.com/watch?v=0hfwJEVQyeQ&feature=related here].
 

=== [[PPOD-mini: 6-DOF Shaker]] ===
[[Image:PPOD_mini.JPG|thumb|200x200 px|right|PPOD-mini 6-DOF Shaker]]
The PPOD-mini is a miniaturized version of the Programmable Part-feeding Oscillatory Device ([http://lims.mech.northwestern.edu/projects/frictioninducedforcefields/index.htm PPOD]) found in the Laboratory for Intelligent Mechanical Systems (LIMS) at Northwestern. The PPOD-mini utilizes six speakers that act like actuators. The speakers are connected to a acrylic plate via flexures of tygon and iron. In its current implementation, the phase of the speakers can be controlled independently, giving the device six degrees of freedom. The movement of objects placed on the acrylic plate can be controlled by changing the phases of the speakers.

 

=== [[Automated Xylophone]] ===
[[Image:AutomatedXylophonePicture1.jpg|thumb|200x200 px|right|Automated Xylophone]]
The Automated Xylophone controls several solenoids which hit various pitches on an actual xylophone based on the note selected. The device has two main modes: using the keypad, a user can choose to either play notes in real time or store songs to be played back later. A video of the Automated Xylophone playing in real time mode can be found [http://www.youtube.com/watch?v=_ubpAEyq9kg here].

 

=== [[Vision-based Cannon]] ===
[[Image:SM_Gun_Camera_PIC_Setup.JPG|thumb|200x200 px|right|Vision-based Cannon]]
This project uses a webcam and Matlab to analyze an image and direct a modified USB Missile Launcher to fire at targets found in the image.

 

=== [[Butterfly Rolling Manipulation]] ===
[[Image:Persistence of Vison Display|right|thumb|150px]]
The Butterfly emulates contact juggling by the stabilization of dynamic rolling. The apparatus rolls a cylinder by rotating the "hand" using a specific trajectory and is able to move the cylinder from one side to the other without losing contact. A video of the Butterfly captured in high speed can be found [http://www.youtube.com/watch?v=hFafcjA_p7E here].

 

== ME 333 Final Projects 2008 ==

=== [[IR Tracker]] ===

[[Image:IR_Tracker_Main.jpg|right|thumb|200px]]

The IR Tracker (aka "Spot") is a device that follows a moving infrared light. It continuously detects the position of an infrared emitter in two axes, and then tracks the emitter with a laser. [[Media:MT_MS_AZ_TrackerVideo.mp4|See Spot Run.]]

'''Chosen the OUTSTANDING PROJECT by the students of ME 333.'''

 

=== [[Robot Snake]] ===
[[Image:HLSSnakeMain.jpg|right|thumb|200px]]

This remote control robotic snake uses servo motors with a traveling sine wave motion profile to mimic serpentine motion. The robotic snake is capable of moving forward, left, right and in reverse.

[http://www.youtube.com/watch?v=r_GOOFLnI6w Video of the robot snake]

Featured on [http://blog.makezine.com/archive/2009/03/well_documented_robotic_snake.html Makezine.com].
 

=== [[Programmable Stiffness Joint]] ===

[[Image:SteelToePic2.jpg|thumb|200px|The 'Steel Toe' programmable stiffness joint|right]]

The Programmable Stiffness Joint varies rotational stiffness as desired by the user. It is the first step in modeling the mechanical impedance of the human ankle joint (both stiffness and damping) for the purpose of determining the respective breakdown of the two properties over the gait cycle.

 

=== [[Magnetic based sample purification]] ===

 

=== [[Continuously Variable Transmission]] ===

[[image:CVT_system.JPG|thumb|200px]]

This prototype is a proof of concept model of a variable ratio transmission to be implemented in the 2008-2009 Formula SAE competition vehicle. The gear ratio is determined by the distances between the pulley halves which are controllable electronically.

 

=== [[Granular Flow Rotating Sphere]] ===
[[Image:Team-21-main-picture.JPG|right|thumb|200px]]
This device will be used to study the granular flow of particles within a rotating sphere. The sphere is filled with grains of varying size and then rotated about two different axes according to a series of position and angular velocity inputs.

 

=== [[Vibratory Clock]] ===

[[Image:Vibratory_Clock.jpg|right|thumb|Vibratory Clock|200px]]

The Vibratory Clock allows a small object to act as an hour "hand" on a horizontal circular platform that is actuated from underneath by three speakers. The object slides around the circular platform, impelled by friction forces due to the vibration. [http://www.youtube.com/watch?v=KhgTNCfdwZw Check it out!]

 

=== [[WiiMouse]] ===

[[Image:HPIM1027.jpg|right|thumb|200px]]

The WiiMouse is a handheld remote that can be used to move a cursor on a windows-based PC, via accelerometer input captured through device movement.

 

=== [[Intelligent Oscillation Controller]] ===

[[image:ME333_learning_oscillator.jpg|thumb|200px]]

This device "learns" a forcing function that is applied to a spring and mass system to match an arbitrary, periodic acceleration profile.

 

=== [[Baseball]] ===

[[Image:Baseball_Playfield.jpg|Sweet Baseball Game|right|thumb|200px]]

An interactive baseball game inspired by pinball, featuring pitching, batting, light up bases and a scoreboard to keep track of the game.

 

=== [[Ball Balancing Challenge]] ===

[[Image:Ballbalancechallenge.JPG|right|thumb|200px]]

An interactive game involving ball balancing on a touchscreen with touchscreen feedback and joystick action.

Music from the Heart -- Music Suit

2010-03-17T07:09:02Z

EricWest:

=Introduction=

This project attempted to create a natural form of musical expression by connecting sensors to the body. Six tilt switches were attached to the wrist, ankles, and shoulders, each controlling a single pitch from the [http://en.wikipedia.org/wiki/Pentatonic_scale pentatonic scale]. The heart beat was obtained using [http://en.wikipedia.org/wiki/Photoplethysmograph photoplethysmography] on the user's finger, and this signal was used to strike a drum in sync with the heart beat.

For a video demonstration, click [http://www.youtube.com/watch?v=YyipByy7m6I here].

==Team Members==

[[Image:Mfth team picture.JPG|thumb|200px|From left: Thomas, Eric, James]]
*Thomas Peterson (Computer Engineering, 2010)
*James Rein (Biomedical Engineering and Music Cognition, 2010)
*Eric West (Mechanical Engineering, 2011)

=Subsystems=

Although intended as a single, cohesive system that would allow the user to intuitively make music, the project was easily divided into three subsystems: heart rate monitor, drum actuation, and music tones. Below is more explanation about each subsystem.

==Heart rate monitor - Concepts==

In brainstorming how to translate a heart beat into a drum beat, we decided that the least intrusive method would be the best. Attaching electrodes to the user would simplify the process of identifying a heart beat, but attaching the sensors directly to the skin would be a time-consuming and personally-invasive process. Instead, we decided a finger tip sensor would be much more comfortable and easy to use.

To make a finger tip sensor, we used the concepts of [http://en.wikipedia.org/wiki/Photoplethysmograph photoplethysmography]. Photoplethysmography is typically used in [http://en.wikipedia.org/wiki/Pulse_oximeter pulse oximeters] and finger-tip sensors in commercially-available devices. We originally tried to hack a heart rate monitor that we had purchased, but this proved difficult, so we decided to make our own.

The basic concept of photoplethysmography is that blood reflects a certain amount of IR light, and the blood density in the finger changes as the heart pumps, so the IR reflectivity of the finger changes as the heart beats. Using an IR emitter-detector pair found in the mechatronics lab followed by lots of amplification and filtering, we were able to obtain a decent signal with peaks when the user's heart beat.

===Heart rate monitor - Electrical Design===

The signal coming directly out of the IR detector was very weak and noisy. To obtain just the information we desired, we ran it through the following filters and amplifiers:

# [[Passive Filters#High-Pass Filter (HPF)|Passive High-Pass Filter]]
# [[Operational Amplifiers (Op-Amps)#Inverting Amplifier|Inverting Amplifier]]: gain = -470
# [http://en.wikipedia.org/wiki/Low-pass_filter#Active_electronic_realization Active Low-pass filter]: cutoff frequency = 4.82Hz, gain = -70
# [http://www.electronics-tutorials.ws/filter/filter_7.html Band-pass filter]: Frequency range = 0.72 to 3.39Hz, inverting gain = -46.8
# [[Comparators|Comparator]]: output to the PIC pin A14, with pull-up resistor to 3.3V and capacitors to smooth out the signal.

The complete signal processing circuit is shown below.

[[Image:Heartrate monitor.PNG|thumb|center|900px|Heart rate monitor circuit diagram. Click for larger image.]]

===Heart rate monitor - Mechanical Design===

[[Image:Heart rate sensor mfth.JPG|thumb|200px|Heart rate sensor with the latex band pulled away so that the emitter-detector is revealed]]
The sensor itself was a QRB1114 emitter-detector pair that was encased in open-cell foam insulation. We inserted it into the foam by drilling and filing a hole in the foam to the appropriate size, and gluing the sensor in place. A round, finger-shaped groove was filed into the foam and the sensor sat flush with the bottom of this groove. The user's finger was held in the correct position with relatively constant pressure using a latex band around the finger and the foam enclosure.

==Drum actuator - Electrical design==

Once the signal from the heart rate sensor is sent to the PIC, the rising edge triggers an interrupt which starts the driving sequence for the motor that strikes the drum. The drive sequence was: drive down (into drum) 100ms, drive up 75ms, wait 150ms. The interrupt does not do the entire driving sequence, it merely flags a variable to start the sequence, which is done in the main loop, as seen in the code below.

An additional interrupt was triggered by the falling edge of the signal; this falling edge interrupt added additional wait time that prevented the PIC from being "fooled" by a noisy falling edge. For instance, if the falling signal had some noise in it, the rising edge interrupt would be triggered again, thus causing the drum to strike on both the rising and falling edges of the heartbeat. We only wanted one strike per heartbeat, so the falling edge interrupt was triggered by the ''first'' falling edge, and any noise in the falling edge was ignored because the PIC was told to wait for 300ms. With a maximum delay of 150 + 300 = 450ms from the two interrupts, the fastest heartbeat our drum could play was 133 beats per minute, but we did not expect anyone to come play the instrument after running, so this was plenty high for our purposes.

Initially, we tried skipping the comparator and sending the analog signal directly into one of the PICs analog inputs. Our intention was to use the fast Fourier transform (FFT) library to try to extract the dominant frequency. Unfortunately, we ran into various problems. First, to get the accuracy we wanted for small frequencies, the sample window had to be very long (10 seconds or more), which made the output lag changes in heart rate. Additionally, the FFT was often "messy", which messed up our original algorithm of detecting the peak frequency between .5 and 2.5 hz. The system would sometimes randomly switch between very different frequencies, and although it was right most of the time it was enough to make the drum beating sound bad. We also tried algorithms to find the [http://en.wikipedia.org/wiki/Fundamental_frequency fundamental frequency] using the entire FFT (instead of just the .5-2.5 hz range), but this was still unreliable. We considered FFT peak detection algorithms, but they seemed to complex for the time and computing power we had available. Because of all this, we went with the simple comparator in the end.

The motor for driving the drumstick was driven by an [[media:L298N.pdf|L298 H-bridge]]. See [[Driving a high current DC Motor using an H-bridge]] for more information on how this works. Our particular circuit diagram is shown below:

[[Image:T21_motorckt_png.PNG|thumb|center|600px|Motor Circuit (non-motor PIC connections not shown). Click for larger image.]]

====Drum actuator - Mechanical Design====

We wanted to use a real drum for our drum beat, so our challenge was to attach a motor and drumstick to a drum. We chose a small rack tom for its resonant tone that is reminiscent of a heart beat.

To attach the drumstick to the motor shaft, we used a small block of acrylic (.5"x.5"x2"). The drumstick was cut down to 8" in length so that it would require less torque from the motor. In one end of the block, a hole was drilled and the drumstick was sanded to the correct diameter in order to snuggly fit into the hole. To ensure that the drumstick could not slide out of the block, a screw was placed in a hole drilled through both the stick and the block. The other end of the block was attached to the motor shaft using a split-clamp method: A hole the size of the motor shaft was drilled through the block, and then a slit was cut from the end of the block to the hole, allowing a screw to tightly clamp the block around the motor.

'''INSERT PICTURE OF DRUMSTICK-MOTORSHAFT ATTACHMENT'''

To attach the motor-stick assembly to the drum, we utilized the tuning screws on the drum. A sheet metal bracket with holes in the appropriate places attached the motor to two of these tuning screws. The bracket was easily made by cutting and bending a piece of 16 gauge steel sheet metal to the appropriate size. Ideally, this part would have been made out of one continuous piece of sheet metal, but we could not find a large enough sheet available in the shop, so we used rivets to connect two smaller pieces together.

After testing the drum striking, we decided it was too loud. To dampen the sound, we taped a piece of foam core and a shop rag to the head of the drum where the stick strikes it.

'''Parts list for drum actuator'''
*Bargain drumstick, at least .5" in diameter
*Small block of acrylic, .5"x.5"x2" (aluminum would work just as well, this is what was available)
*16 gauge steel sheet metal for bracket
*Screws and nuts
*Foam core, shop rag, tape for dampening

==Music Tones - Electrical Design==
The music tones were activated by tilt switches and generated using a [http://pdf1.alldatasheet.com/datasheet-pdf/view/82065/YAMAHA/YMZ284.html YMZ284] chip and were output through a 1/8" jack to a standard set of computer speakers.

Each YMZ284 is capable of producing and mixing any combination of three tones. Since we wanted to have six notes from a [http://en.wikipedia.org/wiki/Pentatonic_scale pentatonic scale], we needed two of these chips and used an [[Operational Amplifiers (Op-Amps)#Summer|summing opamp circuit]] to combine outputs from each chip. We envisioned a possibility of adding [http://en.wikipedia.org/wiki/Overtone overtones] to each note, to make them sound better and more like a real instrument, so we ended up having four YMZ284s attached to our board. When we tried adding an overtone an octave above the fundamental frequency, it ended up sounding harsh and whiny. We decided the tones sounded better with no overtones, so we are only using 2 of the 4 chips on our board.

The YMZ284 communicates with the PIC over an 8-bit databus, plus additional pins for chip select, address, write enable, and reset. All four of our YMZ284s shared all of their pins ''except'' the chip select line; each required their own individual chip select line so that the PIC could specify with which chips it wanted to talk. The circuit diagram below shows how the chips were connected to the PIC and the summing circuit that followed.

[[Image:T21_musicckt_png.PNG|thumb|center|600px|Music circuit diagram. The summing amplifier is not shown. Click for larger image.]]

===Tilt switches - Electrical Design===
In order to detect when the limbs of the user had moved past a certain critical angle, we chose to use tilt switches. We purchased our tilt switches for $2 each from [http://www.goldmine-elec-products.com/prodinfo.asp?number=G16881 Electronics Goldmine]. We chose to use tilt switches instead of an accelerometer because the switches were much cheaper and we figured they would be easier to work with.

The tilt switches we chose are optically-based with an emitter and detector that are selectively blocked by a small ball. When the critical angle is achieved, the tiny ball rolls up a ramp, allowing the emitter to shine directly on the detector, and current flows. When the angle is neutral, the ramp forces the ball to block the light, making current stop flowing through the phototransistor. The "ramp" is really an inverted cone, so the switch can be activated by a change in angle in any direction away from the neutral position. We purchased three different tilt switches to try, each with a different critical angle - 15, 30, and 45 degrees. The configuration we ended up using was:

*30 degrees for shoulders and ankles
*45 degrees for elbows

In hindsight, we would have used all 45-degree switches because they produced the sharpest jump from off to on. The 15-degree switches were practically unusable because they created a large amount of noise as they switched on and off.

We used the tilt switches to provide high-low inputs to the PIC to tell it when to turn on any of the six tones. By attaching these switches to the body such that they are in the neutral position when the body is relaxed, we were able to control the six tones by moving the body in relatively natural ways.

===Tilt switches - Mechanical Design===

[[Image:Wrist sensor mfth.JPG|thumb|200px|Wrist tilt sensor. Ankles are similar, with a larger strap.]]
The switches were attached to the user's body using adjustable straps and buckles. The wrist and ankle sensors were simply a loop of webbing with an adjustable buckle attached. The straps could be tightened or loosened to fit any size user. To attach the switch to the straps, we created an enclosure for each switch out of high-density foam (left over scraps from DSGN 307). The switch was jammed into a hole in the foam so that it could not easily be moved. The foam was then taped to the straps using electrical tape.

The shoulder straps were a bit more involved. Two loops with buckles, similar to the wrist and ankle straps, went over the user's shoulder and underneath their armpit. To keep these straps from sliding off the shoulders, a large strap across the user's back connected the two smaller straps together. This large strap was also used for mounting the solder board which gathered the wires from all six tilt switches and sent them to the PIC over one ribbon cable. Using this strap configuration, we found that the user could comfortably and securely wear the sensors.

[[Image:Shoulder sensors mfth.JPG|thumb|200px|Shoulder straps containing the tilt sensors.]]
To attach the switches to the shoulders, we again created a foam encasement. However, electrical tape was not secure enough to hold the foam pieces to the irregularly-shaped shoulder straps. Instead, we riveted a piece of canvas to the webbing straps. We chose to use rivets instead of sewing because the sewing machine could not tightly sew the foam encasement in place. With rivets, we were able to pull the canvas tightly around the foam so that it couldn't move.

=Code=
To download the entire C file, click [[Media:Main_music.c|here]]. Below, the file is split into sections for comments.

/**********************************************************
* main_music.c: Main c file for "Music Suit" project
*
* Thomas Peterson, James Rein, Eric West
* ME333 Winter 2010
**********************************************************/

#include <HardwareProfile.h>
#include <delays.c> //Delayms and Delayus functions

The first section defines all the input and output pins, used with the motor, sensor, and music circuits.

////////////////////////////////////////////////////
//Pin Defines

//YMZ Chip selects
#define CS1 LATCbits.LATC2
#define CS2 LATCbits.LATC3
#define CS3 LATCbits.LATC4
#define CS4 LATGbits.LATG6
//YMZ communication pins
#define NWR LATBbits.LATB0 //"Not WRite": active low write line
#define A0 LATBbits.LATB6 //Address 0
#define NIC LATCbits.LATC1 //"Not Input Clear": active low reset line
//YMZ data pins
#define D0 LATGbits.LATG9
#define D1 LATEbits.LATE8
#define D2 LATEbits.LATE9
#define D3 LATBbits.LATB5
#define D4 LATBbits.LATB4
#define D5 LATBbits.LATB3
#define D6 LATBbits.LATB2
#define D7 LATBbits.LATB1

//Tilt inputs
#define ENC PORTDbits.RD3
#define END PORTDbits.RD2
#define ENE PORTDbits.RD1
#define ENG PORTCbits.RC14
#define ENA PORTCbits.RC13
#define ENC5 PORTDbits.RD0

//Motor outputs
#define IN1 LATBbits.LATB7
#define IN2 LATAbits.LATA9
#define EN LATAbits.LATA10

///////////////////////////////////////
//Other defines
//Motor times
#define MS(x) x*312.5
#define DRIVETIME MS(100)
#define BACKTIME MS(75)
#define WAITTIME MS(150)
//Channels
#define CHNA 1
#define CHNB 2
#define CHNC 4

//////////////////////////////////////////
//Function definitions
void write_chip(int address, int data);
void portout(int byte);
void channelSw(int chip, int chn, int *mixer, int state);
//Global variables
int mixer1, mixer2;
int motorflag = 0;
The initialization function sets up various parts of the system.
/* init() : This function runs initializations, setting up the pic and music chips */
void init() {
int pbClk = SYSTEMConfigPerformance(SYS_FREQ);

/////////////////////////////////////////////
//Setup inputs / outputs
AD1PCFG = 0xFFFF; //All digital inputs
TRISG &= 0xFDBF; //sets G9,G6 to 0 (output); all else remains the same
TRISC &= 0xFFE1; //sets C4,C3,C2,C1 to 0s (outputs); all else remains the same
TRISB &= 0xFF80; //sets B0-B6 0 (output)
TRISE &= 0xFCFF; //sets E8,9 to output
TRISB |= 0xF000; //sets B12,B13,B14,B15 to 1s (inputs); all else remains the same
TRISC |= 0x6000; //sets C14,13 to inputs
TRISD |= 0x000F; //Sets D0,D1,D2,D3 to inputs
TRISDbits.TRISD4 = 0; //Output for clock
//Motor outputs
TRISAbits.TRISA9 = 0;
TRISAbits.TRISA10 = 0;
TRISBbits.TRISB7 = 0;
//Pulse inputs
TRISAbits.TRISA14 = 1;
TRISAbits.TRISA15 = 1;
//ODC setup
ODCCbits.ODCC1 = 1; //open drain control; can only float high (when set high) or pull low

/* Initialize outputs */
//YMZs
CS1 = 1;
CS2 = 1;
CS3 = 1;
CS4 = 1;
NWR = 1;
A0 = 0;
NIC = 1;
//Motor
IN2 = 0;
IN1 = 0;
EN = 0;

Delayms(100); //wait for power supply to ramp up
NIC = 0; //resets YMZ284s
Delayms(10);
NIC = 1;

In the init() function, the pic writes all the setup data to the music chips. This includes the frequency registers, which determine the frequency of each output, the mixer, which determines which channels are on or off (1 = off), and the volume registers, which determine the volume of each channel. After the setup, the only register that is changed in normal operation is the mixer register, which merely turns channels on and off.
//////////////////////////////////////////////////
//Setup music chips
//Setup Chip 1//
CS1 = 0;
write_chip(0x00,0xC7); //a low // C4
write_chip(0x01,0x01); //a high
write_chip(0x02,0x98); //b low // D
write_chip(0x03,0x01); //b high
write_chip(0x04,0x6E); //c low
write_chip(0x05,0x01); //c high // E
write_chip(0x07,0xFF); //mixer (0 enables)
write_chip(0x08, 0x0A); //level (volume) A
write_chip(0x09, 0x0A); //level (volume) B
write_chip(0x0A, 0x0A); //level (volume) C
CS1=1;
//Setup Chip 2//
CS2 = 0;
write_chip(0x00,0x2C); //a low //G 392
write_chip(0x01,0x01); //a high
write_chip(0x02,0x0D); //b low //A 440
write_chip(0x03,0x01); //b high
write_chip(0x04,0xE3); //c low //C5 523.25
write_chip(0x05,0x00); //c high
write_chip(0x07,0xFF); //mixer (0 enables)
write_chip(0x08, 0x0A); //level (volume) A
write_chip(0x09, 0x0A); //level (volume) B
write_chip(0x0A, 0x0A); //level (volume) C
CS2=1;

mixer1=0xFF;
mixer2=0xFF;
OC5 is used to create a PWM signal with 50% duty at 4Mhz, in effect creating a 4Mhz square wave. This is used by the music chips as a master clock.
//////////////////////////////////////////////
//Setup OC to create master clock for music chips (~4 Mhz)
OpenOC5( OC_ON | OC_TIMER2_SRC | OC_PWM_FAULT_PIN_DISABLE, 0, 0);
OpenTimer2( T2_ON | T2_PS_1_1 | T2_SOURCE_INT, 20);
SetDCOC5PWM(10);
The interrupts are used, as mentioned above, to control when the motor is driven. The motor should drive once every rising edge.
/////////////////////////////////////////////
//External interrupt setups (for motor) - INT3 (A14)
mINT3ClearIntFlag();
mINT3IntEnable(1);
mINT3SetIntPriority(6);
mINT3SetEdgeMode(1); //Rising edge
/////////////////////////////////////////////
//External interrupt setups (for motor) - INT4 (A15)
mINT4ClearIntFlag();
mINT4IntEnable(1);
mINT4SetIntPriority(5);
mINT4SetEdgeMode(0); //Falling edge
INTEnableSystemMultiVectoredInt();

/////////////////////////////////////////////
//Setup motor timer (used for timing delays)
OpenTimer3(T3_ON | T3_PS_1_256 | T3_SOURCE_INT, 0xFFFF);
ConfigIntTimer3(T3_INT_OFF);
}

Main function
/* Main function */
int main()
{
init(); /* Run initialization functions */
Delayms(1);

/* Main while loop: loop indefinietly */
while (1) {
In the main while loop, the PIC checks every cycle to see if an input has changed since the last cycle. Since the "mixer" variables store the current state, if an input does not match up with its valid mixer bit then it has changed recently. In this case, the channelSw() function is called to switch on or off the music channel controlled by that bit.
//Check for state changes in music notes
if (ENC != (mixer1 & 0x01)) { channelSw(1,CHNA,&mixer1,!ENC); } //If input ENC (enable C) is not equal to the state of channel A1 (note c), change the state
if (END != (mixer1 & 0x02)) { channelSw(1,CHNB,&mixer1,!END); }
if (ENE != (mixer1 & 0x04)) { channelSw(1,CHNC,&mixer1,!ENE); }
if (ENG != (mixer2 & 0x01)) { channelSw(2,CHNA,&mixer2,!ENG); }
if (ENA != (mixer2 & 0x02)) { channelSw(2,CHNB,&mixer2,!ENA); }
if (ENC5 != (mixer2 & 0x04)) { channelSw(2,CHNC,&mixer2,!ENC5); }
During the main while loop, the motor flag variable is checked to see if the motor should be driven. If so, it enters a sequence where it uses timer3 to determine the current stage in the motor cycle, changing the outputs as needed.
//Check for motor state changes
switch (motorflag) {
case 0: break; //Do nothing (motor off)
case 1: //Start motor cycle
WriteTimer3(0); //Reset timer to 0
IN1 = 0; //Set H bridge to forward drive
IN2 = 1;
EN = 1;
motorflag = 2; //In drivedown cycle
break;
case 2: //Drivedown cycle
if (ReadTimer3() > DRIVETIME) { //Wait for DRIVETIME to pass
WriteTimer3(0); //Reset timer to 0
motorflag = 3; //In driveup phase
IN2 = 0; //Switch H bridge
IN1 = 1;
}
break;
case 3: //Driveup cycle
if (ReadTimer3() > BACKTIME) { //Wait for BACKTIME to pass
WriteTimer3(0); //Reset timer to 0
motorflag = 4; //In coast/wait phase
EN = 0; //Turn off motor
}
break;
case 4: //coast / wait cycle
if (ReadTimer3() > WAITTIME) {
motorflag = 5; //more wait
WriteTimer3(0);
}
break;
case 5: //Additional wait cycle
if (ReadTimer3() > WAITTIME) {
//Done!
motorflag = 0; //Motor off (can now be triggered again)
}
break;
//Static wait cycles
case 6:
if (ReadTimer3() > WAITTIME) {
motorflag = 7;
WriteTimer3(0);
}
break;
case 7:
if (ReadTimer3() > WAITTIME) {
WriteTimer3(0);
motorflag = 8;
}
break;
case 8:
if (ReadTimer3() > WAITTIME) {
motorflag = 0;
}
break;
}

Delayms(10);
}
return 0;
}//end main

Write chip function, which is a support function that writes data to the music chips.
/* write_chip: This writes the given byte "data" to the "address" (0 or 1)
on a YMZ284. It is assumed that the chip select is already low */
void write_chip(int address,int data) {
//Write address
portout(address);
A0 = 0; //select address mode
Delayus(1); //setup time
NWR = 0; //Write cycle begin
Delayus(1); //hold time
NWR = 1; //Write cycle end

//Write data
portout(data);
A0 = 1; //select data mode
Delayus(1); //setup time
NWR = 0; //write cycle begin
Delayus(1); //hold time
NWR = 1; //write cycle end
}
Port out function
/* port_out: This function outputs a byte to the D0-D7 port */
void portout(int byte) {
// Note: !! converts an integer expression to a boolean (1 or 0).
D0 = !!(byte & 1);
D1 = !!(byte & 2);
D2 = !!(byte & 4);
D3 = !!(byte & 8);
D4 = !!(byte & 16);
D5 = !!(byte & 32);
D6 = !!(byte & 64);
D7 = !!(byte & 128);
}
Channel switch function, which writes a new mixer value to turn a channel on or off.
/* channelSw: Generic channel switch function
This writes a new mixer value to chip "chip". The mixer value
depends on "chn", the channel turning on or off, "state" whether
the channel is turning on or off, and "*mixer", a pointer to
the old mixer value. */
void channelSw(int chip, int chn, int *mixer, int state) {
/* Enable music chip */
switch(chip) {
case 1: CS1 = 0; break;
case 2: CS2 = 0; break;
case 3: CS3 = 0; break;
case 4: CS4 = 0; break;
}
/* Write mixer value */
/* This writes to channel 7 (mixer channel) the _new_ mixer value, which is
the old mixer value with a particular bit flipped based on "chn" and "state" */
write_chip(0x07, (*mixer) = state ? (*mixer) & (0xFF & ~chn) : (*mixer) | chn);
/* Disable chip */
switch(chip) {
case 1: CS1 = 1; break;
case 2: CS2 = 1; break;
case 3: CS3 = 1; break;
case 4: CS4 = 1; break;
}

}
Interrupt functions
//External interrupt for motor driving
void __ISR(_EXTERNAL_3_VECTOR, ipl6) _SingleVectorHandler(void) {
if (motorflag == 0) {
motorflag = 1; //Start motor cycle
}
//If on already, do nothing
mINT3ClearIntFlag();
}

//External interrupt for motor waiting
void __ISR(_EXTERNAL_4_VECTOR, ipl5) _SingleVectorHandler2(void) {
if (motorflag == 0) {
WriteTimer3(0);
motorflag = 6; //Start wait cycle
}
//If on already, do nothing
mINT4ClearIntFlag();
}

=Results=

The project turned out to be a mild success overall. The tilt switches worked very well for activating the music tones, but the heart rate monitor was less successful. One of the biggest issues was getting rid of very low frequency drift in the signal that made the peaks sometimes as high as 10V, but other times less 1V. Dealing with this fluctuation in peak size was the most difficult part of signal processing. As mentioned above, we tried FFT in order to establish a steady heart rate, but could not get the resolution we desired, thus we abandoned the idea.

'''PROBABLY NEED MORE TECHNICAL RESULTS HERE, BUT I'M NOT SURE WHAT TO SAY RIGHT NOW'''

The best result was that using the device was just plain fun. We each had a great time moving around and hearing the fun sounds that resulted, or if we were feeling ambitious, we would try to play a simple melody like "Mary Had a Little Lamb." It was rather difficult to play anything more complicated than that because it required lots of body control and precise movements.

=Reflections=

'''Successes'''
*tilt switches activated each of the six notes when they were supposed to
**the YMZ284 chips were able to produce all six notes at the same time, allowing cool chords
*tones were in tune and formed fun melodies and chords as the body moved
*drum actuator hit the drum reliably and with good tone
*heart rate monitor usually showed clear peaks on a scope, but was finnicky in practice

'''Room for improvements'''
*tilt switches sometimes bounced, so the beginning, or particularly the ends of the notes sounded jagged
**''Possible Solution:'' add a low pass filter to the switch signal so that the signal ramps up and down.
*the shoulder straps sometimes needed adjustments for each individual in order for the sensors to be in the correct position
**''Possible Solution:'' create straps with more constraints, such as a strap across the chest as well as the back, to ensure that the sensors are in the correct positions and orientations.
*the straps could be easier to put on
**''Possible Solution:'' maybe integrate them into a single garment, like a onesie
*the heart rate monitor was not reliable. Low frequency drift made setting a comparison level nearly impossible, especially for more than one specific user.
**''Possible Solution:'' improve FFT method so that desired resolution could be achieved in a short sample period (around 10 seconds). Or implement a complicated peak detection algorithm on the PIC.

'''JAMES SHOULD ADD SOME KIND OF HEARTWARMING CONCLUSION CUZ HE'S GOOD AT THAT STUFF'''

Music from the Heart -- Music Suit

2010-03-17T07:02:04Z

EricWest: /* Tilt switches - Mechanical Design */

=Introduction=

This project attempted to create a natural form of musical expression by connecting sensors to the body. Six tilt switches were attached to the wrist, ankles, and shoulders, each controlling a single pitch from the [http://en.wikipedia.org/wiki/Pentatonic_scale pentatonic scale]. The heart beat was obtained using [http://en.wikipedia.org/wiki/Photoplethysmograph photoplethysmography] on the user's finger, and this signal was used to strike a drum in sync with the heart beat.

For a video demonstration, click [http://www.youtube.com/watch?v=YyipByy7m6I here].

==Team Members==

[[Image:Mfth team picture.JPG|thumb|200px|From left: Thomas, Eric, James]]
*Thomas Peterson (Computer Engineering, 2010)
*James Rein (Biomedical Engineering and Music Cognition, 2010)
*Eric West (Mechanical Engineering, 2011)

=Subsystems=

Although intended as a single, cohesive system that would allow the user to intuitively make music, the project was easily divided into three subsystems: heart rate monitor, drum actuation, and music tones. Below is more explanation about each subsystem.

==Heart rate monitor - Concepts==

In brainstorming how to translate a heart beat into a drum beat, we decided that the least intrusive method would be the best. Attaching electrodes to the user would simplify the process of identifying a heart beat, but attaching the sensors directly to the skin would be a time-consuming and personally-invasive process. Instead, we decided a finger tip sensor would be much more comfortable and easy to use.

To make a finger tip sensor, we used the concepts of [http://en.wikipedia.org/wiki/Photoplethysmograph photoplethysmography]. Photoplethysmography is typically used in [http://en.wikipedia.org/wiki/Pulse_oximeter pulse oximeters] and finger-tip sensors in commercially-available devices. We originally tried to hack a heart rate monitor that we had purchased, but this proved difficult, so we decided to make our own.

The basic concept of photoplethysmography is that blood reflects a certain amount of IR light, and the blood density in the finger changes as the heart pumps, so the IR reflectivity of the finger changes as the heart beats. Using an IR emitter-detector pair found in the mechatronics lab followed by lots of amplification and filtering, we were able to obtain a decent signal with peaks when the user's heart beat.

===Heart rate monitor - Electrical Design===

The signal coming directly out of the IR detector was very weak and noisy. To obtain just the information we desired, we ran it through the following filters and amplifiers:

# [[Passive Filters#High-Pass Filter (HPF)|Passive High-Pass Filter]]
# [[Operational Amplifiers (Op-Amps)#Inverting Amplifier|Inverting Amplifier]]: gain = -470
# [http://en.wikipedia.org/wiki/Low-pass_filter#Active_electronic_realization Active Low-pass filter]: cutoff frequency = 4.82Hz, gain = -70
# [http://www.electronics-tutorials.ws/filter/filter_7.html Band-pass filter]: Frequency range = 0.72 to 3.39Hz, inverting gain = -46.8
# [[Comparators|Comparator]]: output to the PIC pin A14, with pull-up resistor to 3.3V and capacitors to smooth out the signal.

The complete signal processing circuit is shown below.

[[Image:Heartrate monitor.PNG|thumb|center|900px|Heart rate monitor circuit diagram. Click for larger image.]]

===Heart rate monitor - Mechanical Design===

[[Image:Heart rate sensor mfth.JPG|thumb|200px|Heart rate sensor with the latex band pulled away so that the emitter-detector is revealed]]
The sensor itself was a QRB1114 emitter-detector pair that was encased in open-cell foam insulation. We inserted it into the foam by drilling and filing a hole in the foam to the appropriate size, and gluing the sensor in place. A round, finger-shaped groove was filed into the foam and the sensor sat flush with the bottom of this groove. The user's finger was held in the correct position with relatively constant pressure using a latex band around the finger and the foam enclosure.

==Drum actuator - Electrical design==

Once the signal from the heart rate sensor is sent to the PIC, the rising edge triggers an interrupt which starts the driving sequence for the motor that strikes the drum. The drive sequence was: drive down (into drum) 100ms, drive up 75ms, wait 150ms. The interrupt does not do the entire driving sequence, it merely flags a variable to start the sequence, which is done in the main loop, as seen in the code below.

An additional interrupt was triggered by the falling edge of the signal; this falling edge interrupt added additional wait time that prevented the PIC from being "fooled" by a noisy falling edge. For instance, if the falling signal had some noise in it, the rising edge interrupt would be triggered again, thus causing the drum to strike on both the rising and falling edges of the heartbeat. We only wanted one strike per heartbeat, so the falling edge interrupt was triggered by the ''first'' falling edge, and any noise in the falling edge was ignored because the PIC was told to wait for 300ms. With a maximum delay of 150 + 300 = 450ms from the two interrupts, the fastest heartbeat our drum could play was 133 beats per minute, but we did not expect anyone to come play the instrument after running, so this was plenty high for our purposes.

Initially, we tried skipping the comparator and sending the analog signal directly into one of the PICs analog inputs. Our intention was to use the fast Fourier transform (FFT) library to try to extract the dominant frequency. Unfortunately, we ran into various problems. First, to get the accuracy we wanted for small frequencies, the sample window had to be very long (10 seconds or more), which made the output lag changes in heart rate. Additionally, the FFT was often "messy", which messed up our original algorithm of detecting the peak frequency between .5 and 2.5 hz. The system would sometimes randomly switch between very different frequencies, and although it was right most of the time it was enough to make the drum beating sound bad. We also tried algorithms to find the [http://en.wikipedia.org/wiki/Fundamental_frequency fundamental frequency] using the entire FFT (instead of just the .5-2.5 hz range), but this was still unreliable. We considered FFT peak detection algorithms, but they seemed to complex for the time and computing power we had available. Because of all this, we went with the simple comparator in the end.

The motor for driving the drumstick was driven by an [[media:L298N.pdf|L298 H-bridge]]. See [[Driving a high current DC Motor using an H-bridge]] for more information on how this works. Our particular circuit diagram is shown below:

[[Image:T21_motorckt_png.PNG|thumb|center|600px|Motor Circuit (non-motor PIC connections not shown). Click for larger image.]]

====Drum actuator - Mechanical Design====

We wanted to use a real drum for our drum beat, so our challenge was to attach a motor and drumstick to a drum. We chose a small rack tom for its resonant tone that is reminiscent of a heart beat.

To attach the drumstick to the motor shaft, we used a small block of acrylic (.5"x.5"x2"). The drumstick was cut down to 8" in length so that it would require less torque from the motor. In one end of the block, a hole was drilled and the drumstick was sanded to the correct diameter in order to snuggly fit into the hole. To ensure that the drumstick could not slide out of the block, a screw was placed in a hole drilled through both the stick and the block. The other end of the block was attached to the motor shaft using a split-clamp method: A hole the size of the motor shaft was drilled through the block, and then a slit was cut from the end of the block to the hole, allowing a screw to tightly clamp the block around the motor.

'''INSERT PICTURE OF DRUMSTICK-MOTORSHAFT ATTACHMENT'''

To attach the motor-stick assembly to the drum, we utilized the tuning screws on the drum. A sheet metal bracket with holes in the appropriate places attached the motor to two of these tuning screws. The bracket was easily made by cutting and bending a piece of 16 gauge steel sheet metal to the appropriate size. Ideally, this part would have been made out of one continuous piece of sheet metal, but we could not find a large enough sheet available in the shop, so we used rivets to connect two smaller pieces together.

After testing the drum striking, we decided it was too loud. To dampen the sound, we taped a piece of foam core and a shop rag to the head of the drum where the stick strikes it.

'''Parts list for drum actuator'''
*Bargain drumstick, at least .5" in diameter
*Small block of acrylic, .5"x.5"x2" (aluminum would work just as well, this is what was available)
*16 gauge steel sheet metal for bracket
*Screws and nuts
*Foam core, shop rag, tape for dampening

==Music Tones - Electrical Design==
The music tones were activated by tilt switches and generated using a [http://pdf1.alldatasheet.com/datasheet-pdf/view/82065/YAMAHA/YMZ284.html YMZ284] chip and were output through a 1/8" jack to a standard set of computer speakers.

Each YMZ284 is capable of producing and mixing any combination of three tones. Since we wanted to have six notes from a [http://en.wikipedia.org/wiki/Pentatonic_scale pentatonic scale], we needed two of these chips and used an [[Operational Amplifiers (Op-Amps)#Summer|summing opamp circuit]] to combine outputs from each chip. We envisioned a possibility of adding [http://en.wikipedia.org/wiki/Overtone overtones] to each note, to make them sound better and more like a real instrument, so we ended up having four YMZ284s attached to our board. When we tried adding an overtone an octave above the fundamental frequency, it ended up sounding harsh and whiny. We decided the tones sounded better with no overtones, so we are only using 2 of the 4 chips on our board.

The YMZ284 communicates with the PIC over an 8-bit databus, plus additional pins for chip select, address, write enable, and reset. All four of our YMZ284s shared all of their pins ''except'' the chip select line; each required their own individual chip select line so that the PIC could specify with which chips it wanted to talk. The circuit diagram below shows how the chips were connected to the PIC and the summing circuit that followed.

[[Image:T21_musicckt_png.PNG|thumb|center|600px|Music circuit diagram. The summing amplifier is not shown. Click for larger image.]]

===Tilt switches - Electrical Design===
In order to detect when the limbs of the user had moved past a certain critical angle, we chose to use tilt switches. We purchased our tilt switches for $2 each from [http://www.goldmine-elec-products.com/prodinfo.asp?number=G16881 Electronics Goldmine]. We chose to use tilt switches instead of an accelerometer because the switches were much cheaper and we figured they would be easier to work with.

The tilt switches we chose are optically-based with an emitter and detector that are selectively blocked by a small ball. When the critical angle is achieved, the tiny ball rolls up a ramp, allowing the emitter to shine directly on the detector, and current flows. When the angle is neutral, the ramp forces the ball to block the light, making current stop flowing through the phototransistor. The "ramp" is really an inverted cone, so the switch can be activated by a change in angle in any direction away from the neutral position. We purchased three different tilt switches to try, each with a different critical angle - 15, 30, and 45 degrees. The configuration we ended up using was:

*30 degrees for shoulders and ankles
*45 degrees for elbows

In hindsight, we would have used all 45-degree switches because they produced the sharpest jump from off to on. The 15-degree switches were practically unusable because they created a large amount of noise as they switched on and off.

We used the tilt switches to provide high-low inputs to the PIC to tell it when to turn on any of the six tones. By attaching these switches to the body such that they are in the neutral position when the body is relaxed, we were able to control the six tones by moving the body in relatively natural ways.

===Tilt switches - Mechanical Design===

[[Image:Wrist sensor mfth.JPG|thumb|200px|Wrist tilt sensor. Ankles are similar, with a larger strap.]]
The switches were attached to the user's body using adjustable straps and buckles. The wrist and ankle sensors were simply a loop of webbing with an adjustable buckle attached. The straps could be tightened or loosened to fit any size user. To attach the switch to the straps, we created an enclosure for each switch out of high-density foam (left over scraps from DSGN 307). The switch was jammed into a hole in the foam so that it could not easily be moved. The foam was then taped to the straps using electrical tape.

The shoulder straps were a bit more involved. Two loops with buckles, similar to the wrist and ankle straps, went over the user's shoulder and underneath their armpit. To keep these straps from sliding off the shoulders, a large strap across the user's back connected the two smaller straps together. This large strap was also used for mounting the solder board which gathered the wires from all six tilt switches and sent them to the PIC over one ribbon cable. Using this strap configuration, we found that the user could comfortably and securely wear the sensors.

[[Image:Shoulder sensors mfth.JPG|thumb|200px|Shoulder straps containing the tilt sensors.]]
To attach the switches to the shoulders, we again created a foam encasement. However, electrical tape was not secure enough to hold the foam pieces to the irregularly-shaped shoulder straps. Instead, we riveted a piece of canvas to the webbing straps. We chose to use rivets instead of sewing because the sewing machine could not tightly sew the foam encasement in place. With rivets, we were able to pull the canvas tightly around the foam so that it couldn't move.

=Code=
To download the entire C file, click [[Media:Main_music.c|here]]. Below, the file is split into sections for comments.

/**********************************************************
* main_music.c: Main c file for "Music Suit" project
*
* Thomas Peterson, James Rein, Eric West
* ME333 Winter 2010
**********************************************************/

#include <HardwareProfile.h>
#include <delays.c> //Delayms and Delayus functions

The first section defines all the input and output pins, used with the motor, sensor, and music circuits.

////////////////////////////////////////////////////
//Pin Defines

//YMZ Chip selects
#define CS1 LATCbits.LATC2
#define CS2 LATCbits.LATC3
#define CS3 LATCbits.LATC4
#define CS4 LATGbits.LATG6
//YMZ communication pins
#define NWR LATBbits.LATB0 //"Not WRite": active low write line
#define A0 LATBbits.LATB6 //Address 0
#define NIC LATCbits.LATC1 //"Not Input Clear": active low reset line
//YMZ data pins
#define D0 LATGbits.LATG9
#define D1 LATEbits.LATE8
#define D2 LATEbits.LATE9
#define D3 LATBbits.LATB5
#define D4 LATBbits.LATB4
#define D5 LATBbits.LATB3
#define D6 LATBbits.LATB2
#define D7 LATBbits.LATB1

//Tilt inputs
#define ENC PORTDbits.RD3
#define END PORTDbits.RD2
#define ENE PORTDbits.RD1
#define ENG PORTCbits.RC14
#define ENA PORTCbits.RC13
#define ENC5 PORTDbits.RD0

//Motor outputs
#define IN1 LATBbits.LATB7
#define IN2 LATAbits.LATA9
#define EN LATAbits.LATA10

///////////////////////////////////////
//Other defines
//Motor times
#define MS(x) x*312.5
#define DRIVETIME MS(100)
#define BACKTIME MS(75)
#define WAITTIME MS(150)
//Channels
#define CHNA 1
#define CHNB 2
#define CHNC 4

//////////////////////////////////////////
//Function definitions
void write_chip(int address, int data);
void portout(int byte);
void channelSw(int chip, int chn, int *mixer, int state);
//Global variables
int mixer1, mixer2;
int motorflag = 0;
The initialization function sets up various parts of the system.
/* init() : This function runs initializations, setting up the pic and music chips */
void init() {
int pbClk = SYSTEMConfigPerformance(SYS_FREQ);

/////////////////////////////////////////////
//Setup inputs / outputs
AD1PCFG = 0xFFFF; //All digital inputs
TRISG &= 0xFDBF; //sets G9,G6 to 0 (output); all else remains the same
TRISC &= 0xFFE1; //sets C4,C3,C2,C1 to 0s (outputs); all else remains the same
TRISB &= 0xFF80; //sets B0-B6 0 (output)
TRISE &= 0xFCFF; //sets E8,9 to output
TRISB |= 0xF000; //sets B12,B13,B14,B15 to 1s (inputs); all else remains the same
TRISC |= 0x6000; //sets C14,13 to inputs
TRISD |= 0x000F; //Sets D0,D1,D2,D3 to inputs
TRISDbits.TRISD4 = 0; //Output for clock
//Motor outputs
TRISAbits.TRISA9 = 0;
TRISAbits.TRISA10 = 0;
TRISBbits.TRISB7 = 0;
//Pulse inputs
TRISAbits.TRISA14 = 1;
TRISAbits.TRISA15 = 1;
//ODC setup
ODCCbits.ODCC1 = 1; //open drain control; can only float high (when set high) or pull low

/* Initialize outputs */
//YMZs
CS1 = 1;
CS2 = 1;
CS3 = 1;
CS4 = 1;
NWR = 1;
A0 = 0;
NIC = 1;
//Motor
IN2 = 0;
IN1 = 0;
EN = 0;

Delayms(100); //wait for power supply to ramp up
NIC = 0; //resets YMZ284s
Delayms(10);
NIC = 1;

In the init() function, the pic writes all the setup data to the music chips. This includes the frequency registers, which determine the frequency of each output, the mixer, which determines which channels are on or off (1 = off), and the volume registers, which determine the volume of each channel. After the setup, the only register that is changed in normal operation is the mixer register, which merely turns channels on and off.
//////////////////////////////////////////////////
//Setup music chips
//Setup Chip 1//
CS1 = 0;
write_chip(0x00,0xC7); //a low // C4
write_chip(0x01,0x01); //a high
write_chip(0x02,0x98); //b low // D
write_chip(0x03,0x01); //b high
write_chip(0x04,0x6E); //c low
write_chip(0x05,0x01); //c high // E
write_chip(0x07,0xFF); //mixer (0 enables)
write_chip(0x08, 0x0A); //level (volume) A
write_chip(0x09, 0x0A); //level (volume) B
write_chip(0x0A, 0x0A); //level (volume) C
CS1=1;
//Setup Chip 2//
CS2 = 0;
write_chip(0x00,0x2C); //a low //G 392
write_chip(0x01,0x01); //a high
write_chip(0x02,0x0D); //b low //A 440
write_chip(0x03,0x01); //b high
write_chip(0x04,0xE3); //c low //C5 523.25
write_chip(0x05,0x00); //c high
write_chip(0x07,0xFF); //mixer (0 enables)
write_chip(0x08, 0x0A); //level (volume) A
write_chip(0x09, 0x0A); //level (volume) B
write_chip(0x0A, 0x0A); //level (volume) C
CS2=1;

mixer1=0xFF;
mixer2=0xFF;
OC5 is used to create a PWM signal with 50% duty at 4Mhz, in effect creating a 4Mhz square wave. This is used by the music chips as a master clock.
//////////////////////////////////////////////
//Setup OC to create master clock for music chips (~4 Mhz)
OpenOC5( OC_ON | OC_TIMER2_SRC | OC_PWM_FAULT_PIN_DISABLE, 0, 0);
OpenTimer2( T2_ON | T2_PS_1_1 | T2_SOURCE_INT, 20);
SetDCOC5PWM(10);
The interrupts are used, as mentioned above, to control when the motor is driven. The motor should drive once every rising edge.
/////////////////////////////////////////////
//External interrupt setups (for motor) - INT3 (A14)
mINT3ClearIntFlag();
mINT3IntEnable(1);
mINT3SetIntPriority(6);
mINT3SetEdgeMode(1); //Rising edge
/////////////////////////////////////////////
//External interrupt setups (for motor) - INT4 (A15)
mINT4ClearIntFlag();
mINT4IntEnable(1);
mINT4SetIntPriority(5);
mINT4SetEdgeMode(0); //Falling edge
INTEnableSystemMultiVectoredInt();

/////////////////////////////////////////////
//Setup motor timer (used for timing delays)
OpenTimer3(T3_ON | T3_PS_1_256 | T3_SOURCE_INT, 0xFFFF);
ConfigIntTimer3(T3_INT_OFF);
}

Main function
/* Main function */
int main()
{
init(); /* Run initialization functions */
Delayms(1);

/* Main while loop: loop indefinietly */
while (1) {
In the main while loop, the PIC checks every cycle to see if an input has changed since the last cycle. Since the "mixer" variables store the current state, if an input does not match up with its valid mixer bit then it has changed recently. In this case, the channelSw() function is called to switch on or off the music channel controlled by that bit.
//Check for state changes in music notes
if (ENC != (mixer1 & 0x01)) { channelSw(1,CHNA,&mixer1,!ENC); } //If input ENC (enable C) is not equal to the state of channel A1 (note c), change the state
if (END != (mixer1 & 0x02)) { channelSw(1,CHNB,&mixer1,!END); }
if (ENE != (mixer1 & 0x04)) { channelSw(1,CHNC,&mixer1,!ENE); }
if (ENG != (mixer2 & 0x01)) { channelSw(2,CHNA,&mixer2,!ENG); }
if (ENA != (mixer2 & 0x02)) { channelSw(2,CHNB,&mixer2,!ENA); }
if (ENC5 != (mixer2 & 0x04)) { channelSw(2,CHNC,&mixer2,!ENC5); }
During the main while loop, the motor flag variable is checked to see if the motor should be driven. If so, it enters a sequence where it uses timer3 to determine the current stage in the motor cycle, changing the outputs as needed.
//Check for motor state changes
switch (motorflag) {
case 0: break; //Do nothing (motor off)
case 1: //Start motor cycle
WriteTimer3(0); //Reset timer to 0
IN1 = 0; //Set H bridge to forward drive
IN2 = 1;
EN = 1;
motorflag = 2; //In drivedown cycle
break;
case 2: //Drivedown cycle
if (ReadTimer3() > DRIVETIME) { //Wait for DRIVETIME to pass
WriteTimer3(0); //Reset timer to 0
motorflag = 3; //In driveup phase
IN2 = 0; //Switch H bridge
IN1 = 1;
}
break;
case 3: //Driveup cycle
if (ReadTimer3() > BACKTIME) { //Wait for BACKTIME to pass
WriteTimer3(0); //Reset timer to 0
motorflag = 4; //In coast/wait phase
EN = 0; //Turn off motor
}
break;
case 4: //coast / wait cycle
if (ReadTimer3() > WAITTIME) {
motorflag = 5; //more wait
WriteTimer3(0);
}
break;
case 5: //Additional wait cycle
if (ReadTimer3() > WAITTIME) {
//Done!
motorflag = 0; //Motor off (can now be triggered again)
}
break;
//Static wait cycles
case 6:
if (ReadTimer3() > WAITTIME) {
motorflag = 7;
WriteTimer3(0);
}
break;
case 7:
if (ReadTimer3() > WAITTIME) {
WriteTimer3(0);
motorflag = 8;
}
break;
case 8:
if (ReadTimer3() > WAITTIME) {
motorflag = 0;
}
break;
}

Delayms(10);
}
return 0;
}//end main

Write chip function, which is a support function that writes data to the music chips.
/* write_chip: This writes the given byte "data" to the "address" (0 or 1)
on a YMZ284. It is assumed that the chip select is already low */
void write_chip(int address,int data) {
//Write address
portout(address);
A0 = 0; //select address mode
Delayus(1); //setup time
NWR = 0; //Write cycle begin
Delayus(1); //hold time
NWR = 1; //Write cycle end

//Write data
portout(data);
A0 = 1; //select data mode
Delayus(1); //setup time
NWR = 0; //write cycle begin
Delayus(1); //hold time
NWR = 1; //write cycle end
}
Port out function
/* port_out: This function outputs a byte to the D0-D7 port */
void portout(int byte) {
// Note: !! converts an integer expression to a boolean (1 or 0).
D0 = !!(byte & 1);
D1 = !!(byte & 2);
D2 = !!(byte & 4);
D3 = !!(byte & 8);
D4 = !!(byte & 16);
D5 = !!(byte & 32);
D6 = !!(byte & 64);
D7 = !!(byte & 128);
}
Channel switch function, which writes a new mixer value to turn a channel on or off.
/* channelSw: Generic channel switch function
This writes a new mixer value to chip "chip". The mixer value
depends on "chn", the channel turning on or off, "state" whether
the channel is turning on or off, and "*mixer", a pointer to
the old mixer value. */
void channelSw(int chip, int chn, int *mixer, int state) {
/* Enable music chip */
switch(chip) {
case 1: CS1 = 0; break;
case 2: CS2 = 0; break;
case 3: CS3 = 0; break;
case 4: CS4 = 0; break;
}
/* Write mixer value */
/* This writes to channel 7 (mixer channel) the _new_ mixer value, which is
the old mixer value with a particular bit flipped based on "chn" and "state" */
write_chip(0x07, (*mixer) = state ? (*mixer) & (0xFF & ~chn) : (*mixer) | chn);
/* Disable chip */
switch(chip) {
case 1: CS1 = 1; break;
case 2: CS2 = 1; break;
case 3: CS3 = 1; break;
case 4: CS4 = 1; break;
}

}
Interrupt functions
//External interrupt for motor driving
void __ISR(_EXTERNAL_3_VECTOR, ipl6) _SingleVectorHandler(void) {
if (motorflag == 0) {
motorflag = 1; //Start motor cycle
}
//If on already, do nothing
mINT3ClearIntFlag();
}

//External interrupt for motor waiting
void __ISR(_EXTERNAL_4_VECTOR, ipl5) _SingleVectorHandler2(void) {
if (motorflag == 0) {
WriteTimer3(0);
motorflag = 6; //Start wait cycle
}
//If on already, do nothing
mINT4ClearIntFlag();
}

=Results=

The project turned out to be a mild success overall. The tilt switches worked very well for activating the music tones, but the heart rate monitor was less successful. One of the biggest issues was getting rid of very low frequency drift in the signal that made the peaks sometimes as high as 10V, but other times less 1V. Dealing with this fluctuation in peak size was the most difficult part of signal processing. As mentioned above, we tried FFT in order to establish a steady heart rate, but could not get the resolution we desired, thus we abandoned the idea.

'''PROBABLY NEED MORE TECHNICAL RESULTS HERE, BUT I'M NOT SURE WHAT TO SAY RIGHT NOW'''

The best result was that using the device was just plain fun. We each had a great time moving around and hearing the fun sounds that resulted, or if we were feeling ambitious, we would try to play a simple melody like "Mary Had a Little Lamb." It was rather difficult to play anything more complicated than that because it required lots of body control and precise movements.

=Reflections=

'''Successes'''
*tilt switches activated each of the six notes when they were supposed to
**the YMZ284 chips were able to produce all six notes at the same time, allowing cool chords
*tones were in tune and formed fun melodies and chords as the body moved
*drum actuator hit the drum reliably and with good tone
*heart rate monitor usually showed clear peaks on a scope, but was finnicky in practice

'''Room for improvements'''
*tilt switches sometimes bounced, so the beginning, or particularly the ends of the notes sounded jagged
**''Possible Solution:'' add a low pass filter to the switch signal so that the signal ramps up and down.
*the shoulder straps sometimes needed adjustments for each individual in order for the sensors to be in the correct position
**''Possible Solution:'' create straps with more constraints, such as a strap across the chest as well as the back, to ensure that the sensors are in the correct positions and orientations.
*the straps could be easier to put on
**''Possible Solution:'' maybe integrate them into a single garment, like a onesie
*the heart rate monitor was not reliable. Low frequency drift made setting a comparison level nearly impossible, especially for more than one specific user.
**''Possible Solution:'' improve FFT method so that desired resolution could be achieved in a short sample period (around 10 seconds). Or implement a complicated peak detection algorithm on the PIC.

'''JAMES SHOULD ADD SOME KIND OF HEARTWARMING CONCLUSION CUZ HE'S GOOD AT THAT STUFF'''

File:Shoulder sensors mfth.JPG

2010-03-17T07:00:13Z

EricWest: Shoulder sensors for the Music from the Heart project. Two tilt switches are attached to the left and right shoulders.

Shoulder sensors for the Music from the Heart project. Two tilt switches are attached to the left and right shoulders.

File:Wrist sensor mfth.JPG

2010-03-17T06:56:55Z

EricWest: Wrist tilt sensor the music suit for Music from the Heart.

Wrist tilt sensor the music suit for Music from the Heart.

Music from the Heart -- Music Suit

2010-03-17T06:52:03Z

EricWest: /* Introduction */

=Introduction=

This project attempted to create a natural form of musical expression by connecting sensors to the body. Six tilt switches were attached to the wrist, ankles, and shoulders, each controlling a single pitch from the [http://en.wikipedia.org/wiki/Pentatonic_scale pentatonic scale]. The heart beat was obtained using [http://en.wikipedia.org/wiki/Photoplethysmograph photoplethysmography] on the user's finger, and this signal was used to strike a drum in sync with the heart beat.

For a video demonstration, click [http://www.youtube.com/watch?v=YyipByy7m6I here].

==Team Members==

[[Image:Mfth team picture.JPG|thumb|200px|From left: Thomas, Eric, James]]
*Thomas Peterson (Computer Engineering, 2010)
*James Rein (Biomedical Engineering and Music Cognition, 2010)
*Eric West (Mechanical Engineering, 2011)

=Subsystems=

Although intended as a single, cohesive system that would allow the user to intuitively make music, the project was easily divided into three subsystems: heart rate monitor, drum actuation, and music tones. Below is more explanation about each subsystem.

==Heart rate monitor - Concepts==

In brainstorming how to translate a heart beat into a drum beat, we decided that the least intrusive method would be the best. Attaching electrodes to the user would simplify the process of identifying a heart beat, but attaching the sensors directly to the skin would be a time-consuming and personally-invasive process. Instead, we decided a finger tip sensor would be much more comfortable and easy to use.

To make a finger tip sensor, we used the concepts of [http://en.wikipedia.org/wiki/Photoplethysmograph photoplethysmography]. Photoplethysmography is typically used in [http://en.wikipedia.org/wiki/Pulse_oximeter pulse oximeters] and finger-tip sensors in commercially-available devices. We originally tried to hack a heart rate monitor that we had purchased, but this proved difficult, so we decided to make our own.

The basic concept of photoplethysmography is that blood reflects a certain amount of IR light, and the blood density in the finger changes as the heart pumps, so the IR reflectivity of the finger changes as the heart beats. Using an IR emitter-detector pair found in the mechatronics lab followed by lots of amplification and filtering, we were able to obtain a decent signal with peaks when the user's heart beat.

===Heart rate monitor - Electrical Design===

The signal coming directly out of the IR detector was very weak and noisy. To obtain just the information we desired, we ran it through the following filters and amplifiers:

# [[Passive Filters#High-Pass Filter (HPF)|Passive High-Pass Filter]]
# [[Operational Amplifiers (Op-Amps)#Inverting Amplifier|Inverting Amplifier]]: gain = -470
# [http://en.wikipedia.org/wiki/Low-pass_filter#Active_electronic_realization Active Low-pass filter]: cutoff frequency = 4.82Hz, gain = -70
# [http://www.electronics-tutorials.ws/filter/filter_7.html Band-pass filter]: Frequency range = 0.72 to 3.39Hz, inverting gain = -46.8
# [[Comparators|Comparator]]: output to the PIC pin A14, with pull-up resistor to 3.3V and capacitors to smooth out the signal.

The complete signal processing circuit is shown below.

[[Image:Heartrate monitor.PNG|thumb|center|900px|Heart rate monitor circuit diagram. Click for larger image.]]

===Heart rate monitor - Mechanical Design===

[[Image:Heart rate sensor mfth.JPG|thumb|200px|Heart rate sensor with the latex band pulled away so that the emitter-detector is revealed]]
The sensor itself was a QRB1114 emitter-detector pair that was encased in open-cell foam insulation. We inserted it into the foam by drilling and filing a hole in the foam to the appropriate size, and gluing the sensor in place. A round, finger-shaped groove was filed into the foam and the sensor sat flush with the bottom of this groove. The user's finger was held in the correct position with relatively constant pressure using a latex band around the finger and the foam enclosure.

==Drum actuator - Electrical design==

Once the signal from the heart rate sensor is sent to the PIC, the rising edge triggers an interrupt which starts the driving sequence for the motor that strikes the drum. The drive sequence was: drive down (into drum) 100ms, drive up 75ms, wait 150ms. The interrupt does not do the entire driving sequence, it merely flags a variable to start the sequence, which is done in the main loop, as seen in the code below.

An additional interrupt was triggered by the falling edge of the signal; this falling edge interrupt added additional wait time that prevented the PIC from being "fooled" by a noisy falling edge. For instance, if the falling signal had some noise in it, the rising edge interrupt would be triggered again, thus causing the drum to strike on both the rising and falling edges of the heartbeat. We only wanted one strike per heartbeat, so the falling edge interrupt was triggered by the ''first'' falling edge, and any noise in the falling edge was ignored because the PIC was told to wait for 300ms. With a maximum delay of 150 + 300 = 450ms from the two interrupts, the fastest heartbeat our drum could play was 133 beats per minute, but we did not expect anyone to come play the instrument after running, so this was plenty high for our purposes.

Initially, we tried skipping the comparator and sending the analog signal directly into one of the PICs analog inputs. Our intention was to use the fast Fourier transform (FFT) library to try to extract the dominant frequency. Unfortunately, we ran into various problems. First, to get the accuracy we wanted for small frequencies, the sample window had to be very long (10 seconds or more), which made the output lag changes in heart rate. Additionally, the FFT was often "messy", which messed up our original algorithm of detecting the peak frequency between .5 and 2.5 hz. The system would sometimes randomly switch between very different frequencies, and although it was right most of the time it was enough to make the drum beating sound bad. We also tried algorithms to find the [http://en.wikipedia.org/wiki/Fundamental_frequency fundamental frequency] using the entire FFT (instead of just the .5-2.5 hz range), but this was still unreliable. We considered FFT peak detection algorithms, but they seemed to complex for the time and computing power we had available. Because of all this, we went with the simple comparator in the end.

The motor for driving the drumstick was driven by an [[media:L298N.pdf|L298 H-bridge]]. See [[Driving a high current DC Motor using an H-bridge]] for more information on how this works. Our particular circuit diagram is shown below:

[[Image:T21_motorckt_png.PNG|thumb|center|600px|Motor Circuit (non-motor PIC connections not shown). Click for larger image.]]

====Drum actuator - Mechanical Design====

We wanted to use a real drum for our drum beat, so our challenge was to attach a motor and drumstick to a drum. We chose a small rack tom for its resonant tone that is reminiscent of a heart beat.

To attach the drumstick to the motor shaft, we used a small block of acrylic (.5"x.5"x2"). The drumstick was cut down to 8" in length so that it would require less torque from the motor. In one end of the block, a hole was drilled and the drumstick was sanded to the correct diameter in order to snuggly fit into the hole. To ensure that the drumstick could not slide out of the block, a screw was placed in a hole drilled through both the stick and the block. The other end of the block was attached to the motor shaft using a split-clamp method: A hole the size of the motor shaft was drilled through the block, and then a slit was cut from the end of the block to the hole, allowing a screw to tightly clamp the block around the motor.

'''INSERT PICTURE OF DRUMSTICK-MOTORSHAFT ATTACHMENT'''

To attach the motor-stick assembly to the drum, we utilized the tuning screws on the drum. A sheet metal bracket with holes in the appropriate places attached the motor to two of these tuning screws. The bracket was easily made by cutting and bending a piece of 16 gauge steel sheet metal to the appropriate size. Ideally, this part would have been made out of one continuous piece of sheet metal, but we could not find a large enough sheet available in the shop, so we used rivets to connect two smaller pieces together.

After testing the drum striking, we decided it was too loud. To dampen the sound, we taped a piece of foam core and a shop rag to the head of the drum where the stick strikes it.

'''Parts list for drum actuator'''
*Bargain drumstick, at least .5" in diameter
*Small block of acrylic, .5"x.5"x2" (aluminum would work just as well, this is what was available)
*16 gauge steel sheet metal for bracket
*Screws and nuts
*Foam core, shop rag, tape for dampening

==Music Tones - Electrical Design==
The music tones were activated by tilt switches and generated using a [http://pdf1.alldatasheet.com/datasheet-pdf/view/82065/YAMAHA/YMZ284.html YMZ284] chip and were output through a 1/8" jack to a standard set of computer speakers.

Each YMZ284 is capable of producing and mixing any combination of three tones. Since we wanted to have six notes from a [http://en.wikipedia.org/wiki/Pentatonic_scale pentatonic scale], we needed two of these chips and used an [[Operational Amplifiers (Op-Amps)#Summer|summing opamp circuit]] to combine outputs from each chip. We envisioned a possibility of adding [http://en.wikipedia.org/wiki/Overtone overtones] to each note, to make them sound better and more like a real instrument, so we ended up having four YMZ284s attached to our board. When we tried adding an overtone an octave above the fundamental frequency, it ended up sounding harsh and whiny. We decided the tones sounded better with no overtones, so we are only using 2 of the 4 chips on our board.

The YMZ284 communicates with the PIC over an 8-bit databus, plus additional pins for chip select, address, write enable, and reset. All four of our YMZ284s shared all of their pins ''except'' the chip select line; each required their own individual chip select line so that the PIC could specify with which chips it wanted to talk. The circuit diagram below shows how the chips were connected to the PIC and the summing circuit that followed.

[[Image:T21_musicckt_png.PNG|thumb|center|600px|Music circuit diagram. The summing amplifier is not shown. Click for larger image.]]

===Tilt switches - Electrical Design===
In order to detect when the limbs of the user had moved past a certain critical angle, we chose to use tilt switches. We purchased our tilt switches for $2 each from [http://www.goldmine-elec-products.com/prodinfo.asp?number=G16881 Electronics Goldmine]. We chose to use tilt switches instead of an accelerometer because the switches were much cheaper and we figured they would be easier to work with.

The tilt switches we chose are optically-based with an emitter and detector that are selectively blocked by a small ball. When the critical angle is achieved, the tiny ball rolls up a ramp, allowing the emitter to shine directly on the detector, and current flows. When the angle is neutral, the ramp forces the ball to block the light, making current stop flowing through the phototransistor. The "ramp" is really an inverted cone, so the switch can be activated by a change in angle in any direction away from the neutral position. We purchased three different tilt switches to try, each with a different critical angle - 15, 30, and 45 degrees. The configuration we ended up using was:

*30 degrees for shoulders and ankles
*45 degrees for elbows

In hindsight, we would have used all 45-degree switches because they produced the sharpest jump from off to on. The 15-degree switches were practically unusable because they created a large amount of noise as they switched on and off.

We used the tilt switches to provide high-low inputs to the PIC to tell it when to turn on any of the six tones. By attaching these switches to the body such that they are in the neutral position when the body is relaxed, we were able to control the six tones by moving the body in relatively natural ways.

===Tilt switches - Mechanical Design===
The switches were attached to the user's body using adjustable straps and buckles. The wrist and ankle sensors were simply a loop of webbing with an adjustable buckle attached. The straps could be tightened or loosened to fit any size user. To attach the switch to the straps, we created an enclosure for each switch out of high-density foam (left over scraps from DSGN 307). The switch was jammed into a hole in the foam so that it could not easily be moved. The foam was then taped to the straps using electrical tape.

'''INSERT PICTURE OF THE WRIST AND ANKLE STRAPS'''

The shoulder straps were a bit more involved. Two loops with buckles, similar to the wrist and ankle straps, went over the user's shoulder and underneath their armpit. To keep these straps from sliding off the shoulders, a large strap across the user's back connected the two smaller straps together. This large strap was also used for mounting the solder board which gathered the wires from all six tilt switches and sent them to the PIC over one ribbon cable. Using this strap configuration, we found that the user could comfortably and securely wear the sensors.

To attach the switches to the shoulders, we again created a foam encasement. However, electrical tape was not secure enough to hold the foam pieces to the irregularly-shaped shoulder straps. Instead, we riveted a piece of canvas to the webbing straps. We chose to use rivets instead of sewing because the sewing machine could not tightly sew the foam encasement in place. With rivets, we were able to pull the canvas tightly around the foam so that it couldn't move.

'''INSERT PICTURE OF THE SHOULDER STRAPS'''

=Code=
To download the entire C file, click [[Media:Main_music.c|here]]. Below, the file is split into sections for comments.

/**********************************************************
* main_music.c: Main c file for "Music Suit" project
*
* Thomas Peterson, James Rein, Eric West
* ME333 Winter 2010
**********************************************************/

#include <HardwareProfile.h>
#include <delays.c> //Delayms and Delayus functions

The first section defines all the input and output pins, used with the motor, sensor, and music circuits.

////////////////////////////////////////////////////
//Pin Defines

//YMZ Chip selects
#define CS1 LATCbits.LATC2
#define CS2 LATCbits.LATC3
#define CS3 LATCbits.LATC4
#define CS4 LATGbits.LATG6
//YMZ communication pins
#define NWR LATBbits.LATB0 //"Not WRite": active low write line
#define A0 LATBbits.LATB6 //Address 0
#define NIC LATCbits.LATC1 //"Not Input Clear": active low reset line
//YMZ data pins
#define D0 LATGbits.LATG9
#define D1 LATEbits.LATE8
#define D2 LATEbits.LATE9
#define D3 LATBbits.LATB5
#define D4 LATBbits.LATB4
#define D5 LATBbits.LATB3
#define D6 LATBbits.LATB2
#define D7 LATBbits.LATB1

//Tilt inputs
#define ENC PORTDbits.RD3
#define END PORTDbits.RD2
#define ENE PORTDbits.RD1
#define ENG PORTCbits.RC14
#define ENA PORTCbits.RC13
#define ENC5 PORTDbits.RD0

//Motor outputs
#define IN1 LATBbits.LATB7
#define IN2 LATAbits.LATA9
#define EN LATAbits.LATA10

///////////////////////////////////////
//Other defines
//Motor times
#define MS(x) x*312.5
#define DRIVETIME MS(100)
#define BACKTIME MS(75)
#define WAITTIME MS(150)
//Channels
#define CHNA 1
#define CHNB 2
#define CHNC 4

//////////////////////////////////////////
//Function definitions
void write_chip(int address, int data);
void portout(int byte);
void channelSw(int chip, int chn, int *mixer, int state);
//Global variables
int mixer1, mixer2;
int motorflag = 0;
The initialization function sets up various parts of the system.
/* init() : This function runs initializations, setting up the pic and music chips */
void init() {
int pbClk = SYSTEMConfigPerformance(SYS_FREQ);

/////////////////////////////////////////////
//Setup inputs / outputs
AD1PCFG = 0xFFFF; //All digital inputs
TRISG &= 0xFDBF; //sets G9,G6 to 0 (output); all else remains the same
TRISC &= 0xFFE1; //sets C4,C3,C2,C1 to 0s (outputs); all else remains the same
TRISB &= 0xFF80; //sets B0-B6 0 (output)
TRISE &= 0xFCFF; //sets E8,9 to output
TRISB |= 0xF000; //sets B12,B13,B14,B15 to 1s (inputs); all else remains the same
TRISC |= 0x6000; //sets C14,13 to inputs
TRISD |= 0x000F; //Sets D0,D1,D2,D3 to inputs
TRISDbits.TRISD4 = 0; //Output for clock
//Motor outputs
TRISAbits.TRISA9 = 0;
TRISAbits.TRISA10 = 0;
TRISBbits.TRISB7 = 0;
//Pulse inputs
TRISAbits.TRISA14 = 1;
TRISAbits.TRISA15 = 1;
//ODC setup
ODCCbits.ODCC1 = 1; //open drain control; can only float high (when set high) or pull low

/* Initialize outputs */
//YMZs
CS1 = 1;
CS2 = 1;
CS3 = 1;
CS4 = 1;
NWR = 1;
A0 = 0;
NIC = 1;
//Motor
IN2 = 0;
IN1 = 0;
EN = 0;

Delayms(100); //wait for power supply to ramp up
NIC = 0; //resets YMZ284s
Delayms(10);
NIC = 1;

In the init() function, the pic writes all the setup data to the music chips. This includes the frequency registers, which determine the frequency of each output, the mixer, which determines which channels are on or off (1 = off), and the volume registers, which determine the volume of each channel. After the setup, the only register that is changed in normal operation is the mixer register, which merely turns channels on and off.
//////////////////////////////////////////////////
//Setup music chips
//Setup Chip 1//
CS1 = 0;
write_chip(0x00,0xC7); //a low // C4
write_chip(0x01,0x01); //a high
write_chip(0x02,0x98); //b low // D
write_chip(0x03,0x01); //b high
write_chip(0x04,0x6E); //c low
write_chip(0x05,0x01); //c high // E
write_chip(0x07,0xFF); //mixer (0 enables)
write_chip(0x08, 0x0A); //level (volume) A
write_chip(0x09, 0x0A); //level (volume) B
write_chip(0x0A, 0x0A); //level (volume) C
CS1=1;
//Setup Chip 2//
CS2 = 0;
write_chip(0x00,0x2C); //a low //G 392
write_chip(0x01,0x01); //a high
write_chip(0x02,0x0D); //b low //A 440
write_chip(0x03,0x01); //b high
write_chip(0x04,0xE3); //c low //C5 523.25
write_chip(0x05,0x00); //c high
write_chip(0x07,0xFF); //mixer (0 enables)
write_chip(0x08, 0x0A); //level (volume) A
write_chip(0x09, 0x0A); //level (volume) B
write_chip(0x0A, 0x0A); //level (volume) C
CS2=1;

mixer1=0xFF;
mixer2=0xFF;
OC5 is used to create a PWM signal with 50% duty at 4Mhz, in effect creating a 4Mhz square wave. This is used by the music chips as a master clock.
//////////////////////////////////////////////
//Setup OC to create master clock for music chips (~4 Mhz)
OpenOC5( OC_ON | OC_TIMER2_SRC | OC_PWM_FAULT_PIN_DISABLE, 0, 0);
OpenTimer2( T2_ON | T2_PS_1_1 | T2_SOURCE_INT, 20);
SetDCOC5PWM(10);
The interrupts are used, as mentioned above, to control when the motor is driven. The motor should drive once every rising edge.
/////////////////////////////////////////////
//External interrupt setups (for motor) - INT3 (A14)
mINT3ClearIntFlag();
mINT3IntEnable(1);
mINT3SetIntPriority(6);
mINT3SetEdgeMode(1); //Rising edge
/////////////////////////////////////////////
//External interrupt setups (for motor) - INT4 (A15)
mINT4ClearIntFlag();
mINT4IntEnable(1);
mINT4SetIntPriority(5);
mINT4SetEdgeMode(0); //Falling edge
INTEnableSystemMultiVectoredInt();

/////////////////////////////////////////////
//Setup motor timer (used for timing delays)
OpenTimer3(T3_ON | T3_PS_1_256 | T3_SOURCE_INT, 0xFFFF);
ConfigIntTimer3(T3_INT_OFF);
}

Main function
/* Main function */
int main()
{
init(); /* Run initialization functions */
Delayms(1);

/* Main while loop: loop indefinietly */
while (1) {
In the main while loop, the PIC checks every cycle to see if an input has changed since the last cycle. Since the "mixer" variables store the current state, if an input does not match up with its valid mixer bit then it has changed recently. In this case, the channelSw() function is called to switch on or off the music channel controlled by that bit.
//Check for state changes in music notes
if (ENC != (mixer1 & 0x01)) { channelSw(1,CHNA,&mixer1,!ENC); } //If input ENC (enable C) is not equal to the state of channel A1 (note c), change the state
if (END != (mixer1 & 0x02)) { channelSw(1,CHNB,&mixer1,!END); }
if (ENE != (mixer1 & 0x04)) { channelSw(1,CHNC,&mixer1,!ENE); }
if (ENG != (mixer2 & 0x01)) { channelSw(2,CHNA,&mixer2,!ENG); }
if (ENA != (mixer2 & 0x02)) { channelSw(2,CHNB,&mixer2,!ENA); }
if (ENC5 != (mixer2 & 0x04)) { channelSw(2,CHNC,&mixer2,!ENC5); }
During the main while loop, the motor flag variable is checked to see if the motor should be driven. If so, it enters a sequence where it uses timer3 to determine the current stage in the motor cycle, changing the outputs as needed.
//Check for motor state changes
switch (motorflag) {
case 0: break; //Do nothing (motor off)
case 1: //Start motor cycle
WriteTimer3(0); //Reset timer to 0
IN1 = 0; //Set H bridge to forward drive
IN2 = 1;
EN = 1;
motorflag = 2; //In drivedown cycle
break;
case 2: //Drivedown cycle
if (ReadTimer3() > DRIVETIME) { //Wait for DRIVETIME to pass
WriteTimer3(0); //Reset timer to 0
motorflag = 3; //In driveup phase
IN2 = 0; //Switch H bridge
IN1 = 1;
}
break;
case 3: //Driveup cycle
if (ReadTimer3() > BACKTIME) { //Wait for BACKTIME to pass
WriteTimer3(0); //Reset timer to 0
motorflag = 4; //In coast/wait phase
EN = 0; //Turn off motor
}
break;
case 4: //coast / wait cycle
if (ReadTimer3() > WAITTIME) {
motorflag = 5; //more wait
WriteTimer3(0);
}
break;
case 5: //Additional wait cycle
if (ReadTimer3() > WAITTIME) {
//Done!
motorflag = 0; //Motor off (can now be triggered again)
}
break;
//Static wait cycles
case 6:
if (ReadTimer3() > WAITTIME) {
motorflag = 7;
WriteTimer3(0);
}
break;
case 7:
if (ReadTimer3() > WAITTIME) {
WriteTimer3(0);
motorflag = 8;
}
break;
case 8:
if (ReadTimer3() > WAITTIME) {
motorflag = 0;
}
break;
}

Delayms(10);
}
return 0;
}//end main

Write chip function, which is a support function that writes data to the music chips.
/* write_chip: This writes the given byte "data" to the "address" (0 or 1)
on a YMZ284. It is assumed that the chip select is already low */
void write_chip(int address,int data) {
//Write address
portout(address);
A0 = 0; //select address mode
Delayus(1); //setup time
NWR = 0; //Write cycle begin
Delayus(1); //hold time
NWR = 1; //Write cycle end

//Write data
portout(data);
A0 = 1; //select data mode
Delayus(1); //setup time
NWR = 0; //write cycle begin
Delayus(1); //hold time
NWR = 1; //write cycle end
}
Port out function
/* port_out: This function outputs a byte to the D0-D7 port */
void portout(int byte) {
// Note: !! converts an integer expression to a boolean (1 or 0).
D0 = !!(byte & 1);
D1 = !!(byte & 2);
D2 = !!(byte & 4);
D3 = !!(byte & 8);
D4 = !!(byte & 16);
D5 = !!(byte & 32);
D6 = !!(byte & 64);
D7 = !!(byte & 128);
}
Channel switch function, which writes a new mixer value to turn a channel on or off.
/* channelSw: Generic channel switch function
This writes a new mixer value to chip "chip". The mixer value
depends on "chn", the channel turning on or off, "state" whether
the channel is turning on or off, and "*mixer", a pointer to
the old mixer value. */
void channelSw(int chip, int chn, int *mixer, int state) {
/* Enable music chip */
switch(chip) {
case 1: CS1 = 0; break;
case 2: CS2 = 0; break;
case 3: CS3 = 0; break;
case 4: CS4 = 0; break;
}
/* Write mixer value */
/* This writes to channel 7 (mixer channel) the _new_ mixer value, which is
the old mixer value with a particular bit flipped based on "chn" and "state" */
write_chip(0x07, (*mixer) = state ? (*mixer) & (0xFF & ~chn) : (*mixer) | chn);
/* Disable chip */
switch(chip) {
case 1: CS1 = 1; break;
case 2: CS2 = 1; break;
case 3: CS3 = 1; break;
case 4: CS4 = 1; break;
}

}
Interrupt functions
//External interrupt for motor driving
void __ISR(_EXTERNAL_3_VECTOR, ipl6) _SingleVectorHandler(void) {
if (motorflag == 0) {
motorflag = 1; //Start motor cycle
}
//If on already, do nothing
mINT3ClearIntFlag();
}

//External interrupt for motor waiting
void __ISR(_EXTERNAL_4_VECTOR, ipl5) _SingleVectorHandler2(void) {
if (motorflag == 0) {
WriteTimer3(0);
motorflag = 6; //Start wait cycle
}
//If on already, do nothing
mINT4ClearIntFlag();
}

=Results=

The project turned out to be a mild success overall. The tilt switches worked very well for activating the music tones, but the heart rate monitor was less successful. One of the biggest issues was getting rid of very low frequency drift in the signal that made the peaks sometimes as high as 10V, but other times less 1V. Dealing with this fluctuation in peak size was the most difficult part of signal processing. As mentioned above, we tried FFT in order to establish a steady heart rate, but could not get the resolution we desired, thus we abandoned the idea.

'''PROBABLY NEED MORE TECHNICAL RESULTS HERE, BUT I'M NOT SURE WHAT TO SAY RIGHT NOW'''

The best result was that using the device was just plain fun. We each had a great time moving around and hearing the fun sounds that resulted, or if we were feeling ambitious, we would try to play a simple melody like "Mary Had a Little Lamb." It was rather difficult to play anything more complicated than that because it required lots of body control and precise movements.

=Reflections=

'''Successes'''
*tilt switches activated each of the six notes when they were supposed to
**the YMZ284 chips were able to produce all six notes at the same time, allowing cool chords
*tones were in tune and formed fun melodies and chords as the body moved
*drum actuator hit the drum reliably and with good tone
*heart rate monitor usually showed clear peaks on a scope, but was finnicky in practice

'''Room for improvements'''
*tilt switches sometimes bounced, so the beginning, or particularly the ends of the notes sounded jagged
**''Possible Solution:'' add a low pass filter to the switch signal so that the signal ramps up and down.
*the shoulder straps sometimes needed adjustments for each individual in order for the sensors to be in the correct position
**''Possible Solution:'' create straps with more constraints, such as a strap across the chest as well as the back, to ensure that the sensors are in the correct positions and orientations.
*the straps could be easier to put on
**''Possible Solution:'' maybe integrate them into a single garment, like a onesie
*the heart rate monitor was not reliable. Low frequency drift made setting a comparison level nearly impossible, especially for more than one specific user.
**''Possible Solution:'' improve FFT method so that desired resolution could be achieved in a short sample period (around 10 seconds). Or implement a complicated peak detection algorithm on the PIC.

'''JAMES SHOULD ADD SOME KIND OF HEARTWARMING CONCLUSION CUZ HE'S GOOD AT THAT STUFF'''

Music from the Heart -- Music Suit

2010-03-17T06:15:17Z

EricWest:

=Introduction=

This project attempted to create a natural form of musical expression by connecting sensors to the body. Six tilt switches were attached to the wrist, ankles, and shoulders, each controlling a single pitch from the [http://en.wikipedia.org/wiki/Pentatonic_scale pentatonic scale]. The heart beat was obtained using [http://en.wikipedia.org/wiki/Photoplethysmograph photoplethysmography] on the user's finger, and this signal was used to strike a drum in sync with the heart beat.

==Team Members==

[[Image:Mfth team picture.JPG|thumb|200px|From left: Thomas, Eric, James]]
*Thomas Peterson (Computer Engineering, 2010)
*James Rein (Biomedical Engineering and Music Cognition, 2010)
*Eric West (Mechanical Engineering, 2011)

=Subsystems=

Although intended as a single, cohesive system that would allow the user to intuitively make music, the project was easily divided into three subsystems: heart rate monitor, drum actuation, and music tones. Below is more explanation about each subsystem.

==Heart rate monitor - Concepts==

In brainstorming how to translate a heart beat into a drum beat, we decided that the least intrusive method would be the best. Attaching electrodes to the user would simplify the process of identifying a heart beat, but attaching the sensors directly to the skin would be a time-consuming and personally-invasive process. Instead, we decided a finger tip sensor would be much more comfortable and easy to use.

To make a finger tip sensor, we used the concepts of [http://en.wikipedia.org/wiki/Photoplethysmograph photoplethysmography]. Photoplethysmography is typically used in [http://en.wikipedia.org/wiki/Pulse_oximeter pulse oximeters] and finger-tip sensors in commercially-available devices. We originally tried to hack a heart rate monitor that we had purchased, but this proved difficult, so we decided to make our own.

The basic concept of photoplethysmography is that blood reflects a certain amount of IR light, and the blood density in the finger changes as the heart pumps, so the IR reflectivity of the finger changes as the heart beats. Using an IR emitter-detector pair found in the mechatronics lab followed by lots of amplification and filtering, we were able to obtain a decent signal with peaks when the user's heart beat.

===Heart rate monitor - Electrical Design===

The signal coming directly out of the IR detector was very weak and noisy. To obtain just the information we desired, we ran it through the following filters and amplifiers:

# [[Passive Filters#High-Pass Filter (HPF)|Passive High-Pass Filter]]
# [[Operational Amplifiers (Op-Amps)#Inverting Amplifier|Inverting Amplifier]]: gain = -470
# [http://en.wikipedia.org/wiki/Low-pass_filter#Active_electronic_realization Active Low-pass filter]: cutoff frequency = 4.82Hz, gain = -70
# [http://www.electronics-tutorials.ws/filter/filter_7.html Band-pass filter]: Frequency range = 0.72 to 3.39Hz, inverting gain = -46.8
# [[Comparators|Comparator]]: output to the PIC pin A14, with pull-up resistor to 3.3V and capacitors to smooth out the signal.

The complete signal processing circuit is shown below.

[[Image:Heartrate monitor.PNG|thumb|center|900px|Heart rate monitor circuit diagram. Click for larger image.]]

===Heart rate monitor - Mechanical Design===

[[Image:Heart rate sensor mfth.JPG|thumb|200px|Heart rate sensor with the latex band pulled away so that the emitter-detector is revealed]]
The sensor itself was a QRB1114 emitter-detector pair that was encased in open-cell foam insulation. We inserted it into the foam by drilling and filing a hole in the foam to the appropriate size, and gluing the sensor in place. A round, finger-shaped groove was filed into the foam and the sensor sat flush with the bottom of this groove. The user's finger was held in the correct position with relatively constant pressure using a latex band around the finger and the foam enclosure.

==Drum actuator - Electrical design==

Once the signal from the heart rate sensor is sent to the PIC, the rising edge triggers an interrupt which starts the driving sequence for the motor that strikes the drum. The drive sequence was: drive down (into drum) 100ms, drive up 75ms, wait 150ms. The interrupt does not do the entire driving sequence, it merely flags a variable to start the sequence, which is done in the main loop, as seen in the code below.

An additional interrupt was triggered by the falling edge of the signal; this falling edge interrupt added additional wait time that prevented the PIC from being "fooled" by a noisy falling edge. For instance, if the falling signal had some noise in it, the rising edge interrupt would be triggered again, thus causing the drum to strike on both the rising and falling edges of the heartbeat. We only wanted one strike per heartbeat, so the falling edge interrupt was triggered by the ''first'' falling edge, and any noise in the falling edge was ignored because the PIC was told to wait for 300ms. With a maximum delay of 150 + 300 = 450ms from the two interrupts, the fastest heartbeat our drum could play was 133 beats per minute, but we did not expect anyone to come play the instrument after running, so this was plenty high for our purposes.

Initially, we tried skipping the comparator and sending the analog signal directly into one of the PICs analog inputs. Our intention was to use the fast Fourier transform (FFT) library to try to extract the dominant frequency. Unfortunately, we ran into various problems. First, to get the accuracy we wanted for small frequencies, the sample window had to be very long (10 seconds or more), which made the output lag changes in heart rate. Additionally, the FFT was often "messy", which messed up our original algorithm of detecting the peak frequency between .5 and 2.5 hz. The system would sometimes randomly switch between very different frequencies, and although it was right most of the time it was enough to make the drum beating sound bad. We also tried algorithms to find the [http://en.wikipedia.org/wiki/Fundamental_frequency fundamental frequency] using the entire FFT (instead of just the .5-2.5 hz range), but this was still unreliable. We considered FFT peak detection algorithms, but they seemed to complex for the time and computing power we had available. Because of all this, we went with the simple comparator in the end.

The motor for driving the drumstick was driven by an [[media:L298N.pdf|L298 H-bridge]]. See [[Driving a high current DC Motor using an H-bridge]] for more information on how this works. Our particular circuit diagram is shown below:

[[Image:T21_motorckt_png.PNG|thumb|center|600px|Motor Circuit (non-motor PIC connections not shown). Click for larger image.]]

====Drum actuator - Mechanical Design====

We wanted to use a real drum for our drum beat, so our challenge was to attach a motor and drumstick to a drum. We chose a small rack tom for its resonant tone that is reminiscent of a heart beat.

To attach the drumstick to the motor shaft, we used a small block of acrylic (.5"x.5"x2"). The drumstick was cut down to 8" in length so that it would require less torque from the motor. In one end of the block, a hole was drilled and the drumstick was sanded to the correct diameter in order to snuggly fit into the hole. To ensure that the drumstick could not slide out of the block, a screw was placed in a hole drilled through both the stick and the block. The other end of the block was attached to the motor shaft using a split-clamp method: A hole the size of the motor shaft was drilled through the block, and then a slit was cut from the end of the block to the hole, allowing a screw to tightly clamp the block around the motor.

'''INSERT PICTURE OF DRUMSTICK-MOTORSHAFT ATTACHMENT'''

To attach the motor-stick assembly to the drum, we utilized the tuning screws on the drum. A sheet metal bracket with holes in the appropriate places attached the motor to two of these tuning screws. The bracket was easily made by cutting and bending a piece of 16 gauge steel sheet metal to the appropriate size. Ideally, this part would have been made out of one continuous piece of sheet metal, but we could not find a large enough sheet available in the shop, so we used rivets to connect two smaller pieces together.

After testing the drum striking, we decided it was too loud. To dampen the sound, we taped a piece of foam core and a shop rag to the head of the drum where the stick strikes it.

'''Parts list for drum actuator'''
*Bargain drumstick, at least .5" in diameter
*Small block of acrylic, .5"x.5"x2" (aluminum would work just as well, this is what was available)
*16 gauge steel sheet metal for bracket
*Screws and nuts
*Foam core, shop rag, tape for dampening

==Music Tones - Electrical Design==
The music tones were activated by tilt switches and generated using a [http://pdf1.alldatasheet.com/datasheet-pdf/view/82065/YAMAHA/YMZ284.html YMZ284] chip and were output through a 1/8" jack to a standard set of computer speakers.

Each YMZ284 is capable of producing and mixing any combination of three tones. Since we wanted to have six notes from a [http://en.wikipedia.org/wiki/Pentatonic_scale pentatonic scale], we needed two of these chips and used an [[Operational Amplifiers (Op-Amps)#Summer|summing opamp circuit]] to combine outputs from each chip. We envisioned a possibility of adding [http://en.wikipedia.org/wiki/Overtone overtones] to each note, to make them sound better and more like a real instrument, so we ended up having four YMZ284s attached to our board. When we tried adding an overtone an octave above the fundamental frequency, it ended up sounding harsh and whiny. We decided the tones sounded better with no overtones, so we are only using 2 of the 4 chips on our board.

The YMZ284 communicates with the PIC over an 8-bit databus, plus additional pins for chip select, address, write enable, and reset. All four of our YMZ284s shared all of their pins ''except'' the chip select line; each required their own individual chip select line so that the PIC could specify with which chips it wanted to talk. The circuit diagram below shows how the chips were connected to the PIC and the summing circuit that followed.

[[Image:T21_musicckt_png.PNG|thumb|center|600px|Music circuit diagram. The summing amplifier is not shown. Click for larger image.]]

===Tilt switches - Electrical Design===
In order to detect when the limbs of the user had moved past a certain critical angle, we chose to use tilt switches. We purchased our tilt switches for $2 each from [http://www.goldmine-elec-products.com/prodinfo.asp?number=G16881 Electronics Goldmine]. We chose to use tilt switches instead of an accelerometer because the switches were much cheaper and we figured they would be easier to work with.

The tilt switches we chose are optically-based with an emitter and detector that are selectively blocked by a small ball. When the critical angle is achieved, the tiny ball rolls up a ramp, allowing the emitter to shine directly on the detector, and current flows. When the angle is neutral, the ramp forces the ball to block the light, making current stop flowing through the phototransistor. The "ramp" is really an inverted cone, so the switch can be activated by a change in angle in any direction away from the neutral position. We purchased three different tilt switches to try, each with a different critical angle - 15, 30, and 45 degrees. The configuration we ended up using was:

*30 degrees for shoulders and ankles
*45 degrees for elbows

In hindsight, we would have used all 45-degree switches because they produced the sharpest jump from off to on. The 15-degree switches were practically unusable because they created a large amount of noise as they switched on and off.

We used the tilt switches to provide high-low inputs to the PIC to tell it when to turn on any of the six tones. By attaching these switches to the body such that they are in the neutral position when the body is relaxed, we were able to control the six tones by moving the body in relatively natural ways.

===Tilt switches - Mechanical Design===
The switches were attached to the user's body using adjustable straps and buckles. The wrist and ankle sensors were simply a loop of webbing with an adjustable buckle attached. The straps could be tightened or loosened to fit any size user. To attach the switch to the straps, we created an enclosure for each switch out of high-density foam (left over scraps from DSGN 307). The switch was jammed into a hole in the foam so that it could not easily be moved. The foam was then taped to the straps using electrical tape.

'''INSERT PICTURE OF THE WRIST AND ANKLE STRAPS'''

The shoulder straps were a bit more involved. Two loops with buckles, similar to the wrist and ankle straps, went over the user's shoulder and underneath their armpit. To keep these straps from sliding off the shoulders, a large strap across the user's back connected the two smaller straps together. This large strap was also used for mounting the solder board which gathered the wires from all six tilt switches and sent them to the PIC over one ribbon cable. Using this strap configuration, we found that the user could comfortably and securely wear the sensors.

To attach the switches to the shoulders, we again created a foam encasement. However, electrical tape was not secure enough to hold the foam pieces to the irregularly-shaped shoulder straps. Instead, we riveted a piece of canvas to the webbing straps. We chose to use rivets instead of sewing because the sewing machine could not tightly sew the foam encasement in place. With rivets, we were able to pull the canvas tightly around the foam so that it couldn't move.

'''INSERT PICTURE OF THE SHOULDER STRAPS'''

=Code=
To download the entire C file, click [[Media:Main_music.c|here]]. Below, the file is split into sections for comments.

/**********************************************************
* main_music.c: Main c file for "Music Suit" project
*
* Thomas Peterson, James Rein, Eric West
* ME333 Winter 2010
**********************************************************/

#include <HardwareProfile.h>
#include <delays.c> //Delayms and Delayus functions

The first section defines all the input and output pins, used with the motor, sensor, and music circuits.

////////////////////////////////////////////////////
//Pin Defines

//YMZ Chip selects
#define CS1 LATCbits.LATC2
#define CS2 LATCbits.LATC3
#define CS3 LATCbits.LATC4
#define CS4 LATGbits.LATG6
//YMZ communication pins
#define NWR LATBbits.LATB0 //"Not WRite": active low write line
#define A0 LATBbits.LATB6 //Address 0
#define NIC LATCbits.LATC1 //"Not Input Clear": active low reset line
//YMZ data pins
#define D0 LATGbits.LATG9
#define D1 LATEbits.LATE8
#define D2 LATEbits.LATE9
#define D3 LATBbits.LATB5
#define D4 LATBbits.LATB4
#define D5 LATBbits.LATB3
#define D6 LATBbits.LATB2
#define D7 LATBbits.LATB1

//Tilt inputs
#define ENC PORTDbits.RD3
#define END PORTDbits.RD2
#define ENE PORTDbits.RD1
#define ENG PORTCbits.RC14
#define ENA PORTCbits.RC13
#define ENC5 PORTDbits.RD0

//Motor outputs
#define IN1 LATBbits.LATB7
#define IN2 LATAbits.LATA9
#define EN LATAbits.LATA10

///////////////////////////////////////
//Other defines
//Motor times
#define MS(x) x*312.5
#define DRIVETIME MS(100)
#define BACKTIME MS(75)
#define WAITTIME MS(150)
//Channels
#define CHNA 1
#define CHNB 2
#define CHNC 4

//////////////////////////////////////////
//Function definitions
void write_chip(int address, int data);
void portout(int byte);
void channelSw(int chip, int chn, int *mixer, int state);
//Global variables
int mixer1, mixer2;
int motorflag = 0;
The initialization function sets up various parts of the system.
/* init() : This function runs initializations, setting up the pic and music chips */
void init() {
int pbClk = SYSTEMConfigPerformance(SYS_FREQ);

/////////////////////////////////////////////
//Setup inputs / outputs
AD1PCFG = 0xFFFF; //All digital inputs
TRISG &= 0xFDBF; //sets G9,G6 to 0 (output); all else remains the same
TRISC &= 0xFFE1; //sets C4,C3,C2,C1 to 0s (outputs); all else remains the same
TRISB &= 0xFF80; //sets B0-B6 0 (output)
TRISE &= 0xFCFF; //sets E8,9 to output
TRISB |= 0xF000; //sets B12,B13,B14,B15 to 1s (inputs); all else remains the same
TRISC |= 0x6000; //sets C14,13 to inputs
TRISD |= 0x000F; //Sets D0,D1,D2,D3 to inputs
TRISDbits.TRISD4 = 0; //Output for clock
//Motor outputs
TRISAbits.TRISA9 = 0;
TRISAbits.TRISA10 = 0;
TRISBbits.TRISB7 = 0;
//Pulse inputs
TRISAbits.TRISA14 = 1;
TRISAbits.TRISA15 = 1;
//ODC setup
ODCCbits.ODCC1 = 1; //open drain control; can only float high (when set high) or pull low

/* Initialize outputs */
//YMZs
CS1 = 1;
CS2 = 1;
CS3 = 1;
CS4 = 1;
NWR = 1;
A0 = 0;
NIC = 1;
//Motor
IN2 = 0;
IN1 = 0;
EN = 0;

Delayms(100); //wait for power supply to ramp up
NIC = 0; //resets YMZ284s
Delayms(10);
NIC = 1;

In the init() function, the pic writes all the setup data to the music chips. This includes the frequency registers, which determine the frequency of each output, the mixer, which determines which channels are on or off (1 = off), and the volume registers, which determine the volume of each channel. After the setup, the only register that is changed in normal operation is the mixer register, which merely turns channels on and off.
//////////////////////////////////////////////////
//Setup music chips
//Setup Chip 1//
CS1 = 0;
write_chip(0x00,0xC7); //a low // C4
write_chip(0x01,0x01); //a high
write_chip(0x02,0x98); //b low // D
write_chip(0x03,0x01); //b high
write_chip(0x04,0x6E); //c low
write_chip(0x05,0x01); //c high // E
write_chip(0x07,0xFF); //mixer (0 enables)
write_chip(0x08, 0x0A); //level (volume) A
write_chip(0x09, 0x0A); //level (volume) B
write_chip(0x0A, 0x0A); //level (volume) C
CS1=1;
//Setup Chip 2//
CS2 = 0;
write_chip(0x00,0x2C); //a low //G 392
write_chip(0x01,0x01); //a high
write_chip(0x02,0x0D); //b low //A 440
write_chip(0x03,0x01); //b high
write_chip(0x04,0xE3); //c low //C5 523.25
write_chip(0x05,0x00); //c high
write_chip(0x07,0xFF); //mixer (0 enables)
write_chip(0x08, 0x0A); //level (volume) A
write_chip(0x09, 0x0A); //level (volume) B
write_chip(0x0A, 0x0A); //level (volume) C
CS2=1;

mixer1=0xFF;
mixer2=0xFF;
OC5 is used to create a PWM signal with 50% duty at 4Mhz, in effect creating a 4Mhz square wave. This is used by the music chips as a master clock.
//////////////////////////////////////////////
//Setup OC to create master clock for music chips (~4 Mhz)
OpenOC5( OC_ON | OC_TIMER2_SRC | OC_PWM_FAULT_PIN_DISABLE, 0, 0);
OpenTimer2( T2_ON | T2_PS_1_1 | T2_SOURCE_INT, 20);
SetDCOC5PWM(10);
The interrupts are used, as mentioned above, to control when the motor is driven. The motor should drive once every rising edge.
/////////////////////////////////////////////
//External interrupt setups (for motor) - INT3 (A14)
mINT3ClearIntFlag();
mINT3IntEnable(1);
mINT3SetIntPriority(6);
mINT3SetEdgeMode(1); //Rising edge
/////////////////////////////////////////////
//External interrupt setups (for motor) - INT4 (A15)
mINT4ClearIntFlag();
mINT4IntEnable(1);
mINT4SetIntPriority(5);
mINT4SetEdgeMode(0); //Falling edge
INTEnableSystemMultiVectoredInt();

/////////////////////////////////////////////
//Setup motor timer (used for timing delays)
OpenTimer3(T3_ON | T3_PS_1_256 | T3_SOURCE_INT, 0xFFFF);
ConfigIntTimer3(T3_INT_OFF);
}

Main function
/* Main function */
int main()
{
init(); /* Run initialization functions */
Delayms(1);

/* Main while loop: loop indefinietly */
while (1) {
In the main while loop, the PIC checks every cycle to see if an input has changed since the last cycle. Since the "mixer" variables store the current state, if an input does not match up with its valid mixer bit then it has changed recently. In this case, the channelSw() function is called to switch on or off the music channel controlled by that bit.
//Check for state changes in music notes
if (ENC != (mixer1 & 0x01)) { channelSw(1,CHNA,&mixer1,!ENC); } //If input ENC (enable C) is not equal to the state of channel A1 (note c), change the state
if (END != (mixer1 & 0x02)) { channelSw(1,CHNB,&mixer1,!END); }
if (ENE != (mixer1 & 0x04)) { channelSw(1,CHNC,&mixer1,!ENE); }
if (ENG != (mixer2 & 0x01)) { channelSw(2,CHNA,&mixer2,!ENG); }
if (ENA != (mixer2 & 0x02)) { channelSw(2,CHNB,&mixer2,!ENA); }
if (ENC5 != (mixer2 & 0x04)) { channelSw(2,CHNC,&mixer2,!ENC5); }
During the main while loop, the motor flag variable is checked to see if the motor should be driven. If so, it enters a sequence where it uses timer3 to determine the current stage in the motor cycle, changing the outputs as needed.
//Check for motor state changes
switch (motorflag) {
case 0: break; //Do nothing (motor off)
case 1: //Start motor cycle
WriteTimer3(0); //Reset timer to 0
IN1 = 0; //Set H bridge to forward drive
IN2 = 1;
EN = 1;
motorflag = 2; //In drivedown cycle
break;
case 2: //Drivedown cycle
if (ReadTimer3() > DRIVETIME) { //Wait for DRIVETIME to pass
WriteTimer3(0); //Reset timer to 0
motorflag = 3; //In driveup phase
IN2 = 0; //Switch H bridge
IN1 = 1;
}
break;
case 3: //Driveup cycle
if (ReadTimer3() > BACKTIME) { //Wait for BACKTIME to pass
WriteTimer3(0); //Reset timer to 0
motorflag = 4; //In coast/wait phase
EN = 0; //Turn off motor
}
break;
case 4: //coast / wait cycle
if (ReadTimer3() > WAITTIME) {
motorflag = 5; //more wait
WriteTimer3(0);
}
break;
case 5: //Additional wait cycle
if (ReadTimer3() > WAITTIME) {
//Done!
motorflag = 0; //Motor off (can now be triggered again)
}
break;
//Static wait cycles
case 6:
if (ReadTimer3() > WAITTIME) {
motorflag = 7;
WriteTimer3(0);
}
break;
case 7:
if (ReadTimer3() > WAITTIME) {
WriteTimer3(0);
motorflag = 8;
}
break;
case 8:
if (ReadTimer3() > WAITTIME) {
motorflag = 0;
}
break;
}

Delayms(10);
}
return 0;
}//end main

Write chip function, which is a support function that writes data to the music chips.
/* write_chip: This writes the given byte "data" to the "address" (0 or 1)
on a YMZ284. It is assumed that the chip select is already low */
void write_chip(int address,int data) {
//Write address
portout(address);
A0 = 0; //select address mode
Delayus(1); //setup time
NWR = 0; //Write cycle begin
Delayus(1); //hold time
NWR = 1; //Write cycle end

//Write data
portout(data);
A0 = 1; //select data mode
Delayus(1); //setup time
NWR = 0; //write cycle begin
Delayus(1); //hold time
NWR = 1; //write cycle end
}
Port out function
/* port_out: This function outputs a byte to the D0-D7 port */
void portout(int byte) {
// Note: !! converts an integer expression to a boolean (1 or 0).
D0 = !!(byte & 1);
D1 = !!(byte & 2);
D2 = !!(byte & 4);
D3 = !!(byte & 8);
D4 = !!(byte & 16);
D5 = !!(byte & 32);
D6 = !!(byte & 64);
D7 = !!(byte & 128);
}
Channel switch function, which writes a new mixer value to turn a channel on or off.
/* channelSw: Generic channel switch function
This writes a new mixer value to chip "chip". The mixer value
depends on "chn", the channel turning on or off, "state" whether
the channel is turning on or off, and "*mixer", a pointer to
the old mixer value. */
void channelSw(int chip, int chn, int *mixer, int state) {
/* Enable music chip */
switch(chip) {
case 1: CS1 = 0; break;
case 2: CS2 = 0; break;
case 3: CS3 = 0; break;
case 4: CS4 = 0; break;
}
/* Write mixer value */
/* This writes to channel 7 (mixer channel) the _new_ mixer value, which is
the old mixer value with a particular bit flipped based on "chn" and "state" */
write_chip(0x07, (*mixer) = state ? (*mixer) & (0xFF & ~chn) : (*mixer) | chn);
/* Disable chip */
switch(chip) {
case 1: CS1 = 1; break;
case 2: CS2 = 1; break;
case 3: CS3 = 1; break;
case 4: CS4 = 1; break;
}

}
Interrupt functions
//External interrupt for motor driving
void __ISR(_EXTERNAL_3_VECTOR, ipl6) _SingleVectorHandler(void) {
if (motorflag == 0) {
motorflag = 1; //Start motor cycle
}
//If on already, do nothing
mINT3ClearIntFlag();
}

//External interrupt for motor waiting
void __ISR(_EXTERNAL_4_VECTOR, ipl5) _SingleVectorHandler2(void) {
if (motorflag == 0) {
WriteTimer3(0);
motorflag = 6; //Start wait cycle
}
//If on already, do nothing
mINT4ClearIntFlag();
}

=Results=

The project turned out to be a mild success overall. The tilt switches worked very well for activating the music tones, but the heart rate monitor was less successful. One of the biggest issues was getting rid of very low frequency drift in the signal that made the peaks sometimes as high as 10V, but other times less 1V. Dealing with this fluctuation in peak size was the most difficult part of signal processing. As mentioned above, we tried FFT in order to establish a steady heart rate, but could not get the resolution we desired, thus we abandoned the idea.

'''PROBABLY NEED MORE TECHNICAL RESULTS HERE, BUT I'M NOT SURE WHAT TO SAY RIGHT NOW'''

The best result was that using the device was just plain fun. We each had a great time moving around and hearing the fun sounds that resulted, or if we were feeling ambitious, we would try to play a simple melody like "Mary Had a Little Lamb." It was rather difficult to play anything more complicated than that because it required lots of body control and precise movements.

=Reflections=

'''Successes'''
*tilt switches activated each of the six notes when they were supposed to
**the YMZ284 chips were able to produce all six notes at the same time, allowing cool chords
*tones were in tune and formed fun melodies and chords as the body moved
*drum actuator hit the drum reliably and with good tone
*heart rate monitor usually showed clear peaks on a scope, but was finnicky in practice

'''Room for improvements'''
*tilt switches sometimes bounced, so the beginning, or particularly the ends of the notes sounded jagged
**''Possible Solution:'' add a low pass filter to the switch signal so that the signal ramps up and down.
*the shoulder straps sometimes needed adjustments for each individual in order for the sensors to be in the correct position
**''Possible Solution:'' create straps with more constraints, such as a strap across the chest as well as the back, to ensure that the sensors are in the correct positions and orientations.
*the straps could be easier to put on
**''Possible Solution:'' maybe integrate them into a single garment, like a onesie
*the heart rate monitor was not reliable. Low frequency drift made setting a comparison level nearly impossible, especially for more than one specific user.
**''Possible Solution:'' improve FFT method so that desired resolution could be achieved in a short sample period (around 10 seconds). Or implement a complicated peak detection algorithm on the PIC.

'''JAMES SHOULD ADD SOME KIND OF HEARTWARMING CONCLUSION CUZ HE'S GOOD AT THAT STUFF'''

Music from the Heart -- Music Suit

2010-03-17T06:15:02Z

EricWest: /* Team Members */

=Introduction=

This project attempted to create a natural form of musical expression by connecting sensors to the body. Six tilt switches were attached to the wrist, ankles, and shoulders, each controlling a single pitch from the [http://en.wikipedia.org/wiki/Pentatonic_scale pentatonic scale]. The heart beat was obtained using [http://en.wikipedia.org/wiki/Photoplethysmograph photoplethysmography] on the user's finger, and this signal was used to strike a drum in sync with the heart beat.

==Team Members==

[[Image:Mfth team picture.JPG|thumb|200px|From left: Thomas, Eric, James]]
*Thomas Peterson (Computer Engineering, 2010)
*James Rein (Biomedical Engineering and Music Cognition, 2010)
*Eric West (Mechanical Engineering, 2011)

=Subsystems=

Although intended as a single, cohesive system that would allow the user to intuitively make music, the project was easily divided into three subsystems: heart rate monitor, drum actuation, and music tones. Below is more explanation about each subsystem.

==Heart rate monitor - Concepts==

In brainstorming how to translate a heart beat into a drum beat, we decided that the least intrusive method would be the best. Attaching electrodes to the user would simplify the process of identifying a heart beat, but attaching the sensors directly to the skin would be a time-consuming and personally-invasive process. Instead, we decided a finger tip sensor would be much more comfortable and easy to use.

To make a finger tip sensor, we used the concepts of [http://en.wikipedia.org/wiki/Photoplethysmograph photoplethysmography]. Photoplethysmography is typically used in [http://en.wikipedia.org/wiki/Pulse_oximeter pulse oximeters] and finger-tip sensors in commercially-available devices. We originally tried to hack a heart rate monitor that we had purchased, but this proved difficult, so we decided to make our own.

The basic concept of photoplethysmography is that blood reflects a certain amount of IR light, and the blood density in the finger changes as the heart pumps, so the IR reflectivity of the finger changes as the heart beats. Using an IR emitter-detector pair found in the mechatronics lab followed by lots of amplification and filtering, we were able to obtain a decent signal with peaks when the user's heart beat.

===Heart rate monitor - Electrical Design===

The signal coming directly out of the IR detector was very weak and noisy. To obtain just the information we desired, we ran it through the following filters and amplifiers:

# [[Passive Filters#High-Pass Filter (HPF)|Passive High-Pass Filter]]
# [[Operational Amplifiers (Op-Amps)#Inverting Amplifier|Inverting Amplifier]]: gain = -470
# [http://en.wikipedia.org/wiki/Low-pass_filter#Active_electronic_realization Active Low-pass filter]: cutoff frequency = 4.82Hz, gain = -70
# [http://www.electronics-tutorials.ws/filter/filter_7.html Band-pass filter]: Frequency range = 0.72 to 3.39Hz, inverting gain = -46.8
# [[Comparators|Comparator]]: output to the PIC pin A14, with pull-up resistor to 3.3V and capacitors to smooth out the signal.

The complete signal processing circuit is shown below.

[[Image:Heartrate monitor.PNG|thumb|center|900px|Heart rate monitor circuit diagram. Click for larger image.]]

===Heart rate monitor - Mechanical Design===

[[Image:Heart rate sensor mfth.JPG|thumb|200px|Heart rate sensor with the latex band pulled away so that the emitter-detector is revealed]]
The sensor itself was a QRB1114 emitter-detector pair that was encased in open-cell foam insulation. We inserted it into the foam by drilling and filing a hole in the foam to the appropriate size, and gluing the sensor in place. A round, finger-shaped groove was filed into the foam and the sensor sat flush with the bottom of this groove. The user's finger was held in the correct position with relatively constant pressure using a latex band around the finger and the foam enclosure.

==Drum actuator - Electrical design==

Once the signal from the heart rate sensor is sent to the PIC, the rising edge triggers an interrupt which starts the driving sequence for the motor that strikes the drum. The drive sequence was: drive down (into drum) 100ms, drive up 75ms, wait 150ms. The interrupt does not do the entire driving sequence, it merely flags a variable to start the sequence, which is done in the main loop, as seen in the code below.

An additional interrupt was triggered by the falling edge of the signal; this falling edge interrupt added additional wait time that prevented the PIC from being "fooled" by a noisy falling edge. For instance, if the falling signal had some noise in it, the rising edge interrupt would be triggered again, thus causing the drum to strike on both the rising and falling edges of the heartbeat. We only wanted one strike per heartbeat, so the falling edge interrupt was triggered by the ''first'' falling edge, and any noise in the falling edge was ignored because the PIC was told to wait for 300ms. With a maximum delay of 150 + 300 = 450ms from the two interrupts, the fastest heartbeat our drum could play was 133 beats per minute, but we did not expect anyone to come play the instrument after running, so this was plenty high for our purposes.

Initially, we tried skipping the comparator and sending the analog signal directly into one of the PICs analog inputs. Our intention was to use the fast Fourier transform (FFT) library to try to extract the dominant frequency. Unfortunately, we ran into various problems. First, to get the accuracy we wanted for small frequencies, the sample window had to be very long (10 seconds or more), which made the output lag changes in heart rate. Additionally, the FFT was often "messy", which messed up our original algorithm of detecting the peak frequency between .5 and 2.5 hz. The system would sometimes randomly switch between very different frequencies, and although it was right most of the time it was enough to make the drum beating sound bad. We also tried algorithms to find the [http://en.wikipedia.org/wiki/Fundamental_frequency fundamental frequency] using the entire FFT (instead of just the .5-2.5 hz range), but this was still unreliable. We considered FFT peak detection algorithms, but they seemed to complex for the time and computing power we had available. Because of all this, we went with the simple comparator in the end.

The motor for driving the drumstick was driven by an [[media:L298N.pdf|L298 H-bridge]]. See [[Driving a high current DC Motor using an H-bridge]] for more information on how this works. Our particular circuit diagram is shown below:

[[Image:T21_motorckt_png.PNG|thumb|center|600px|Motor Circuit (non-motor PIC connections not shown). Click for larger image.]]

====Drum actuator - Mechanical Design====

We wanted to use a real drum for our drum beat, so our challenge was to attach a motor and drumstick to a drum. We chose a small rack tom for its resonant tone that is reminiscent of a heart beat.

To attach the drumstick to the motor shaft, we used a small block of acrylic (.5"x.5"x2"). The drumstick was cut down to 8" in length so that it would require less torque from the motor. In one end of the block, a hole was drilled and the drumstick was sanded to the correct diameter in order to snuggly fit into the hole. To ensure that the drumstick could not slide out of the block, a screw was placed in a hole drilled through both the stick and the block. The other end of the block was attached to the motor shaft using a split-clamp method: A hole the size of the motor shaft was drilled through the block, and then a slit was cut from the end of the block to the hole, allowing a screw to tightly clamp the block around the motor.

'''INSERT PICTURE OF DRUMSTICK-MOTORSHAFT ATTACHMENT'''

To attach the motor-stick assembly to the drum, we utilized the tuning screws on the drum. A sheet metal bracket with holes in the appropriate places attached the motor to two of these tuning screws. The bracket was easily made by cutting and bending a piece of 16 gauge steel sheet metal to the appropriate size. Ideally, this part would have been made out of one continuous piece of sheet metal, but we could not find a large enough sheet available in the shop, so we used rivets to connect two smaller pieces together.

After testing the drum striking, we decided it was too loud. To dampen the sound, we taped a piece of foam core and a shop rag to the head of the drum where the stick strikes it.

'''Parts list for drum actuator'''
*Bargain drumstick, at least .5" in diameter
*Small block of acrylic, .5"x.5"x2" (aluminum would work just as well, this is what was available)
*16 gauge steel sheet metal for bracket
*Screws and nuts
*Foam core, shop rag, tape for dampening

==Music Tones - Electrical Design==
The music tones were activated by tilt switches and generated using a [http://pdf1.alldatasheet.com/datasheet-pdf/view/82065/YAMAHA/YMZ284.html YMZ284] chip and were output through a 1/8" jack to a standard set of computer speakers.

Each YMZ284 is capable of producing and mixing any combination of three tones. Since we wanted to have six notes from a [http://en.wikipedia.org/wiki/Pentatonic_scale pentatonic scale], we needed two of these chips and used an [[Operational Amplifiers (Op-Amps)#Summer|summing opamp circuit]] to combine outputs from each chip. We envisioned a possibility of adding [http://en.wikipedia.org/wiki/Overtone overtones] to each note, to make them sound better and more like a real instrument, so we ended up having four YMZ284s attached to our board. When we tried adding an overtone an octave above the fundamental frequency, it ended up sounding harsh and whiny. We decided the tones sounded better with no overtones, so we are only using 2 of the 4 chips on our board.

The YMZ284 communicates with the PIC over an 8-bit databus, plus additional pins for chip select, address, write enable, and reset. All four of our YMZ284s shared all of their pins ''except'' the chip select line; each required their own individual chip select line so that the PIC could specify with which chips it wanted to talk. The circuit diagram below shows how the chips were connected to the PIC and the summing circuit that followed.

[[Image:T21_musicckt_png.PNG|thumb|center|600px|Music circuit diagram. The summing amplifier is not shown. Click for larger image.]]

===Tilt switches - Electrical Design===
In order to detect when the limbs of the user had moved past a certain critical angle, we chose to use tilt switches. We purchased our tilt switches for $2 each from [http://www.goldmine-elec-products.com/prodinfo.asp?number=G16881 Electronics Goldmine]. We chose to use tilt switches instead of an accelerometer because the switches were much cheaper and we figured they would be easier to work with.

The tilt switches we chose are optically-based with an emitter and detector that are selectively blocked by a small ball. When the critical angle is achieved, the tiny ball rolls up a ramp, allowing the emitter to shine directly on the detector, and current flows. When the angle is neutral, the ramp forces the ball to block the light, making current stop flowing through the phototransistor. The "ramp" is really an inverted cone, so the switch can be activated by a change in angle in any direction away from the neutral position. We purchased three different tilt switches to try, each with a different critical angle - 15, 30, and 45 degrees. The configuration we ended up using was:

*30 degrees for shoulders and ankles
*45 degrees for elbows

In hindsight, we would have used all 45-degree switches because they produced the sharpest jump from off to on. The 15-degree switches were practically unusable because they created a large amount of noise as they switched on and off.

We used the tilt switches to provide high-low inputs to the PIC to tell it when to turn on any of the six tones. By attaching these switches to the body such that they are in the neutral position when the body is relaxed, we were able to control the six tones by moving the body in relatively natural ways.

===Tilt switches - Mechanical Design===
The switches were attached to the user's body using adjustable straps and buckles. The wrist and ankle sensors were simply a loop of webbing with an adjustable buckle attached. The straps could be tightened or loosened to fit any size user. To attach the switch to the straps, we created an enclosure for each switch out of high-density foam (left over scraps from DSGN 307). The switch was jammed into a hole in the foam so that it could not easily be moved. The foam was then taped to the straps using electrical tape.

'''INSERT PICTURE OF THE WRIST AND ANKLE STRAPS'''

The shoulder straps were a bit more involved. Two loops with buckles, similar to the wrist and ankle straps, went over the user's shoulder and underneath their armpit. To keep these straps from sliding off the shoulders, a large strap across the user's back connected the two smaller straps together. This large strap was also used for mounting the solder board which gathered the wires from all six tilt switches and sent them to the PIC over one ribbon cable. Using this strap configuration, we found that the user could comfortably and securely wear the sensors.

To attach the switches to the shoulders, we again created a foam encasement. However, electrical tape was not secure enough to hold the foam pieces to the irregularly-shaped shoulder straps. Instead, we riveted a piece of canvas to the webbing straps. We chose to use rivets instead of sewing because the sewing machine could not tightly sew the foam encasement in place. With rivets, we were able to pull the canvas tightly around the foam so that it couldn't move.

'''INSERT PICTURE OF THE SHOULDER STRAPS'''

=Code=
To download the entire C file, click [[Media:Main_music.c|here]]. Below, the file is split into sections for comments.

/**********************************************************
* main_music.c: Main c file for "Music Suit" project
*
* Thomas Peterson, James Rein, Eric West
* ME333 Winter 2010
**********************************************************/

#include <HardwareProfile.h>
#include <delays.c> //Delayms and Delayus functions

The first section defines all the input and output pins, used with the motor, sensor, and music circuits.

////////////////////////////////////////////////////
//Pin Defines

//YMZ Chip selects
#define CS1 LATCbits.LATC2
#define CS2 LATCbits.LATC3
#define CS3 LATCbits.LATC4
#define CS4 LATGbits.LATG6
//YMZ communication pins
#define NWR LATBbits.LATB0 //"Not WRite": active low write line
#define A0 LATBbits.LATB6 //Address 0
#define NIC LATCbits.LATC1 //"Not Input Clear": active low reset line
//YMZ data pins
#define D0 LATGbits.LATG9
#define D1 LATEbits.LATE8
#define D2 LATEbits.LATE9
#define D3 LATBbits.LATB5
#define D4 LATBbits.LATB4
#define D5 LATBbits.LATB3
#define D6 LATBbits.LATB2
#define D7 LATBbits.LATB1

//Tilt inputs
#define ENC PORTDbits.RD3
#define END PORTDbits.RD2
#define ENE PORTDbits.RD1
#define ENG PORTCbits.RC14
#define ENA PORTCbits.RC13
#define ENC5 PORTDbits.RD0

//Motor outputs
#define IN1 LATBbits.LATB7
#define IN2 LATAbits.LATA9
#define EN LATAbits.LATA10

///////////////////////////////////////
//Other defines
//Motor times
#define MS(x) x*312.5
#define DRIVETIME MS(100)
#define BACKTIME MS(75)
#define WAITTIME MS(150)
//Channels
#define CHNA 1
#define CHNB 2
#define CHNC 4

//////////////////////////////////////////
//Function definitions
void write_chip(int address, int data);
void portout(int byte);
void channelSw(int chip, int chn, int *mixer, int state);
//Global variables
int mixer1, mixer2;
int motorflag = 0;
The initialization function sets up various parts of the system.
/* init() : This function runs initializations, setting up the pic and music chips */
void init() {
int pbClk = SYSTEMConfigPerformance(SYS_FREQ);

/////////////////////////////////////////////
//Setup inputs / outputs
AD1PCFG = 0xFFFF; //All digital inputs
TRISG &= 0xFDBF; //sets G9,G6 to 0 (output); all else remains the same
TRISC &= 0xFFE1; //sets C4,C3,C2,C1 to 0s (outputs); all else remains the same
TRISB &= 0xFF80; //sets B0-B6 0 (output)
TRISE &= 0xFCFF; //sets E8,9 to output
TRISB |= 0xF000; //sets B12,B13,B14,B15 to 1s (inputs); all else remains the same
TRISC |= 0x6000; //sets C14,13 to inputs
TRISD |= 0x000F; //Sets D0,D1,D2,D3 to inputs
TRISDbits.TRISD4 = 0; //Output for clock
//Motor outputs
TRISAbits.TRISA9 = 0;
TRISAbits.TRISA10 = 0;
TRISBbits.TRISB7 = 0;
//Pulse inputs
TRISAbits.TRISA14 = 1;
TRISAbits.TRISA15 = 1;
//ODC setup
ODCCbits.ODCC1 = 1; //open drain control; can only float high (when set high) or pull low

/* Initialize outputs */
//YMZs
CS1 = 1;
CS2 = 1;
CS3 = 1;
CS4 = 1;
NWR = 1;
A0 = 0;
NIC = 1;
//Motor
IN2 = 0;
IN1 = 0;
EN = 0;

Delayms(100); //wait for power supply to ramp up
NIC = 0; //resets YMZ284s
Delayms(10);
NIC = 1;

In the init() function, the pic writes all the setup data to the music chips. This includes the frequency registers, which determine the frequency of each output, the mixer, which determines which channels are on or off (1 = off), and the volume registers, which determine the volume of each channel. After the setup, the only register that is changed in normal operation is the mixer register, which merely turns channels on and off.
//////////////////////////////////////////////////
//Setup music chips
//Setup Chip 1//
CS1 = 0;
write_chip(0x00,0xC7); //a low // C4
write_chip(0x01,0x01); //a high
write_chip(0x02,0x98); //b low // D
write_chip(0x03,0x01); //b high
write_chip(0x04,0x6E); //c low
write_chip(0x05,0x01); //c high // E
write_chip(0x07,0xFF); //mixer (0 enables)
write_chip(0x08, 0x0A); //level (volume) A
write_chip(0x09, 0x0A); //level (volume) B
write_chip(0x0A, 0x0A); //level (volume) C
CS1=1;
//Setup Chip 2//
CS2 = 0;
write_chip(0x00,0x2C); //a low //G 392
write_chip(0x01,0x01); //a high
write_chip(0x02,0x0D); //b low //A 440
write_chip(0x03,0x01); //b high
write_chip(0x04,0xE3); //c low //C5 523.25
write_chip(0x05,0x00); //c high
write_chip(0x07,0xFF); //mixer (0 enables)
write_chip(0x08, 0x0A); //level (volume) A
write_chip(0x09, 0x0A); //level (volume) B
write_chip(0x0A, 0x0A); //level (volume) C
CS2=1;

mixer1=0xFF;
mixer2=0xFF;
OC5 is used to create a PWM signal with 50% duty at 4Mhz, in effect creating a 4Mhz square wave. This is used by the music chips as a master clock.
//////////////////////////////////////////////
//Setup OC to create master clock for music chips (~4 Mhz)
OpenOC5( OC_ON | OC_TIMER2_SRC | OC_PWM_FAULT_PIN_DISABLE, 0, 0);
OpenTimer2( T2_ON | T2_PS_1_1 | T2_SOURCE_INT, 20);
SetDCOC5PWM(10);
The interrupts are used, as mentioned above, to control when the motor is driven. The motor should drive once every rising edge.
/////////////////////////////////////////////
//External interrupt setups (for motor) - INT3 (A14)
mINT3ClearIntFlag();
mINT3IntEnable(1);
mINT3SetIntPriority(6);
mINT3SetEdgeMode(1); //Rising edge
/////////////////////////////////////////////
//External interrupt setups (for motor) - INT4 (A15)
mINT4ClearIntFlag();
mINT4IntEnable(1);
mINT4SetIntPriority(5);
mINT4SetEdgeMode(0); //Falling edge
INTEnableSystemMultiVectoredInt();

/////////////////////////////////////////////
//Setup motor timer (used for timing delays)
OpenTimer3(T3_ON | T3_PS_1_256 | T3_SOURCE_INT, 0xFFFF);
ConfigIntTimer3(T3_INT_OFF);
}

Main function
/* Main function */
int main()
{
init(); /* Run initialization functions */
Delayms(1);

/* Main while loop: loop indefinietly */
while (1) {
In the main while loop, the PIC checks every cycle to see if an input has changed since the last cycle. Since the "mixer" variables store the current state, if an input does not match up with its valid mixer bit then it has changed recently. In this case, the channelSw() function is called to switch on or off the music channel controlled by that bit.
//Check for state changes in music notes
if (ENC != (mixer1 & 0x01)) { channelSw(1,CHNA,&mixer1,!ENC); } //If input ENC (enable C) is not equal to the state of channel A1 (note c), change the state
if (END != (mixer1 & 0x02)) { channelSw(1,CHNB,&mixer1,!END); }
if (ENE != (mixer1 & 0x04)) { channelSw(1,CHNC,&mixer1,!ENE); }
if (ENG != (mixer2 & 0x01)) { channelSw(2,CHNA,&mixer2,!ENG); }
if (ENA != (mixer2 & 0x02)) { channelSw(2,CHNB,&mixer2,!ENA); }
if (ENC5 != (mixer2 & 0x04)) { channelSw(2,CHNC,&mixer2,!ENC5); }
During the main while loop, the motor flag variable is checked to see if the motor should be driven. If so, it enters a sequence where it uses timer3 to determine the current stage in the motor cycle, changing the outputs as needed.
//Check for motor state changes
switch (motorflag) {
case 0: break; //Do nothing (motor off)
case 1: //Start motor cycle
WriteTimer3(0); //Reset timer to 0
IN1 = 0; //Set H bridge to forward drive
IN2 = 1;
EN = 1;
motorflag = 2; //In drivedown cycle
break;
case 2: //Drivedown cycle
if (ReadTimer3() > DRIVETIME) { //Wait for DRIVETIME to pass
WriteTimer3(0); //Reset timer to 0
motorflag = 3; //In driveup phase
IN2 = 0; //Switch H bridge
IN1 = 1;
}
break;
case 3: //Driveup cycle
if (ReadTimer3() > BACKTIME) { //Wait for BACKTIME to pass
WriteTimer3(0); //Reset timer to 0
motorflag = 4; //In coast/wait phase
EN = 0; //Turn off motor
}
break;
case 4: //coast / wait cycle
if (ReadTimer3() > WAITTIME) {
motorflag = 5; //more wait
WriteTimer3(0);
}
break;
case 5: //Additional wait cycle
if (ReadTimer3() > WAITTIME) {
//Done!
motorflag = 0; //Motor off (can now be triggered again)
}
break;
//Static wait cycles
case 6:
if (ReadTimer3() > WAITTIME) {
motorflag = 7;
WriteTimer3(0);
}
break;
case 7:
if (ReadTimer3() > WAITTIME) {
WriteTimer3(0);
motorflag = 8;
}
break;
case 8:
if (ReadTimer3() > WAITTIME) {
motorflag = 0;
}
break;
}

Delayms(10);
}
return 0;
}//end main

Write chip function, which is a support function that writes data to the music chips.
/* write_chip: This writes the given byte "data" to the "address" (0 or 1)
on a YMZ284. It is assumed that the chip select is already low */
void write_chip(int address,int data) {
//Write address
portout(address);
A0 = 0; //select address mode
Delayus(1); //setup time
NWR = 0; //Write cycle begin
Delayus(1); //hold time
NWR = 1; //Write cycle end

//Write data
portout(data);
A0 = 1; //select data mode
Delayus(1); //setup time
NWR = 0; //write cycle begin
Delayus(1); //hold time
NWR = 1; //write cycle end
}
Port out function
/* port_out: This function outputs a byte to the D0-D7 port */
void portout(int byte) {
// Note: !! converts an integer expression to a boolean (1 or 0).
D0 = !!(byte & 1);
D1 = !!(byte & 2);
D2 = !!(byte & 4);
D3 = !!(byte & 8);
D4 = !!(byte & 16);
D5 = !!(byte & 32);
D6 = !!(byte & 64);
D7 = !!(byte & 128);
}
Channel switch function, which writes a new mixer value to turn a channel on or off.
/* channelSw: Generic channel switch function
This writes a new mixer value to chip "chip". The mixer value
depends on "chn", the channel turning on or off, "state" whether
the channel is turning on or off, and "*mixer", a pointer to
the old mixer value. */
void channelSw(int chip, int chn, int *mixer, int state) {
/* Enable music chip */
switch(chip) {
case 1: CS1 = 0; break;
case 2: CS2 = 0; break;
case 3: CS3 = 0; break;
case 4: CS4 = 0; break;
}
/* Write mixer value */
/* This writes to channel 7 (mixer channel) the _new_ mixer value, which is
the old mixer value with a particular bit flipped based on "chn" and "state" */
write_chip(0x07, (*mixer) = state ? (*mixer) & (0xFF & ~chn) : (*mixer) | chn);
/* Disable chip */
switch(chip) {
case 1: CS1 = 1; break;
case 2: CS2 = 1; break;
case 3: CS3 = 1; break;
case 4: CS4 = 1; break;
}

}
Interrupt functions
//External interrupt for motor driving
void __ISR(_EXTERNAL_3_VECTOR, ipl6) _SingleVectorHandler(void) {
if (motorflag == 0) {
motorflag = 1; //Start motor cycle
}
//If on already, do nothing
mINT3ClearIntFlag();
}

//External interrupt for motor waiting
void __ISR(_EXTERNAL_4_VECTOR, ipl5) _SingleVectorHandler2(void) {
if (motorflag == 0) {
WriteTimer3(0);
motorflag = 6; //Start wait cycle
}
//If on already, do nothing
mINT4ClearIntFlag();
}

=Results=

The project turned out to be a mild success overall. The tilt switches worked very well for activating the music tones, but the heart rate monitor was less successful. One of the biggest issues was getting rid of very low frequency drift in the signal that made the peaks sometimes as high as 10V, but other times less 1V. Dealing with this fluctuation in peak size was the most difficult part of signal processing. As mentioned above, we tried FFT in order to establish a steady heart rate, but could not get the resolution we desired, thus we abandoned the idea.

'''PROBABLY NEED MORE TECHNICAL RESULTS HERE, BUT I'M NOT SURE WHAT TO SAY RIGHT NOW'''

The best result was that using the device was just plain fun. We each had a great time moving around and hearing the fun sounds that resulted, or if we were feeling ambitious, we would try to play a simple melody like "Mary Had a Little Lamb." It was rather difficult to play anything more complicated than that because it required lots of body control and precise movements.

=Reflections=

'''Successes'''
*tilt switches activated each of the six notes when they were supposed to
**the YMZ284 chips were able to produce all six notes at the same time, allowing cool chords
*tones were in tune and formed fun melodies and chords as the body moved
*drum actuator hit the drum reliably and with good tone
*heart rate monitor usually showed clear peaks on a scope, but was finnicky in practice

'''Room for improvements'''
*tilt switches sometimes bounced, so the beginning, or particularly the ends of the notes sounded jagged
**''Possible Solution:'' add a low pass filter to the switch signal so that the signal ramps up and down.
*the shoulder straps sometimes needed adjustments for each individual in order for the sensors to be in the correct position
**''Possible Solution:'' create straps with more constraints, such as a strap across the chest as well as the back, to ensure that the sensors are in the correct positions and orientations.
*the straps could be easier to put on
**''Possible Solution:'' maybe integrate them into a single garment, like a onesie
*the heart rate monitor was not reliable. Low frequency drift made setting a comparison level nearly impossible, especially for more than one specific user.
**''Possible Solution:'' improve FFT method so that desired resolution could be achieved in a short sample period (around 10 seconds). Or implement a complicated peak detection algorithm on the PIC.

'''JAMES SHOULD ADD SOME KIND OF HEARTWARMING CONCLUSION CUZ HE'S GOOD AT THAT STUFF'''

File:Mfth team picture.JPG

2010-03-17T06:13:43Z

EricWest: team picture of team 21, with their "Music from the Heart Music Suit." ME 333, winter 2010

team picture of team 21, with their "Music from the Heart Music Suit." ME 333, winter 2010

Music from the Heart -- Music Suit

2010-03-17T06:10:02Z

EricWest: /* Heart rate monitor - Mechanical Design */

=Introduction=

This project attempted to create a natural form of musical expression by connecting sensors to the body. Six tilt switches were attached to the wrist, ankles, and shoulders, each controlling a single pitch from the [http://en.wikipedia.org/wiki/Pentatonic_scale pentatonic scale]. The heart beat was obtained using [http://en.wikipedia.org/wiki/Photoplethysmograph photoplethysmography] on the user's finger, and this signal was used to strike a drum in sync with the heart beat.

==Team Members==

*Thomas Peterson (Computer Engineering, 2010)
*James Rein (Biomedical Engineering and Music Cognition, 2010)
*Eric West (Mechanical Engineering, 2011)

'''INSERT TEAM PICTURE HERE'''

=Subsystems=

Although intended as a single, cohesive system that would allow the user to intuitively make music, the project was easily divided into three subsystems: heart rate monitor, drum actuation, and music tones. Below is more explanation about each subsystem.

==Heart rate monitor - Concepts==

In brainstorming how to translate a heart beat into a drum beat, we decided that the least intrusive method would be the best. Attaching electrodes to the user would simplify the process of identifying a heart beat, but attaching the sensors directly to the skin would be a time-consuming and personally-invasive process. Instead, we decided a finger tip sensor would be much more comfortable and easy to use.

To make a finger tip sensor, we used the concepts of [http://en.wikipedia.org/wiki/Photoplethysmograph photoplethysmography]. Photoplethysmography is typically used in [http://en.wikipedia.org/wiki/Pulse_oximeter pulse oximeters] and finger-tip sensors in commercially-available devices. We originally tried to hack a heart rate monitor that we had purchased, but this proved difficult, so we decided to make our own.

The basic concept of photoplethysmography is that blood reflects a certain amount of IR light, and the blood density in the finger changes as the heart pumps, so the IR reflectivity of the finger changes as the heart beats. Using an IR emitter-detector pair found in the mechatronics lab followed by lots of amplification and filtering, we were able to obtain a decent signal with peaks when the user's heart beat.

===Heart rate monitor - Electrical Design===

The signal coming directly out of the IR detector was very weak and noisy. To obtain just the information we desired, we ran it through the following filters and amplifiers:

# [[Passive Filters#High-Pass Filter (HPF)|Passive High-Pass Filter]]
# [[Operational Amplifiers (Op-Amps)#Inverting Amplifier|Inverting Amplifier]]: gain = -470
# [http://en.wikipedia.org/wiki/Low-pass_filter#Active_electronic_realization Active Low-pass filter]: cutoff frequency = 4.82Hz, gain = -70
# [http://www.electronics-tutorials.ws/filter/filter_7.html Band-pass filter]: Frequency range = 0.72 to 3.39Hz, inverting gain = -46.8
# [[Comparators|Comparator]]: output to the PIC pin A14, with pull-up resistor to 3.3V and capacitors to smooth out the signal.

The complete signal processing circuit is shown below.

[[Image:Heartrate monitor.PNG|thumb|center|900px|Heart rate monitor circuit diagram. Click for larger image.]]

===Heart rate monitor - Mechanical Design===

[[Image:Heart rate sensor mfth.JPG|thumb|200px|Heart rate sensor with the latex band pulled away so that the emitter-detector is revealed]]
The sensor itself was a QRB1114 emitter-detector pair that was encased in open-cell foam insulation. We inserted it into the foam by drilling and filing a hole in the foam to the appropriate size, and gluing the sensor in place. A round, finger-shaped groove was filed into the foam and the sensor sat flush with the bottom of this groove. The user's finger was held in the correct position with relatively constant pressure using a latex band around the finger and the foam enclosure.

==Drum actuator - Electrical design==

Once the signal from the heart rate sensor is sent to the PIC, the rising edge triggers an interrupt which starts the driving sequence for the motor that strikes the drum. The drive sequence was: drive down (into drum) 100ms, drive up 75ms, wait 150ms. The interrupt does not do the entire driving sequence, it merely flags a variable to start the sequence, which is done in the main loop, as seen in the code below.

An additional interrupt was triggered by the falling edge of the signal; this falling edge interrupt added additional wait time that prevented the PIC from being "fooled" by a noisy falling edge. For instance, if the falling signal had some noise in it, the rising edge interrupt would be triggered again, thus causing the drum to strike on both the rising and falling edges of the heartbeat. We only wanted one strike per heartbeat, so the falling edge interrupt was triggered by the ''first'' falling edge, and any noise in the falling edge was ignored because the PIC was told to wait for 300ms. With a maximum delay of 150 + 300 = 450ms from the two interrupts, the fastest heartbeat our drum could play was 133 beats per minute, but we did not expect anyone to come play the instrument after running, so this was plenty high for our purposes.

Initially, we tried skipping the comparator and sending the analog signal directly into one of the PICs analog inputs. Our intention was to use the fast Fourier transform (FFT) library to try to extract the dominant frequency. Unfortunately, we ran into various problems. First, to get the accuracy we wanted for small frequencies, the sample window had to be very long (10 seconds or more), which made the output lag changes in heart rate. Additionally, the FFT was often "messy", which messed up our original algorithm of detecting the peak frequency between .5 and 2.5 hz. The system would sometimes randomly switch between very different frequencies, and although it was right most of the time it was enough to make the drum beating sound bad. We also tried algorithms to find the [http://en.wikipedia.org/wiki/Fundamental_frequency fundamental frequency] using the entire FFT (instead of just the .5-2.5 hz range), but this was still unreliable. We considered FFT peak detection algorithms, but they seemed to complex for the time and computing power we had available. Because of all this, we went with the simple comparator in the end.

The motor for driving the drumstick was driven by an [[media:L298N.pdf|L298 H-bridge]]. See [[Driving a high current DC Motor using an H-bridge]] for more information on how this works. Our particular circuit diagram is shown below:

[[Image:T21_motorckt_png.PNG|thumb|center|600px|Motor Circuit (non-motor PIC connections not shown). Click for larger image.]]

====Drum actuator - Mechanical Design====

We wanted to use a real drum for our drum beat, so our challenge was to attach a motor and drumstick to a drum. We chose a small rack tom for its resonant tone that is reminiscent of a heart beat.

To attach the drumstick to the motor shaft, we used a small block of acrylic (.5"x.5"x2"). The drumstick was cut down to 8" in length so that it would require less torque from the motor. In one end of the block, a hole was drilled and the drumstick was sanded to the correct diameter in order to snuggly fit into the hole. To ensure that the drumstick could not slide out of the block, a screw was placed in a hole drilled through both the stick and the block. The other end of the block was attached to the motor shaft using a split-clamp method: A hole the size of the motor shaft was drilled through the block, and then a slit was cut from the end of the block to the hole, allowing a screw to tightly clamp the block around the motor.

'''INSERT PICTURE OF DRUMSTICK-MOTORSHAFT ATTACHMENT'''

To attach the motor-stick assembly to the drum, we utilized the tuning screws on the drum. A sheet metal bracket with holes in the appropriate places attached the motor to two of these tuning screws. The bracket was easily made by cutting and bending a piece of 16 gauge steel sheet metal to the appropriate size. Ideally, this part would have been made out of one continuous piece of sheet metal, but we could not find a large enough sheet available in the shop, so we used rivets to connect two smaller pieces together.

After testing the drum striking, we decided it was too loud. To dampen the sound, we taped a piece of foam core and a shop rag to the head of the drum where the stick strikes it.

'''Parts list for drum actuator'''
*Bargain drumstick, at least .5" in diameter
*Small block of acrylic, .5"x.5"x2" (aluminum would work just as well, this is what was available)
*16 gauge steel sheet metal for bracket
*Screws and nuts
*Foam core, shop rag, tape for dampening

==Music Tones - Electrical Design==
The music tones were activated by tilt switches and generated using a [http://pdf1.alldatasheet.com/datasheet-pdf/view/82065/YAMAHA/YMZ284.html YMZ284] chip and were output through a 1/8" jack to a standard set of computer speakers.

Each YMZ284 is capable of producing and mixing any combination of three tones. Since we wanted to have six notes from a [http://en.wikipedia.org/wiki/Pentatonic_scale pentatonic scale], we needed two of these chips and used an [[Operational Amplifiers (Op-Amps)#Summer|summing opamp circuit]] to combine outputs from each chip. We envisioned a possibility of adding [http://en.wikipedia.org/wiki/Overtone overtones] to each note, to make them sound better and more like a real instrument, so we ended up having four YMZ284s attached to our board. When we tried adding an overtone an octave above the fundamental frequency, it ended up sounding harsh and whiny. We decided the tones sounded better with no overtones, so we are only using 2 of the 4 chips on our board.

The YMZ284 communicates with the PIC over an 8-bit databus, plus additional pins for chip select, address, write enable, and reset. All four of our YMZ284s shared all of their pins ''except'' the chip select line; each required their own individual chip select line so that the PIC could specify with which chips it wanted to talk. The circuit diagram below shows how the chips were connected to the PIC and the summing circuit that followed.

[[Image:T21_musicckt_png.PNG|thumb|center|600px|Music circuit diagram. The summing amplifier is not shown. Click for larger image.]]

===Tilt switches - Electrical Design===
In order to detect when the limbs of the user had moved past a certain critical angle, we chose to use tilt switches. We purchased our tilt switches for $2 each from [http://www.goldmine-elec-products.com/prodinfo.asp?number=G16881 Electronics Goldmine]. We chose to use tilt switches instead of an accelerometer because the switches were much cheaper and we figured they would be easier to work with.

The tilt switches we chose are optically-based with an emitter and detector that are selectively blocked by a small ball. When the critical angle is achieved, the tiny ball rolls up a ramp, allowing the emitter to shine directly on the detector, and current flows. When the angle is neutral, the ramp forces the ball to block the light, making current stop flowing through the phototransistor. The "ramp" is really an inverted cone, so the switch can be activated by a change in angle in any direction away from the neutral position. We purchased three different tilt switches to try, each with a different critical angle - 15, 30, and 45 degrees. The configuration we ended up using was:

*30 degrees for shoulders and ankles
*45 degrees for elbows

In hindsight, we would have used all 45-degree switches because they produced the sharpest jump from off to on. The 15-degree switches were practically unusable because they created a large amount of noise as they switched on and off.

We used the tilt switches to provide high-low inputs to the PIC to tell it when to turn on any of the six tones. By attaching these switches to the body such that they are in the neutral position when the body is relaxed, we were able to control the six tones by moving the body in relatively natural ways.

===Tilt switches - Mechanical Design===
The switches were attached to the user's body using adjustable straps and buckles. The wrist and ankle sensors were simply a loop of webbing with an adjustable buckle attached. The straps could be tightened or loosened to fit any size user. To attach the switch to the straps, we created an enclosure for each switch out of high-density foam (left over scraps from DSGN 307). The switch was jammed into a hole in the foam so that it could not easily be moved. The foam was then taped to the straps using electrical tape.

'''INSERT PICTURE OF THE WRIST AND ANKLE STRAPS'''

The shoulder straps were a bit more involved. Two loops with buckles, similar to the wrist and ankle straps, went over the user's shoulder and underneath their armpit. To keep these straps from sliding off the shoulders, a large strap across the user's back connected the two smaller straps together. This large strap was also used for mounting the solder board which gathered the wires from all six tilt switches and sent them to the PIC over one ribbon cable. Using this strap configuration, we found that the user could comfortably and securely wear the sensors.

To attach the switches to the shoulders, we again created a foam encasement. However, electrical tape was not secure enough to hold the foam pieces to the irregularly-shaped shoulder straps. Instead, we riveted a piece of canvas to the webbing straps. We chose to use rivets instead of sewing because the sewing machine could not tightly sew the foam encasement in place. With rivets, we were able to pull the canvas tightly around the foam so that it couldn't move.

'''INSERT PICTURE OF THE SHOULDER STRAPS'''

=Code=
To download the entire C file, click [[Media:Main_music.c|here]]. Below, the file is split into sections for comments.

/**********************************************************
* main_music.c: Main c file for "Music Suit" project
*
* Thomas Peterson, James Rein, Eric West
* ME333 Winter 2010
**********************************************************/

#include <HardwareProfile.h>
#include <delays.c> //Delayms and Delayus functions

The first section defines all the input and output pins, used with the motor, sensor, and music circuits.

////////////////////////////////////////////////////
//Pin Defines

//YMZ Chip selects
#define CS1 LATCbits.LATC2
#define CS2 LATCbits.LATC3
#define CS3 LATCbits.LATC4
#define CS4 LATGbits.LATG6
//YMZ communication pins
#define NWR LATBbits.LATB0 //"Not WRite": active low write line
#define A0 LATBbits.LATB6 //Address 0
#define NIC LATCbits.LATC1 //"Not Input Clear": active low reset line
//YMZ data pins
#define D0 LATGbits.LATG9
#define D1 LATEbits.LATE8
#define D2 LATEbits.LATE9
#define D3 LATBbits.LATB5
#define D4 LATBbits.LATB4
#define D5 LATBbits.LATB3
#define D6 LATBbits.LATB2
#define D7 LATBbits.LATB1

//Tilt inputs
#define ENC PORTDbits.RD3
#define END PORTDbits.RD2
#define ENE PORTDbits.RD1
#define ENG PORTCbits.RC14
#define ENA PORTCbits.RC13
#define ENC5 PORTDbits.RD0

//Motor outputs
#define IN1 LATBbits.LATB7
#define IN2 LATAbits.LATA9
#define EN LATAbits.LATA10

///////////////////////////////////////
//Other defines
//Motor times
#define MS(x) x*312.5
#define DRIVETIME MS(100)
#define BACKTIME MS(75)
#define WAITTIME MS(150)
//Channels
#define CHNA 1
#define CHNB 2
#define CHNC 4

//////////////////////////////////////////
//Function definitions
void write_chip(int address, int data);
void portout(int byte);
void channelSw(int chip, int chn, int *mixer, int state);
//Global variables
int mixer1, mixer2;
int motorflag = 0;
The initialization function sets up various parts of the system.
/* init() : This function runs initializations, setting up the pic and music chips */
void init() {
int pbClk = SYSTEMConfigPerformance(SYS_FREQ);

/////////////////////////////////////////////
//Setup inputs / outputs
AD1PCFG = 0xFFFF; //All digital inputs
TRISG &= 0xFDBF; //sets G9,G6 to 0 (output); all else remains the same
TRISC &= 0xFFE1; //sets C4,C3,C2,C1 to 0s (outputs); all else remains the same
TRISB &= 0xFF80; //sets B0-B6 0 (output)
TRISE &= 0xFCFF; //sets E8,9 to output
TRISB |= 0xF000; //sets B12,B13,B14,B15 to 1s (inputs); all else remains the same
TRISC |= 0x6000; //sets C14,13 to inputs
TRISD |= 0x000F; //Sets D0,D1,D2,D3 to inputs
TRISDbits.TRISD4 = 0; //Output for clock
//Motor outputs
TRISAbits.TRISA9 = 0;
TRISAbits.TRISA10 = 0;
TRISBbits.TRISB7 = 0;
//Pulse inputs
TRISAbits.TRISA14 = 1;
TRISAbits.TRISA15 = 1;
//ODC setup
ODCCbits.ODCC1 = 1; //open drain control; can only float high (when set high) or pull low

/* Initialize outputs */
//YMZs
CS1 = 1;
CS2 = 1;
CS3 = 1;
CS4 = 1;
NWR = 1;
A0 = 0;
NIC = 1;
//Motor
IN2 = 0;
IN1 = 0;
EN = 0;

Delayms(100); //wait for power supply to ramp up
NIC = 0; //resets YMZ284s
Delayms(10);
NIC = 1;

In the init() function, the pic writes all the setup data to the music chips. This includes the frequency registers, which determine the frequency of each output, the mixer, which determines which channels are on or off (1 = off), and the volume registers, which determine the volume of each channel. After the setup, the only register that is changed in normal operation is the mixer register, which merely turns channels on and off.
//////////////////////////////////////////////////
//Setup music chips
//Setup Chip 1//
CS1 = 0;
write_chip(0x00,0xC7); //a low // C4
write_chip(0x01,0x01); //a high
write_chip(0x02,0x98); //b low // D
write_chip(0x03,0x01); //b high
write_chip(0x04,0x6E); //c low
write_chip(0x05,0x01); //c high // E
write_chip(0x07,0xFF); //mixer (0 enables)
write_chip(0x08, 0x0A); //level (volume) A
write_chip(0x09, 0x0A); //level (volume) B
write_chip(0x0A, 0x0A); //level (volume) C
CS1=1;
//Setup Chip 2//
CS2 = 0;
write_chip(0x00,0x2C); //a low //G 392
write_chip(0x01,0x01); //a high
write_chip(0x02,0x0D); //b low //A 440
write_chip(0x03,0x01); //b high
write_chip(0x04,0xE3); //c low //C5 523.25
write_chip(0x05,0x00); //c high
write_chip(0x07,0xFF); //mixer (0 enables)
write_chip(0x08, 0x0A); //level (volume) A
write_chip(0x09, 0x0A); //level (volume) B
write_chip(0x0A, 0x0A); //level (volume) C
CS2=1;

mixer1=0xFF;
mixer2=0xFF;
OC5 is used to create a PWM signal with 50% duty at 4Mhz, in effect creating a 4Mhz square wave. This is used by the music chips as a master clock.
//////////////////////////////////////////////
//Setup OC to create master clock for music chips (~4 Mhz)
OpenOC5( OC_ON | OC_TIMER2_SRC | OC_PWM_FAULT_PIN_DISABLE, 0, 0);
OpenTimer2( T2_ON | T2_PS_1_1 | T2_SOURCE_INT, 20);
SetDCOC5PWM(10);
The interrupts are used, as mentioned above, to control when the motor is driven. The motor should drive once every rising edge.
/////////////////////////////////////////////
//External interrupt setups (for motor) - INT3 (A14)
mINT3ClearIntFlag();
mINT3IntEnable(1);
mINT3SetIntPriority(6);
mINT3SetEdgeMode(1); //Rising edge
/////////////////////////////////////////////
//External interrupt setups (for motor) - INT4 (A15)
mINT4ClearIntFlag();
mINT4IntEnable(1);
mINT4SetIntPriority(5);
mINT4SetEdgeMode(0); //Falling edge
INTEnableSystemMultiVectoredInt();

/////////////////////////////////////////////
//Setup motor timer (used for timing delays)
OpenTimer3(T3_ON | T3_PS_1_256 | T3_SOURCE_INT, 0xFFFF);
ConfigIntTimer3(T3_INT_OFF);
}

Main function
/* Main function */
int main()
{
init(); /* Run initialization functions */
Delayms(1);

/* Main while loop: loop indefinietly */
while (1) {
In the main while loop, the PIC checks every cycle to see if an input has changed since the last cycle. Since the "mixer" variables store the current state, if an input does not match up with its valid mixer bit then it has changed recently. In this case, the channelSw() function is called to switch on or off the music channel controlled by that bit.
//Check for state changes in music notes
if (ENC != (mixer1 & 0x01)) { channelSw(1,CHNA,&mixer1,!ENC); } //If input ENC (enable C) is not equal to the state of channel A1 (note c), change the state
if (END != (mixer1 & 0x02)) { channelSw(1,CHNB,&mixer1,!END); }
if (ENE != (mixer1 & 0x04)) { channelSw(1,CHNC,&mixer1,!ENE); }
if (ENG != (mixer2 & 0x01)) { channelSw(2,CHNA,&mixer2,!ENG); }
if (ENA != (mixer2 & 0x02)) { channelSw(2,CHNB,&mixer2,!ENA); }
if (ENC5 != (mixer2 & 0x04)) { channelSw(2,CHNC,&mixer2,!ENC5); }
During the main while loop, the motor flag variable is checked to see if the motor should be driven. If so, it enters a sequence where it uses timer3 to determine the current stage in the motor cycle, changing the outputs as needed.
//Check for motor state changes
switch (motorflag) {
case 0: break; //Do nothing (motor off)
case 1: //Start motor cycle
WriteTimer3(0); //Reset timer to 0
IN1 = 0; //Set H bridge to forward drive
IN2 = 1;
EN = 1;
motorflag = 2; //In drivedown cycle
break;
case 2: //Drivedown cycle
if (ReadTimer3() > DRIVETIME) { //Wait for DRIVETIME to pass
WriteTimer3(0); //Reset timer to 0
motorflag = 3; //In driveup phase
IN2 = 0; //Switch H bridge
IN1 = 1;
}
break;
case 3: //Driveup cycle
if (ReadTimer3() > BACKTIME) { //Wait for BACKTIME to pass
WriteTimer3(0); //Reset timer to 0
motorflag = 4; //In coast/wait phase
EN = 0; //Turn off motor
}
break;
case 4: //coast / wait cycle
if (ReadTimer3() > WAITTIME) {
motorflag = 5; //more wait
WriteTimer3(0);
}
break;
case 5: //Additional wait cycle
if (ReadTimer3() > WAITTIME) {
//Done!
motorflag = 0; //Motor off (can now be triggered again)
}
break;
//Static wait cycles
case 6:
if (ReadTimer3() > WAITTIME) {
motorflag = 7;
WriteTimer3(0);
}
break;
case 7:
if (ReadTimer3() > WAITTIME) {
WriteTimer3(0);
motorflag = 8;
}
break;
case 8:
if (ReadTimer3() > WAITTIME) {
motorflag = 0;
}
break;
}

Delayms(10);
}
return 0;
}//end main

Write chip function, which is a support function that writes data to the music chips.
/* write_chip: This writes the given byte "data" to the "address" (0 or 1)
on a YMZ284. It is assumed that the chip select is already low */
void write_chip(int address,int data) {
//Write address
portout(address);
A0 = 0; //select address mode
Delayus(1); //setup time
NWR = 0; //Write cycle begin
Delayus(1); //hold time
NWR = 1; //Write cycle end

//Write data
portout(data);
A0 = 1; //select data mode
Delayus(1); //setup time
NWR = 0; //write cycle begin
Delayus(1); //hold time
NWR = 1; //write cycle end
}
Port out function
/* port_out: This function outputs a byte to the D0-D7 port */
void portout(int byte) {
// Note: !! converts an integer expression to a boolean (1 or 0).
D0 = !!(byte & 1);
D1 = !!(byte & 2);
D2 = !!(byte & 4);
D3 = !!(byte & 8);
D4 = !!(byte & 16);
D5 = !!(byte & 32);
D6 = !!(byte & 64);
D7 = !!(byte & 128);
}
Channel switch function, which writes a new mixer value to turn a channel on or off.
/* channelSw: Generic channel switch function
This writes a new mixer value to chip "chip". The mixer value
depends on "chn", the channel turning on or off, "state" whether
the channel is turning on or off, and "*mixer", a pointer to
the old mixer value. */
void channelSw(int chip, int chn, int *mixer, int state) {
/* Enable music chip */
switch(chip) {
case 1: CS1 = 0; break;
case 2: CS2 = 0; break;
case 3: CS3 = 0; break;
case 4: CS4 = 0; break;
}
/* Write mixer value */
/* This writes to channel 7 (mixer channel) the _new_ mixer value, which is
the old mixer value with a particular bit flipped based on "chn" and "state" */
write_chip(0x07, (*mixer) = state ? (*mixer) & (0xFF & ~chn) : (*mixer) | chn);
/* Disable chip */
switch(chip) {
case 1: CS1 = 1; break;
case 2: CS2 = 1; break;
case 3: CS3 = 1; break;
case 4: CS4 = 1; break;
}

}
Interrupt functions
//External interrupt for motor driving
void __ISR(_EXTERNAL_3_VECTOR, ipl6) _SingleVectorHandler(void) {
if (motorflag == 0) {
motorflag = 1; //Start motor cycle
}
//If on already, do nothing
mINT3ClearIntFlag();
}

//External interrupt for motor waiting
void __ISR(_EXTERNAL_4_VECTOR, ipl5) _SingleVectorHandler2(void) {
if (motorflag == 0) {
WriteTimer3(0);
motorflag = 6; //Start wait cycle
}
//If on already, do nothing
mINT4ClearIntFlag();
}

=Results=

The project turned out to be a mild success overall. The tilt switches worked very well for activating the music tones, but the heart rate monitor was less successful. One of the biggest issues was getting rid of very low frequency drift in the signal that made the peaks sometimes as high as 10V, but other times less 1V. Dealing with this fluctuation in peak size was the most difficult part of signal processing. As mentioned above, we tried FFT in order to establish a steady heart rate, but could not get the resolution we desired, thus we abandoned the idea.

'''PROBABLY NEED MORE TECHNICAL RESULTS HERE, BUT I'M NOT SURE WHAT TO SAY RIGHT NOW'''

The best result was that using the device was just plain fun. We each had a great time moving around and hearing the fun sounds that resulted, or if we were feeling ambitious, we would try to play a simple melody like "Mary Had a Little Lamb." It was rather difficult to play anything more complicated than that because it required lots of body control and precise movements.

=Reflections=

'''Successes'''
*tilt switches activated each of the six notes when they were supposed to
**the YMZ284 chips were able to produce all six notes at the same time, allowing cool chords
*tones were in tune and formed fun melodies and chords as the body moved
*drum actuator hit the drum reliably and with good tone
*heart rate monitor usually showed clear peaks on a scope, but was finnicky in practice

'''Room for improvements'''
*tilt switches sometimes bounced, so the beginning, or particularly the ends of the notes sounded jagged
**''Possible Solution:'' add a low pass filter to the switch signal so that the signal ramps up and down.
*the shoulder straps sometimes needed adjustments for each individual in order for the sensors to be in the correct position
**''Possible Solution:'' create straps with more constraints, such as a strap across the chest as well as the back, to ensure that the sensors are in the correct positions and orientations.
*the straps could be easier to put on
**''Possible Solution:'' maybe integrate them into a single garment, like a onesie
*the heart rate monitor was not reliable. Low frequency drift made setting a comparison level nearly impossible, especially for more than one specific user.
**''Possible Solution:'' improve FFT method so that desired resolution could be achieved in a short sample period (around 10 seconds). Or implement a complicated peak detection algorithm on the PIC.

'''JAMES SHOULD ADD SOME KIND OF HEARTWARMING CONCLUSION CUZ HE'S GOOD AT THAT STUFF'''

Music from the Heart -- Music Suit

2010-03-17T06:09:47Z

EricWest: /* Heart rate monitor - Mechanical Design */

=Introduction=

This project attempted to create a natural form of musical expression by connecting sensors to the body. Six tilt switches were attached to the wrist, ankles, and shoulders, each controlling a single pitch from the [http://en.wikipedia.org/wiki/Pentatonic_scale pentatonic scale]. The heart beat was obtained using [http://en.wikipedia.org/wiki/Photoplethysmograph photoplethysmography] on the user's finger, and this signal was used to strike a drum in sync with the heart beat.

==Team Members==

*Thomas Peterson (Computer Engineering, 2010)
*James Rein (Biomedical Engineering and Music Cognition, 2010)
*Eric West (Mechanical Engineering, 2011)

'''INSERT TEAM PICTURE HERE'''

=Subsystems=

Although intended as a single, cohesive system that would allow the user to intuitively make music, the project was easily divided into three subsystems: heart rate monitor, drum actuation, and music tones. Below is more explanation about each subsystem.

==Heart rate monitor - Concepts==

In brainstorming how to translate a heart beat into a drum beat, we decided that the least intrusive method would be the best. Attaching electrodes to the user would simplify the process of identifying a heart beat, but attaching the sensors directly to the skin would be a time-consuming and personally-invasive process. Instead, we decided a finger tip sensor would be much more comfortable and easy to use.

To make a finger tip sensor, we used the concepts of [http://en.wikipedia.org/wiki/Photoplethysmograph photoplethysmography]. Photoplethysmography is typically used in [http://en.wikipedia.org/wiki/Pulse_oximeter pulse oximeters] and finger-tip sensors in commercially-available devices. We originally tried to hack a heart rate monitor that we had purchased, but this proved difficult, so we decided to make our own.

The basic concept of photoplethysmography is that blood reflects a certain amount of IR light, and the blood density in the finger changes as the heart pumps, so the IR reflectivity of the finger changes as the heart beats. Using an IR emitter-detector pair found in the mechatronics lab followed by lots of amplification and filtering, we were able to obtain a decent signal with peaks when the user's heart beat.

===Heart rate monitor - Electrical Design===

The signal coming directly out of the IR detector was very weak and noisy. To obtain just the information we desired, we ran it through the following filters and amplifiers:

# [[Passive Filters#High-Pass Filter (HPF)|Passive High-Pass Filter]]
# [[Operational Amplifiers (Op-Amps)#Inverting Amplifier|Inverting Amplifier]]: gain = -470
# [http://en.wikipedia.org/wiki/Low-pass_filter#Active_electronic_realization Active Low-pass filter]: cutoff frequency = 4.82Hz, gain = -70
# [http://www.electronics-tutorials.ws/filter/filter_7.html Band-pass filter]: Frequency range = 0.72 to 3.39Hz, inverting gain = -46.8
# [[Comparators|Comparator]]: output to the PIC pin A14, with pull-up resistor to 3.3V and capacitors to smooth out the signal.

The complete signal processing circuit is shown below.

[[Image:Heartrate monitor.PNG|thumb|center|900px|Heart rate monitor circuit diagram. Click for larger image.]]

===Heart rate monitor - Mechanical Design===

The sensor itself was a QRB1114 emitter-detector pair that was encased in open-cell foam insulation. We inserted it into the foam by drilling and filing a hole in the foam to the appropriate size, and gluing the sensor in place. A round, finger-shaped groove was filed into the foam and the sensor sat flush with the bottom of this groove. The user's finger was held in the correct position with relatively constant pressure using a latex band around the finger and the foam enclosure.
[[Image:Heart rate sensor mfth.JPG|thumb|200px|Heart rate sensor with the latex band pulled away so that the emitter-detector is revealed]]

==Drum actuator - Electrical design==

Once the signal from the heart rate sensor is sent to the PIC, the rising edge triggers an interrupt which starts the driving sequence for the motor that strikes the drum. The drive sequence was: drive down (into drum) 100ms, drive up 75ms, wait 150ms. The interrupt does not do the entire driving sequence, it merely flags a variable to start the sequence, which is done in the main loop, as seen in the code below.

An additional interrupt was triggered by the falling edge of the signal; this falling edge interrupt added additional wait time that prevented the PIC from being "fooled" by a noisy falling edge. For instance, if the falling signal had some noise in it, the rising edge interrupt would be triggered again, thus causing the drum to strike on both the rising and falling edges of the heartbeat. We only wanted one strike per heartbeat, so the falling edge interrupt was triggered by the ''first'' falling edge, and any noise in the falling edge was ignored because the PIC was told to wait for 300ms. With a maximum delay of 150 + 300 = 450ms from the two interrupts, the fastest heartbeat our drum could play was 133 beats per minute, but we did not expect anyone to come play the instrument after running, so this was plenty high for our purposes.

Initially, we tried skipping the comparator and sending the analog signal directly into one of the PICs analog inputs. Our intention was to use the fast Fourier transform (FFT) library to try to extract the dominant frequency. Unfortunately, we ran into various problems. First, to get the accuracy we wanted for small frequencies, the sample window had to be very long (10 seconds or more), which made the output lag changes in heart rate. Additionally, the FFT was often "messy", which messed up our original algorithm of detecting the peak frequency between .5 and 2.5 hz. The system would sometimes randomly switch between very different frequencies, and although it was right most of the time it was enough to make the drum beating sound bad. We also tried algorithms to find the [http://en.wikipedia.org/wiki/Fundamental_frequency fundamental frequency] using the entire FFT (instead of just the .5-2.5 hz range), but this was still unreliable. We considered FFT peak detection algorithms, but they seemed to complex for the time and computing power we had available. Because of all this, we went with the simple comparator in the end.

The motor for driving the drumstick was driven by an [[media:L298N.pdf|L298 H-bridge]]. See [[Driving a high current DC Motor using an H-bridge]] for more information on how this works. Our particular circuit diagram is shown below:

[[Image:T21_motorckt_png.PNG|thumb|center|600px|Motor Circuit (non-motor PIC connections not shown). Click for larger image.]]

====Drum actuator - Mechanical Design====

We wanted to use a real drum for our drum beat, so our challenge was to attach a motor and drumstick to a drum. We chose a small rack tom for its resonant tone that is reminiscent of a heart beat.

To attach the drumstick to the motor shaft, we used a small block of acrylic (.5"x.5"x2"). The drumstick was cut down to 8" in length so that it would require less torque from the motor. In one end of the block, a hole was drilled and the drumstick was sanded to the correct diameter in order to snuggly fit into the hole. To ensure that the drumstick could not slide out of the block, a screw was placed in a hole drilled through both the stick and the block. The other end of the block was attached to the motor shaft using a split-clamp method: A hole the size of the motor shaft was drilled through the block, and then a slit was cut from the end of the block to the hole, allowing a screw to tightly clamp the block around the motor.

'''INSERT PICTURE OF DRUMSTICK-MOTORSHAFT ATTACHMENT'''

To attach the motor-stick assembly to the drum, we utilized the tuning screws on the drum. A sheet metal bracket with holes in the appropriate places attached the motor to two of these tuning screws. The bracket was easily made by cutting and bending a piece of 16 gauge steel sheet metal to the appropriate size. Ideally, this part would have been made out of one continuous piece of sheet metal, but we could not find a large enough sheet available in the shop, so we used rivets to connect two smaller pieces together.

After testing the drum striking, we decided it was too loud. To dampen the sound, we taped a piece of foam core and a shop rag to the head of the drum where the stick strikes it.

'''Parts list for drum actuator'''
*Bargain drumstick, at least .5" in diameter
*Small block of acrylic, .5"x.5"x2" (aluminum would work just as well, this is what was available)
*16 gauge steel sheet metal for bracket
*Screws and nuts
*Foam core, shop rag, tape for dampening

==Music Tones - Electrical Design==
The music tones were activated by tilt switches and generated using a [http://pdf1.alldatasheet.com/datasheet-pdf/view/82065/YAMAHA/YMZ284.html YMZ284] chip and were output through a 1/8" jack to a standard set of computer speakers.

Each YMZ284 is capable of producing and mixing any combination of three tones. Since we wanted to have six notes from a [http://en.wikipedia.org/wiki/Pentatonic_scale pentatonic scale], we needed two of these chips and used an [[Operational Amplifiers (Op-Amps)#Summer|summing opamp circuit]] to combine outputs from each chip. We envisioned a possibility of adding [http://en.wikipedia.org/wiki/Overtone overtones] to each note, to make them sound better and more like a real instrument, so we ended up having four YMZ284s attached to our board. When we tried adding an overtone an octave above the fundamental frequency, it ended up sounding harsh and whiny. We decided the tones sounded better with no overtones, so we are only using 2 of the 4 chips on our board.

The YMZ284 communicates with the PIC over an 8-bit databus, plus additional pins for chip select, address, write enable, and reset. All four of our YMZ284s shared all of their pins ''except'' the chip select line; each required their own individual chip select line so that the PIC could specify with which chips it wanted to talk. The circuit diagram below shows how the chips were connected to the PIC and the summing circuit that followed.

[[Image:T21_musicckt_png.PNG|thumb|center|600px|Music circuit diagram. The summing amplifier is not shown. Click for larger image.]]

===Tilt switches - Electrical Design===
In order to detect when the limbs of the user had moved past a certain critical angle, we chose to use tilt switches. We purchased our tilt switches for $2 each from [http://www.goldmine-elec-products.com/prodinfo.asp?number=G16881 Electronics Goldmine]. We chose to use tilt switches instead of an accelerometer because the switches were much cheaper and we figured they would be easier to work with.

The tilt switches we chose are optically-based with an emitter and detector that are selectively blocked by a small ball. When the critical angle is achieved, the tiny ball rolls up a ramp, allowing the emitter to shine directly on the detector, and current flows. When the angle is neutral, the ramp forces the ball to block the light, making current stop flowing through the phototransistor. The "ramp" is really an inverted cone, so the switch can be activated by a change in angle in any direction away from the neutral position. We purchased three different tilt switches to try, each with a different critical angle - 15, 30, and 45 degrees. The configuration we ended up using was:

*30 degrees for shoulders and ankles
*45 degrees for elbows

In hindsight, we would have used all 45-degree switches because they produced the sharpest jump from off to on. The 15-degree switches were practically unusable because they created a large amount of noise as they switched on and off.

We used the tilt switches to provide high-low inputs to the PIC to tell it when to turn on any of the six tones. By attaching these switches to the body such that they are in the neutral position when the body is relaxed, we were able to control the six tones by moving the body in relatively natural ways.

===Tilt switches - Mechanical Design===
The switches were attached to the user's body using adjustable straps and buckles. The wrist and ankle sensors were simply a loop of webbing with an adjustable buckle attached. The straps could be tightened or loosened to fit any size user. To attach the switch to the straps, we created an enclosure for each switch out of high-density foam (left over scraps from DSGN 307). The switch was jammed into a hole in the foam so that it could not easily be moved. The foam was then taped to the straps using electrical tape.

'''INSERT PICTURE OF THE WRIST AND ANKLE STRAPS'''

The shoulder straps were a bit more involved. Two loops with buckles, similar to the wrist and ankle straps, went over the user's shoulder and underneath their armpit. To keep these straps from sliding off the shoulders, a large strap across the user's back connected the two smaller straps together. This large strap was also used for mounting the solder board which gathered the wires from all six tilt switches and sent them to the PIC over one ribbon cable. Using this strap configuration, we found that the user could comfortably and securely wear the sensors.

To attach the switches to the shoulders, we again created a foam encasement. However, electrical tape was not secure enough to hold the foam pieces to the irregularly-shaped shoulder straps. Instead, we riveted a piece of canvas to the webbing straps. We chose to use rivets instead of sewing because the sewing machine could not tightly sew the foam encasement in place. With rivets, we were able to pull the canvas tightly around the foam so that it couldn't move.

'''INSERT PICTURE OF THE SHOULDER STRAPS'''

=Code=
To download the entire C file, click [[Media:Main_music.c|here]]. Below, the file is split into sections for comments.

/**********************************************************
* main_music.c: Main c file for "Music Suit" project
*
* Thomas Peterson, James Rein, Eric West
* ME333 Winter 2010
**********************************************************/

#include <HardwareProfile.h>
#include <delays.c> //Delayms and Delayus functions

The first section defines all the input and output pins, used with the motor, sensor, and music circuits.

////////////////////////////////////////////////////
//Pin Defines

//YMZ Chip selects
#define CS1 LATCbits.LATC2
#define CS2 LATCbits.LATC3
#define CS3 LATCbits.LATC4
#define CS4 LATGbits.LATG6
//YMZ communication pins
#define NWR LATBbits.LATB0 //"Not WRite": active low write line
#define A0 LATBbits.LATB6 //Address 0
#define NIC LATCbits.LATC1 //"Not Input Clear": active low reset line
//YMZ data pins
#define D0 LATGbits.LATG9
#define D1 LATEbits.LATE8
#define D2 LATEbits.LATE9
#define D3 LATBbits.LATB5
#define D4 LATBbits.LATB4
#define D5 LATBbits.LATB3
#define D6 LATBbits.LATB2
#define D7 LATBbits.LATB1

//Tilt inputs
#define ENC PORTDbits.RD3
#define END PORTDbits.RD2
#define ENE PORTDbits.RD1
#define ENG PORTCbits.RC14
#define ENA PORTCbits.RC13
#define ENC5 PORTDbits.RD0

//Motor outputs
#define IN1 LATBbits.LATB7
#define IN2 LATAbits.LATA9
#define EN LATAbits.LATA10

///////////////////////////////////////
//Other defines
//Motor times
#define MS(x) x*312.5
#define DRIVETIME MS(100)
#define BACKTIME MS(75)
#define WAITTIME MS(150)
//Channels
#define CHNA 1
#define CHNB 2
#define CHNC 4

//////////////////////////////////////////
//Function definitions
void write_chip(int address, int data);
void portout(int byte);
void channelSw(int chip, int chn, int *mixer, int state);
//Global variables
int mixer1, mixer2;
int motorflag = 0;
The initialization function sets up various parts of the system.
/* init() : This function runs initializations, setting up the pic and music chips */
void init() {
int pbClk = SYSTEMConfigPerformance(SYS_FREQ);

/////////////////////////////////////////////
//Setup inputs / outputs
AD1PCFG = 0xFFFF; //All digital inputs
TRISG &= 0xFDBF; //sets G9,G6 to 0 (output); all else remains the same
TRISC &= 0xFFE1; //sets C4,C3,C2,C1 to 0s (outputs); all else remains the same
TRISB &= 0xFF80; //sets B0-B6 0 (output)
TRISE &= 0xFCFF; //sets E8,9 to output
TRISB |= 0xF000; //sets B12,B13,B14,B15 to 1s (inputs); all else remains the same
TRISC |= 0x6000; //sets C14,13 to inputs
TRISD |= 0x000F; //Sets D0,D1,D2,D3 to inputs
TRISDbits.TRISD4 = 0; //Output for clock
//Motor outputs
TRISAbits.TRISA9 = 0;
TRISAbits.TRISA10 = 0;
TRISBbits.TRISB7 = 0;
//Pulse inputs
TRISAbits.TRISA14 = 1;
TRISAbits.TRISA15 = 1;
//ODC setup
ODCCbits.ODCC1 = 1; //open drain control; can only float high (when set high) or pull low

/* Initialize outputs */
//YMZs
CS1 = 1;
CS2 = 1;
CS3 = 1;
CS4 = 1;
NWR = 1;
A0 = 0;
NIC = 1;
//Motor
IN2 = 0;
IN1 = 0;
EN = 0;

Delayms(100); //wait for power supply to ramp up
NIC = 0; //resets YMZ284s
Delayms(10);
NIC = 1;

In the init() function, the pic writes all the setup data to the music chips. This includes the frequency registers, which determine the frequency of each output, the mixer, which determines which channels are on or off (1 = off), and the volume registers, which determine the volume of each channel. After the setup, the only register that is changed in normal operation is the mixer register, which merely turns channels on and off.
//////////////////////////////////////////////////
//Setup music chips
//Setup Chip 1//
CS1 = 0;
write_chip(0x00,0xC7); //a low // C4
write_chip(0x01,0x01); //a high
write_chip(0x02,0x98); //b low // D
write_chip(0x03,0x01); //b high
write_chip(0x04,0x6E); //c low
write_chip(0x05,0x01); //c high // E
write_chip(0x07,0xFF); //mixer (0 enables)
write_chip(0x08, 0x0A); //level (volume) A
write_chip(0x09, 0x0A); //level (volume) B
write_chip(0x0A, 0x0A); //level (volume) C
CS1=1;
//Setup Chip 2//
CS2 = 0;
write_chip(0x00,0x2C); //a low //G 392
write_chip(0x01,0x01); //a high
write_chip(0x02,0x0D); //b low //A 440
write_chip(0x03,0x01); //b high
write_chip(0x04,0xE3); //c low //C5 523.25
write_chip(0x05,0x00); //c high
write_chip(0x07,0xFF); //mixer (0 enables)
write_chip(0x08, 0x0A); //level (volume) A
write_chip(0x09, 0x0A); //level (volume) B
write_chip(0x0A, 0x0A); //level (volume) C
CS2=1;

mixer1=0xFF;
mixer2=0xFF;
OC5 is used to create a PWM signal with 50% duty at 4Mhz, in effect creating a 4Mhz square wave. This is used by the music chips as a master clock.
//////////////////////////////////////////////
//Setup OC to create master clock for music chips (~4 Mhz)
OpenOC5( OC_ON | OC_TIMER2_SRC | OC_PWM_FAULT_PIN_DISABLE, 0, 0);
OpenTimer2( T2_ON | T2_PS_1_1 | T2_SOURCE_INT, 20);
SetDCOC5PWM(10);
The interrupts are used, as mentioned above, to control when the motor is driven. The motor should drive once every rising edge.
/////////////////////////////////////////////
//External interrupt setups (for motor) - INT3 (A14)
mINT3ClearIntFlag();
mINT3IntEnable(1);
mINT3SetIntPriority(6);
mINT3SetEdgeMode(1); //Rising edge
/////////////////////////////////////////////
//External interrupt setups (for motor) - INT4 (A15)
mINT4ClearIntFlag();
mINT4IntEnable(1);
mINT4SetIntPriority(5);
mINT4SetEdgeMode(0); //Falling edge
INTEnableSystemMultiVectoredInt();

/////////////////////////////////////////////
//Setup motor timer (used for timing delays)
OpenTimer3(T3_ON | T3_PS_1_256 | T3_SOURCE_INT, 0xFFFF);
ConfigIntTimer3(T3_INT_OFF);
}

Main function
/* Main function */
int main()
{
init(); /* Run initialization functions */
Delayms(1);

/* Main while loop: loop indefinietly */
while (1) {
In the main while loop, the PIC checks every cycle to see if an input has changed since the last cycle. Since the "mixer" variables store the current state, if an input does not match up with its valid mixer bit then it has changed recently. In this case, the channelSw() function is called to switch on or off the music channel controlled by that bit.
//Check for state changes in music notes
if (ENC != (mixer1 & 0x01)) { channelSw(1,CHNA,&mixer1,!ENC); } //If input ENC (enable C) is not equal to the state of channel A1 (note c), change the state
if (END != (mixer1 & 0x02)) { channelSw(1,CHNB,&mixer1,!END); }
if (ENE != (mixer1 & 0x04)) { channelSw(1,CHNC,&mixer1,!ENE); }
if (ENG != (mixer2 & 0x01)) { channelSw(2,CHNA,&mixer2,!ENG); }
if (ENA != (mixer2 & 0x02)) { channelSw(2,CHNB,&mixer2,!ENA); }
if (ENC5 != (mixer2 & 0x04)) { channelSw(2,CHNC,&mixer2,!ENC5); }
During the main while loop, the motor flag variable is checked to see if the motor should be driven. If so, it enters a sequence where it uses timer3 to determine the current stage in the motor cycle, changing the outputs as needed.
//Check for motor state changes
switch (motorflag) {
case 0: break; //Do nothing (motor off)
case 1: //Start motor cycle
WriteTimer3(0); //Reset timer to 0
IN1 = 0; //Set H bridge to forward drive
IN2 = 1;
EN = 1;
motorflag = 2; //In drivedown cycle
break;
case 2: //Drivedown cycle
if (ReadTimer3() > DRIVETIME) { //Wait for DRIVETIME to pass
WriteTimer3(0); //Reset timer to 0
motorflag = 3; //In driveup phase
IN2 = 0; //Switch H bridge
IN1 = 1;
}
break;
case 3: //Driveup cycle
if (ReadTimer3() > BACKTIME) { //Wait for BACKTIME to pass
WriteTimer3(0); //Reset timer to 0
motorflag = 4; //In coast/wait phase
EN = 0; //Turn off motor
}
break;
case 4: //coast / wait cycle
if (ReadTimer3() > WAITTIME) {
motorflag = 5; //more wait
WriteTimer3(0);
}
break;
case 5: //Additional wait cycle
if (ReadTimer3() > WAITTIME) {
//Done!
motorflag = 0; //Motor off (can now be triggered again)
}
break;
//Static wait cycles
case 6:
if (ReadTimer3() > WAITTIME) {
motorflag = 7;
WriteTimer3(0);
}
break;
case 7:
if (ReadTimer3() > WAITTIME) {
WriteTimer3(0);
motorflag = 8;
}
break;
case 8:
if (ReadTimer3() > WAITTIME) {
motorflag = 0;
}
break;
}

Delayms(10);
}
return 0;
}//end main

Write chip function, which is a support function that writes data to the music chips.
/* write_chip: This writes the given byte "data" to the "address" (0 or 1)
on a YMZ284. It is assumed that the chip select is already low */
void write_chip(int address,int data) {
//Write address
portout(address);
A0 = 0; //select address mode
Delayus(1); //setup time
NWR = 0; //Write cycle begin
Delayus(1); //hold time
NWR = 1; //Write cycle end

//Write data
portout(data);
A0 = 1; //select data mode
Delayus(1); //setup time
NWR = 0; //write cycle begin
Delayus(1); //hold time
NWR = 1; //write cycle end
}
Port out function
/* port_out: This function outputs a byte to the D0-D7 port */
void portout(int byte) {
// Note: !! converts an integer expression to a boolean (1 or 0).
D0 = !!(byte & 1);
D1 = !!(byte & 2);
D2 = !!(byte & 4);
D3 = !!(byte & 8);
D4 = !!(byte & 16);
D5 = !!(byte & 32);
D6 = !!(byte & 64);
D7 = !!(byte & 128);
}
Channel switch function, which writes a new mixer value to turn a channel on or off.
/* channelSw: Generic channel switch function
This writes a new mixer value to chip "chip". The mixer value
depends on "chn", the channel turning on or off, "state" whether
the channel is turning on or off, and "*mixer", a pointer to
the old mixer value. */
void channelSw(int chip, int chn, int *mixer, int state) {
/* Enable music chip */
switch(chip) {
case 1: CS1 = 0; break;
case 2: CS2 = 0; break;
case 3: CS3 = 0; break;
case 4: CS4 = 0; break;
}
/* Write mixer value */
/* This writes to channel 7 (mixer channel) the _new_ mixer value, which is
the old mixer value with a particular bit flipped based on "chn" and "state" */
write_chip(0x07, (*mixer) = state ? (*mixer) & (0xFF & ~chn) : (*mixer) | chn);
/* Disable chip */
switch(chip) {
case 1: CS1 = 1; break;
case 2: CS2 = 1; break;
case 3: CS3 = 1; break;
case 4: CS4 = 1; break;
}

}
Interrupt functions
//External interrupt for motor driving
void __ISR(_EXTERNAL_3_VECTOR, ipl6) _SingleVectorHandler(void) {
if (motorflag == 0) {
motorflag = 1; //Start motor cycle
}
//If on already, do nothing
mINT3ClearIntFlag();
}

//External interrupt for motor waiting
void __ISR(_EXTERNAL_4_VECTOR, ipl5) _SingleVectorHandler2(void) {
if (motorflag == 0) {
WriteTimer3(0);
motorflag = 6; //Start wait cycle
}
//If on already, do nothing
mINT4ClearIntFlag();
}

=Results=

The project turned out to be a mild success overall. The tilt switches worked very well for activating the music tones, but the heart rate monitor was less successful. One of the biggest issues was getting rid of very low frequency drift in the signal that made the peaks sometimes as high as 10V, but other times less 1V. Dealing with this fluctuation in peak size was the most difficult part of signal processing. As mentioned above, we tried FFT in order to establish a steady heart rate, but could not get the resolution we desired, thus we abandoned the idea.

'''PROBABLY NEED MORE TECHNICAL RESULTS HERE, BUT I'M NOT SURE WHAT TO SAY RIGHT NOW'''

The best result was that using the device was just plain fun. We each had a great time moving around and hearing the fun sounds that resulted, or if we were feeling ambitious, we would try to play a simple melody like "Mary Had a Little Lamb." It was rather difficult to play anything more complicated than that because it required lots of body control and precise movements.

=Reflections=

'''Successes'''
*tilt switches activated each of the six notes when they were supposed to
**the YMZ284 chips were able to produce all six notes at the same time, allowing cool chords
*tones were in tune and formed fun melodies and chords as the body moved
*drum actuator hit the drum reliably and with good tone
*heart rate monitor usually showed clear peaks on a scope, but was finnicky in practice

'''Room for improvements'''
*tilt switches sometimes bounced, so the beginning, or particularly the ends of the notes sounded jagged
**''Possible Solution:'' add a low pass filter to the switch signal so that the signal ramps up and down.
*the shoulder straps sometimes needed adjustments for each individual in order for the sensors to be in the correct position
**''Possible Solution:'' create straps with more constraints, such as a strap across the chest as well as the back, to ensure that the sensors are in the correct positions and orientations.
*the straps could be easier to put on
**''Possible Solution:'' maybe integrate them into a single garment, like a onesie
*the heart rate monitor was not reliable. Low frequency drift made setting a comparison level nearly impossible, especially for more than one specific user.
**''Possible Solution:'' improve FFT method so that desired resolution could be achieved in a short sample period (around 10 seconds). Or implement a complicated peak detection algorithm on the PIC.

'''JAMES SHOULD ADD SOME KIND OF HEARTWARMING CONCLUSION CUZ HE'S GOOD AT THAT STUFF'''

Music from the Heart -- Music Suit

2010-03-17T06:09:26Z

EricWest: /* Heart rate monitor - Mechanical Design */

=Introduction=

This project attempted to create a natural form of musical expression by connecting sensors to the body. Six tilt switches were attached to the wrist, ankles, and shoulders, each controlling a single pitch from the [http://en.wikipedia.org/wiki/Pentatonic_scale pentatonic scale]. The heart beat was obtained using [http://en.wikipedia.org/wiki/Photoplethysmograph photoplethysmography] on the user's finger, and this signal was used to strike a drum in sync with the heart beat.

==Team Members==

*Thomas Peterson (Computer Engineering, 2010)
*James Rein (Biomedical Engineering and Music Cognition, 2010)
*Eric West (Mechanical Engineering, 2011)

'''INSERT TEAM PICTURE HERE'''

=Subsystems=

Although intended as a single, cohesive system that would allow the user to intuitively make music, the project was easily divided into three subsystems: heart rate monitor, drum actuation, and music tones. Below is more explanation about each subsystem.

==Heart rate monitor - Concepts==

In brainstorming how to translate a heart beat into a drum beat, we decided that the least intrusive method would be the best. Attaching electrodes to the user would simplify the process of identifying a heart beat, but attaching the sensors directly to the skin would be a time-consuming and personally-invasive process. Instead, we decided a finger tip sensor would be much more comfortable and easy to use.

To make a finger tip sensor, we used the concepts of [http://en.wikipedia.org/wiki/Photoplethysmograph photoplethysmography]. Photoplethysmography is typically used in [http://en.wikipedia.org/wiki/Pulse_oximeter pulse oximeters] and finger-tip sensors in commercially-available devices. We originally tried to hack a heart rate monitor that we had purchased, but this proved difficult, so we decided to make our own.

The basic concept of photoplethysmography is that blood reflects a certain amount of IR light, and the blood density in the finger changes as the heart pumps, so the IR reflectivity of the finger changes as the heart beats. Using an IR emitter-detector pair found in the mechatronics lab followed by lots of amplification and filtering, we were able to obtain a decent signal with peaks when the user's heart beat.

===Heart rate monitor - Electrical Design===

The signal coming directly out of the IR detector was very weak and noisy. To obtain just the information we desired, we ran it through the following filters and amplifiers:

# [[Passive Filters#High-Pass Filter (HPF)|Passive High-Pass Filter]]
# [[Operational Amplifiers (Op-Amps)#Inverting Amplifier|Inverting Amplifier]]: gain = -470
# [http://en.wikipedia.org/wiki/Low-pass_filter#Active_electronic_realization Active Low-pass filter]: cutoff frequency = 4.82Hz, gain = -70
# [http://www.electronics-tutorials.ws/filter/filter_7.html Band-pass filter]: Frequency range = 0.72 to 3.39Hz, inverting gain = -46.8
# [[Comparators|Comparator]]: output to the PIC pin A14, with pull-up resistor to 3.3V and capacitors to smooth out the signal.

The complete signal processing circuit is shown below.

[[Image:Heartrate monitor.PNG|thumb|center|900px|Heart rate monitor circuit diagram. Click for larger image.]]

===Heart rate monitor - Mechanical Design===

The sensor itself was a QRB1114 emitter-detector pair that was encased in open-cell foam insulation. We inserted it into the foam by drilling and filing a hole in the foam to the appropriate size, and gluing the sensor in place. A round, finger-shaped groove was filed into the foam and the sensor sat flush with the bottom of this groove. The user's finger was held in the correct position with relatively constant pressure using a latex band around the finger and the foam enclosure.

[[Image:Heart rate sensor mfth.JPG|thumb|200px|Heart rate sensor with the latex band pulled away so that the emitter-detector is revealed]]

==Drum actuator - Electrical design==

Once the signal from the heart rate sensor is sent to the PIC, the rising edge triggers an interrupt which starts the driving sequence for the motor that strikes the drum. The drive sequence was: drive down (into drum) 100ms, drive up 75ms, wait 150ms. The interrupt does not do the entire driving sequence, it merely flags a variable to start the sequence, which is done in the main loop, as seen in the code below.

An additional interrupt was triggered by the falling edge of the signal; this falling edge interrupt added additional wait time that prevented the PIC from being "fooled" by a noisy falling edge. For instance, if the falling signal had some noise in it, the rising edge interrupt would be triggered again, thus causing the drum to strike on both the rising and falling edges of the heartbeat. We only wanted one strike per heartbeat, so the falling edge interrupt was triggered by the ''first'' falling edge, and any noise in the falling edge was ignored because the PIC was told to wait for 300ms. With a maximum delay of 150 + 300 = 450ms from the two interrupts, the fastest heartbeat our drum could play was 133 beats per minute, but we did not expect anyone to come play the instrument after running, so this was plenty high for our purposes.

Initially, we tried skipping the comparator and sending the analog signal directly into one of the PICs analog inputs. Our intention was to use the fast Fourier transform (FFT) library to try to extract the dominant frequency. Unfortunately, we ran into various problems. First, to get the accuracy we wanted for small frequencies, the sample window had to be very long (10 seconds or more), which made the output lag changes in heart rate. Additionally, the FFT was often "messy", which messed up our original algorithm of detecting the peak frequency between .5 and 2.5 hz. The system would sometimes randomly switch between very different frequencies, and although it was right most of the time it was enough to make the drum beating sound bad. We also tried algorithms to find the [http://en.wikipedia.org/wiki/Fundamental_frequency fundamental frequency] using the entire FFT (instead of just the .5-2.5 hz range), but this was still unreliable. We considered FFT peak detection algorithms, but they seemed to complex for the time and computing power we had available. Because of all this, we went with the simple comparator in the end.

The motor for driving the drumstick was driven by an [[media:L298N.pdf|L298 H-bridge]]. See [[Driving a high current DC Motor using an H-bridge]] for more information on how this works. Our particular circuit diagram is shown below:

[[Image:T21_motorckt_png.PNG|thumb|center|600px|Motor Circuit (non-motor PIC connections not shown). Click for larger image.]]

====Drum actuator - Mechanical Design====

We wanted to use a real drum for our drum beat, so our challenge was to attach a motor and drumstick to a drum. We chose a small rack tom for its resonant tone that is reminiscent of a heart beat.

To attach the drumstick to the motor shaft, we used a small block of acrylic (.5"x.5"x2"). The drumstick was cut down to 8" in length so that it would require less torque from the motor. In one end of the block, a hole was drilled and the drumstick was sanded to the correct diameter in order to snuggly fit into the hole. To ensure that the drumstick could not slide out of the block, a screw was placed in a hole drilled through both the stick and the block. The other end of the block was attached to the motor shaft using a split-clamp method: A hole the size of the motor shaft was drilled through the block, and then a slit was cut from the end of the block to the hole, allowing a screw to tightly clamp the block around the motor.

'''INSERT PICTURE OF DRUMSTICK-MOTORSHAFT ATTACHMENT'''

To attach the motor-stick assembly to the drum, we utilized the tuning screws on the drum. A sheet metal bracket with holes in the appropriate places attached the motor to two of these tuning screws. The bracket was easily made by cutting and bending a piece of 16 gauge steel sheet metal to the appropriate size. Ideally, this part would have been made out of one continuous piece of sheet metal, but we could not find a large enough sheet available in the shop, so we used rivets to connect two smaller pieces together.

After testing the drum striking, we decided it was too loud. To dampen the sound, we taped a piece of foam core and a shop rag to the head of the drum where the stick strikes it.

'''Parts list for drum actuator'''
*Bargain drumstick, at least .5" in diameter
*Small block of acrylic, .5"x.5"x2" (aluminum would work just as well, this is what was available)
*16 gauge steel sheet metal for bracket
*Screws and nuts
*Foam core, shop rag, tape for dampening

==Music Tones - Electrical Design==
The music tones were activated by tilt switches and generated using a [http://pdf1.alldatasheet.com/datasheet-pdf/view/82065/YAMAHA/YMZ284.html YMZ284] chip and were output through a 1/8" jack to a standard set of computer speakers.

Each YMZ284 is capable of producing and mixing any combination of three tones. Since we wanted to have six notes from a [http://en.wikipedia.org/wiki/Pentatonic_scale pentatonic scale], we needed two of these chips and used an [[Operational Amplifiers (Op-Amps)#Summer|summing opamp circuit]] to combine outputs from each chip. We envisioned a possibility of adding [http://en.wikipedia.org/wiki/Overtone overtones] to each note, to make them sound better and more like a real instrument, so we ended up having four YMZ284s attached to our board. When we tried adding an overtone an octave above the fundamental frequency, it ended up sounding harsh and whiny. We decided the tones sounded better with no overtones, so we are only using 2 of the 4 chips on our board.

The YMZ284 communicates with the PIC over an 8-bit databus, plus additional pins for chip select, address, write enable, and reset. All four of our YMZ284s shared all of their pins ''except'' the chip select line; each required their own individual chip select line so that the PIC could specify with which chips it wanted to talk. The circuit diagram below shows how the chips were connected to the PIC and the summing circuit that followed.

[[Image:T21_musicckt_png.PNG|thumb|center|600px|Music circuit diagram. The summing amplifier is not shown. Click for larger image.]]

===Tilt switches - Electrical Design===
In order to detect when the limbs of the user had moved past a certain critical angle, we chose to use tilt switches. We purchased our tilt switches for $2 each from [http://www.goldmine-elec-products.com/prodinfo.asp?number=G16881 Electronics Goldmine]. We chose to use tilt switches instead of an accelerometer because the switches were much cheaper and we figured they would be easier to work with.

The tilt switches we chose are optically-based with an emitter and detector that are selectively blocked by a small ball. When the critical angle is achieved, the tiny ball rolls up a ramp, allowing the emitter to shine directly on the detector, and current flows. When the angle is neutral, the ramp forces the ball to block the light, making current stop flowing through the phototransistor. The "ramp" is really an inverted cone, so the switch can be activated by a change in angle in any direction away from the neutral position. We purchased three different tilt switches to try, each with a different critical angle - 15, 30, and 45 degrees. The configuration we ended up using was:

*30 degrees for shoulders and ankles
*45 degrees for elbows

In hindsight, we would have used all 45-degree switches because they produced the sharpest jump from off to on. The 15-degree switches were practically unusable because they created a large amount of noise as they switched on and off.

We used the tilt switches to provide high-low inputs to the PIC to tell it when to turn on any of the six tones. By attaching these switches to the body such that they are in the neutral position when the body is relaxed, we were able to control the six tones by moving the body in relatively natural ways.

===Tilt switches - Mechanical Design===
The switches were attached to the user's body using adjustable straps and buckles. The wrist and ankle sensors were simply a loop of webbing with an adjustable buckle attached. The straps could be tightened or loosened to fit any size user. To attach the switch to the straps, we created an enclosure for each switch out of high-density foam (left over scraps from DSGN 307). The switch was jammed into a hole in the foam so that it could not easily be moved. The foam was then taped to the straps using electrical tape.

'''INSERT PICTURE OF THE WRIST AND ANKLE STRAPS'''

The shoulder straps were a bit more involved. Two loops with buckles, similar to the wrist and ankle straps, went over the user's shoulder and underneath their armpit. To keep these straps from sliding off the shoulders, a large strap across the user's back connected the two smaller straps together. This large strap was also used for mounting the solder board which gathered the wires from all six tilt switches and sent them to the PIC over one ribbon cable. Using this strap configuration, we found that the user could comfortably and securely wear the sensors.

To attach the switches to the shoulders, we again created a foam encasement. However, electrical tape was not secure enough to hold the foam pieces to the irregularly-shaped shoulder straps. Instead, we riveted a piece of canvas to the webbing straps. We chose to use rivets instead of sewing because the sewing machine could not tightly sew the foam encasement in place. With rivets, we were able to pull the canvas tightly around the foam so that it couldn't move.

'''INSERT PICTURE OF THE SHOULDER STRAPS'''

=Code=
To download the entire C file, click [[Media:Main_music.c|here]]. Below, the file is split into sections for comments.

/**********************************************************
* main_music.c: Main c file for "Music Suit" project
*
* Thomas Peterson, James Rein, Eric West
* ME333 Winter 2010
**********************************************************/

#include <HardwareProfile.h>
#include <delays.c> //Delayms and Delayus functions

The first section defines all the input and output pins, used with the motor, sensor, and music circuits.

////////////////////////////////////////////////////
//Pin Defines

//YMZ Chip selects
#define CS1 LATCbits.LATC2
#define CS2 LATCbits.LATC3
#define CS3 LATCbits.LATC4
#define CS4 LATGbits.LATG6
//YMZ communication pins
#define NWR LATBbits.LATB0 //"Not WRite": active low write line
#define A0 LATBbits.LATB6 //Address 0
#define NIC LATCbits.LATC1 //"Not Input Clear": active low reset line
//YMZ data pins
#define D0 LATGbits.LATG9
#define D1 LATEbits.LATE8
#define D2 LATEbits.LATE9
#define D3 LATBbits.LATB5
#define D4 LATBbits.LATB4
#define D5 LATBbits.LATB3
#define D6 LATBbits.LATB2
#define D7 LATBbits.LATB1

//Tilt inputs
#define ENC PORTDbits.RD3
#define END PORTDbits.RD2
#define ENE PORTDbits.RD1
#define ENG PORTCbits.RC14
#define ENA PORTCbits.RC13
#define ENC5 PORTDbits.RD0

//Motor outputs
#define IN1 LATBbits.LATB7
#define IN2 LATAbits.LATA9
#define EN LATAbits.LATA10

///////////////////////////////////////
//Other defines
//Motor times
#define MS(x) x*312.5
#define DRIVETIME MS(100)
#define BACKTIME MS(75)
#define WAITTIME MS(150)
//Channels
#define CHNA 1
#define CHNB 2
#define CHNC 4

//////////////////////////////////////////
//Function definitions
void write_chip(int address, int data);
void portout(int byte);
void channelSw(int chip, int chn, int *mixer, int state);
//Global variables
int mixer1, mixer2;
int motorflag = 0;
The initialization function sets up various parts of the system.
/* init() : This function runs initializations, setting up the pic and music chips */
void init() {
int pbClk = SYSTEMConfigPerformance(SYS_FREQ);

/////////////////////////////////////////////
//Setup inputs / outputs
AD1PCFG = 0xFFFF; //All digital inputs
TRISG &= 0xFDBF; //sets G9,G6 to 0 (output); all else remains the same
TRISC &= 0xFFE1; //sets C4,C3,C2,C1 to 0s (outputs); all else remains the same
TRISB &= 0xFF80; //sets B0-B6 0 (output)
TRISE &= 0xFCFF; //sets E8,9 to output
TRISB |= 0xF000; //sets B12,B13,B14,B15 to 1s (inputs); all else remains the same
TRISC |= 0x6000; //sets C14,13 to inputs
TRISD |= 0x000F; //Sets D0,D1,D2,D3 to inputs
TRISDbits.TRISD4 = 0; //Output for clock
//Motor outputs
TRISAbits.TRISA9 = 0;
TRISAbits.TRISA10 = 0;
TRISBbits.TRISB7 = 0;
//Pulse inputs
TRISAbits.TRISA14 = 1;
TRISAbits.TRISA15 = 1;
//ODC setup
ODCCbits.ODCC1 = 1; //open drain control; can only float high (when set high) or pull low

/* Initialize outputs */
//YMZs
CS1 = 1;
CS2 = 1;
CS3 = 1;
CS4 = 1;
NWR = 1;
A0 = 0;
NIC = 1;
//Motor
IN2 = 0;
IN1 = 0;
EN = 0;

Delayms(100); //wait for power supply to ramp up
NIC = 0; //resets YMZ284s
Delayms(10);
NIC = 1;

In the init() function, the pic writes all the setup data to the music chips. This includes the frequency registers, which determine the frequency of each output, the mixer, which determines which channels are on or off (1 = off), and the volume registers, which determine the volume of each channel. After the setup, the only register that is changed in normal operation is the mixer register, which merely turns channels on and off.
//////////////////////////////////////////////////
//Setup music chips
//Setup Chip 1//
CS1 = 0;
write_chip(0x00,0xC7); //a low // C4
write_chip(0x01,0x01); //a high
write_chip(0x02,0x98); //b low // D
write_chip(0x03,0x01); //b high
write_chip(0x04,0x6E); //c low
write_chip(0x05,0x01); //c high // E
write_chip(0x07,0xFF); //mixer (0 enables)
write_chip(0x08, 0x0A); //level (volume) A
write_chip(0x09, 0x0A); //level (volume) B
write_chip(0x0A, 0x0A); //level (volume) C
CS1=1;
//Setup Chip 2//
CS2 = 0;
write_chip(0x00,0x2C); //a low //G 392
write_chip(0x01,0x01); //a high
write_chip(0x02,0x0D); //b low //A 440
write_chip(0x03,0x01); //b high
write_chip(0x04,0xE3); //c low //C5 523.25
write_chip(0x05,0x00); //c high
write_chip(0x07,0xFF); //mixer (0 enables)
write_chip(0x08, 0x0A); //level (volume) A
write_chip(0x09, 0x0A); //level (volume) B
write_chip(0x0A, 0x0A); //level (volume) C
CS2=1;

mixer1=0xFF;
mixer2=0xFF;
OC5 is used to create a PWM signal with 50% duty at 4Mhz, in effect creating a 4Mhz square wave. This is used by the music chips as a master clock.
//////////////////////////////////////////////
//Setup OC to create master clock for music chips (~4 Mhz)
OpenOC5( OC_ON | OC_TIMER2_SRC | OC_PWM_FAULT_PIN_DISABLE, 0, 0);
OpenTimer2( T2_ON | T2_PS_1_1 | T2_SOURCE_INT, 20);
SetDCOC5PWM(10);
The interrupts are used, as mentioned above, to control when the motor is driven. The motor should drive once every rising edge.
/////////////////////////////////////////////
//External interrupt setups (for motor) - INT3 (A14)
mINT3ClearIntFlag();
mINT3IntEnable(1);
mINT3SetIntPriority(6);
mINT3SetEdgeMode(1); //Rising edge
/////////////////////////////////////////////
//External interrupt setups (for motor) - INT4 (A15)
mINT4ClearIntFlag();
mINT4IntEnable(1);
mINT4SetIntPriority(5);
mINT4SetEdgeMode(0); //Falling edge
INTEnableSystemMultiVectoredInt();

/////////////////////////////////////////////
//Setup motor timer (used for timing delays)
OpenTimer3(T3_ON | T3_PS_1_256 | T3_SOURCE_INT, 0xFFFF);
ConfigIntTimer3(T3_INT_OFF);
}

Main function
/* Main function */
int main()
{
init(); /* Run initialization functions */
Delayms(1);

/* Main while loop: loop indefinietly */
while (1) {
In the main while loop, the PIC checks every cycle to see if an input has changed since the last cycle. Since the "mixer" variables store the current state, if an input does not match up with its valid mixer bit then it has changed recently. In this case, the channelSw() function is called to switch on or off the music channel controlled by that bit.
//Check for state changes in music notes
if (ENC != (mixer1 & 0x01)) { channelSw(1,CHNA,&mixer1,!ENC); } //If input ENC (enable C) is not equal to the state of channel A1 (note c), change the state
if (END != (mixer1 & 0x02)) { channelSw(1,CHNB,&mixer1,!END); }
if (ENE != (mixer1 & 0x04)) { channelSw(1,CHNC,&mixer1,!ENE); }
if (ENG != (mixer2 & 0x01)) { channelSw(2,CHNA,&mixer2,!ENG); }
if (ENA != (mixer2 & 0x02)) { channelSw(2,CHNB,&mixer2,!ENA); }
if (ENC5 != (mixer2 & 0x04)) { channelSw(2,CHNC,&mixer2,!ENC5); }
During the main while loop, the motor flag variable is checked to see if the motor should be driven. If so, it enters a sequence where it uses timer3 to determine the current stage in the motor cycle, changing the outputs as needed.
//Check for motor state changes
switch (motorflag) {
case 0: break; //Do nothing (motor off)
case 1: //Start motor cycle
WriteTimer3(0); //Reset timer to 0
IN1 = 0; //Set H bridge to forward drive
IN2 = 1;
EN = 1;
motorflag = 2; //In drivedown cycle
break;
case 2: //Drivedown cycle
if (ReadTimer3() > DRIVETIME) { //Wait for DRIVETIME to pass
WriteTimer3(0); //Reset timer to 0
motorflag = 3; //In driveup phase
IN2 = 0; //Switch H bridge
IN1 = 1;
}
break;
case 3: //Driveup cycle
if (ReadTimer3() > BACKTIME) { //Wait for BACKTIME to pass
WriteTimer3(0); //Reset timer to 0
motorflag = 4; //In coast/wait phase
EN = 0; //Turn off motor
}
break;
case 4: //coast / wait cycle
if (ReadTimer3() > WAITTIME) {
motorflag = 5; //more wait
WriteTimer3(0);
}
break;
case 5: //Additional wait cycle
if (ReadTimer3() > WAITTIME) {
//Done!
motorflag = 0; //Motor off (can now be triggered again)
}
break;
//Static wait cycles
case 6:
if (ReadTimer3() > WAITTIME) {
motorflag = 7;
WriteTimer3(0);
}
break;
case 7:
if (ReadTimer3() > WAITTIME) {
WriteTimer3(0);
motorflag = 8;
}
break;
case 8:
if (ReadTimer3() > WAITTIME) {
motorflag = 0;
}
break;
}

Delayms(10);
}
return 0;
}//end main

Write chip function, which is a support function that writes data to the music chips.
/* write_chip: This writes the given byte "data" to the "address" (0 or 1)
on a YMZ284. It is assumed that the chip select is already low */
void write_chip(int address,int data) {
//Write address
portout(address);
A0 = 0; //select address mode
Delayus(1); //setup time
NWR = 0; //Write cycle begin
Delayus(1); //hold time
NWR = 1; //Write cycle end

//Write data
portout(data);
A0 = 1; //select data mode
Delayus(1); //setup time
NWR = 0; //write cycle begin
Delayus(1); //hold time
NWR = 1; //write cycle end
}
Port out function
/* port_out: This function outputs a byte to the D0-D7 port */
void portout(int byte) {
// Note: !! converts an integer expression to a boolean (1 or 0).
D0 = !!(byte & 1);
D1 = !!(byte & 2);
D2 = !!(byte & 4);
D3 = !!(byte & 8);
D4 = !!(byte & 16);
D5 = !!(byte & 32);
D6 = !!(byte & 64);
D7 = !!(byte & 128);
}
Channel switch function, which writes a new mixer value to turn a channel on or off.
/* channelSw: Generic channel switch function
This writes a new mixer value to chip "chip". The mixer value
depends on "chn", the channel turning on or off, "state" whether
the channel is turning on or off, and "*mixer", a pointer to
the old mixer value. */
void channelSw(int chip, int chn, int *mixer, int state) {
/* Enable music chip */
switch(chip) {
case 1: CS1 = 0; break;
case 2: CS2 = 0; break;
case 3: CS3 = 0; break;
case 4: CS4 = 0; break;
}
/* Write mixer value */
/* This writes to channel 7 (mixer channel) the _new_ mixer value, which is
the old mixer value with a particular bit flipped based on "chn" and "state" */
write_chip(0x07, (*mixer) = state ? (*mixer) & (0xFF & ~chn) : (*mixer) | chn);
/* Disable chip */
switch(chip) {
case 1: CS1 = 1; break;
case 2: CS2 = 1; break;
case 3: CS3 = 1; break;
case 4: CS4 = 1; break;
}

}
Interrupt functions
//External interrupt for motor driving
void __ISR(_EXTERNAL_3_VECTOR, ipl6) _SingleVectorHandler(void) {
if (motorflag == 0) {
motorflag = 1; //Start motor cycle
}
//If on already, do nothing
mINT3ClearIntFlag();
}

//External interrupt for motor waiting
void __ISR(_EXTERNAL_4_VECTOR, ipl5) _SingleVectorHandler2(void) {
if (motorflag == 0) {
WriteTimer3(0);
motorflag = 6; //Start wait cycle
}
//If on already, do nothing
mINT4ClearIntFlag();
}

=Results=

The project turned out to be a mild success overall. The tilt switches worked very well for activating the music tones, but the heart rate monitor was less successful. One of the biggest issues was getting rid of very low frequency drift in the signal that made the peaks sometimes as high as 10V, but other times less 1V. Dealing with this fluctuation in peak size was the most difficult part of signal processing. As mentioned above, we tried FFT in order to establish a steady heart rate, but could not get the resolution we desired, thus we abandoned the idea.

'''PROBABLY NEED MORE TECHNICAL RESULTS HERE, BUT I'M NOT SURE WHAT TO SAY RIGHT NOW'''

The best result was that using the device was just plain fun. We each had a great time moving around and hearing the fun sounds that resulted, or if we were feeling ambitious, we would try to play a simple melody like "Mary Had a Little Lamb." It was rather difficult to play anything more complicated than that because it required lots of body control and precise movements.

=Reflections=

'''Successes'''
*tilt switches activated each of the six notes when they were supposed to
**the YMZ284 chips were able to produce all six notes at the same time, allowing cool chords
*tones were in tune and formed fun melodies and chords as the body moved
*drum actuator hit the drum reliably and with good tone
*heart rate monitor usually showed clear peaks on a scope, but was finnicky in practice

'''Room for improvements'''
*tilt switches sometimes bounced, so the beginning, or particularly the ends of the notes sounded jagged
**''Possible Solution:'' add a low pass filter to the switch signal so that the signal ramps up and down.
*the shoulder straps sometimes needed adjustments for each individual in order for the sensors to be in the correct position
**''Possible Solution:'' create straps with more constraints, such as a strap across the chest as well as the back, to ensure that the sensors are in the correct positions and orientations.
*the straps could be easier to put on
**''Possible Solution:'' maybe integrate them into a single garment, like a onesie
*the heart rate monitor was not reliable. Low frequency drift made setting a comparison level nearly impossible, especially for more than one specific user.
**''Possible Solution:'' improve FFT method so that desired resolution could be achieved in a short sample period (around 10 seconds). Or implement a complicated peak detection algorithm on the PIC.

'''JAMES SHOULD ADD SOME KIND OF HEARTWARMING CONCLUSION CUZ HE'S GOOD AT THAT STUFF'''

File:Heart rate sensor mfth.JPG

2010-03-17T06:07:59Z

EricWest: Illustrates the mechanical design of the heart rate sensor used in the Music from the Heart Music Suit.

Illustrates the mechanical design of the heart rate sensor used in the Music from the Heart Music Suit.

Music from the Heart -- Music Suit

2010-03-17T04:49:34Z

EricWest:

=Introduction=

This project attempted to create a natural form of musical expression by connecting sensors to the body. Six tilt switches were attached to the wrist, ankles, and shoulders, each controlling a single pitch from the [http://en.wikipedia.org/wiki/Pentatonic_scale pentatonic scale]. The heart beat was obtained using [http://en.wikipedia.org/wiki/Photoplethysmograph photoplethysmography] on the user's finger, and this signal was used to strike a drum in sync with the heart beat.

==Team Members==

*Thomas Peterson (Computer Engineering, 2010)
*James Rein (Biomedical Engineering and Music Cognition, 2010)
*Eric West (Mechanical Engineering, 2011)

'''INSERT TEAM PICTURE HERE'''

=Subsystems=

Although intended as a single, cohesive system that would allow the user to intuitively make music, the project was easily divided into three subsystems: heart rate monitor, drum actuation, and music tones. Below is more explanation about each subsystem.

==Heart rate monitor - Concepts==

In brainstorming how to translate a heart beat into a drum beat, we decided that the least intrusive method would be the best. Attaching electrodes to the user would simplify the process of identifying a heart beat, but attaching the sensors directly to the skin would be a time-consuming and personally-invasive process. Instead, we decided a finger tip sensor would be much more comfortable and easy to use.

To make a finger tip sensor, we used the concepts of [http://en.wikipedia.org/wiki/Photoplethysmograph photoplethysmography]. Photoplethysmography is typically used in [http://en.wikipedia.org/wiki/Pulse_oximeter pulse oximeters] and finger-tip sensors in commercially-available devices. We originally tried to hack a heart rate monitor that we had purchased, but this proved difficult, so we decided to make our own.

The basic concept of photoplethysmography is that blood reflects a certain amount of IR light, and the blood density in the finger changes as the heart pumps, so the IR reflectivity of the finger changes as the heart beats. Using an IR emitter-detector pair found in the mechatronics lab followed by lots of amplification and filtering, we were able to obtain a decent signal with peaks when the user's heart beat.

===Heart rate monitor - Electrical Design===

The signal coming directly out of the IR detector was very weak and noisy. To obtain just the information we desired, we ran it through the following filters and amplifiers:

# [[Passive Filters#High-Pass Filter (HPF)|Passive High-Pass Filter]]
# [[Operational Amplifiers (Op-Amps)#Inverting Amplifier|Inverting Amplifier]]: gain = -470
# [http://en.wikipedia.org/wiki/Low-pass_filter#Active_electronic_realization Active Low-pass filter]: cutoff frequency = 4.82Hz, gain = -70
# [http://www.electronics-tutorials.ws/filter/filter_7.html Band-pass filter]: Frequency range = 0.72 to 3.39Hz, inverting gain = -46.8
# [[Comparators|Comparator]]: output to the PIC pin A14, with pull-up resistor to 3.3V and capacitors to smooth out the signal.

The complete signal processing circuit is shown below.

[[Image:Heartrate monitor.PNG|thumb|center|900px|Heart rate monitor circuit diagram. Click for larger image.]]

===Heart rate monitor - Mechanical Design===

The sensor itself was a QRB1114 emitter-detector pair that was encased in open-cell foam insulation. We inserted it into the foam by drilling and filing a hole in the foam to the appropriate size, and gluing the sensor in place. A round, finger-shaped groove was filed into the foam and the sensor sat flush with the bottom of this groove. The user's finger was held in the correct position with relatively constant pressure using a latex band around the finger and the foam enclosure.

'''INSERT PICTURE OF THE HEART SENSOR'''

==Drum actuator - Electrical design==

Once the signal from the heart rate sensor is sent to the PIC, the rising edge triggers an interrupt which starts the driving sequence for the motor that strikes the drum. The drive sequence was: drive down (into drum) 100ms, drive up 75ms, wait 150ms. The interrupt does not do the entire driving sequence, it merely flags a variable to start the sequence, which is done in the main loop, as seen in the code below.

An additional interrupt was triggered by the falling edge of the signal; this falling edge interrupt added additional wait time that prevented the PIC from being "fooled" by a noisy falling edge. For instance, if the falling signal had some noise in it, the rising edge interrupt would be triggered again, thus causing the drum to strike on both the rising and falling edges of the heartbeat. We only wanted one strike per heartbeat, so the falling edge interrupt was triggered by the ''first'' falling edge, and any noise in the falling edge was ignored because the PIC was told to wait for 300ms. With a maximum delay of 150 + 300 = 450ms from the two interrupts, the fastest heartbeat our drum could play was 133 beats per minute, but we did not expect anyone to come play the instrument after running, so this was plenty high for our purposes.

Initially, we tried skipping the comparator and sending the analog signal directly into one of the PICs analog inputs. Our intention was to use the fast Fourier transform (FFT) library to try to extract the dominant frequency. Unfortunately, we ran into various problems. First, to get the accuracy we wanted for small frequencies, the sample window had to be very long (10 seconds or more), which made the output lag changes in heart rate. Additionally, the FFT was often "messy", which messed up our original algorithm of detecting the peak frequency between .5 and 2.5 hz. The system would sometimes randomly switch between very different frequencies, and although it was right most of the time it was enough to make the drum beating sound bad. We also tried algorithms to find the [http://en.wikipedia.org/wiki/Fundamental_frequency fundamental frequency] using the entire FFT (instead of just the .5-2.5 hz range), but this was still unreliable. We considered FFT peak detection algorithms, but they seemed to complex for the time and computing power we had available. Because of all this, we went with the simple comparator in the end.

The motor for driving the drumstick was driven by an [[media:L298N.pdf|L298 H-bridge]]. See [[Driving a high current DC Motor using an H-bridge]] for more information on how this works. Our particular circuit diagram is shown below:

[[Image:T21_motorckt_png.PNG|thumb|center|600px|Motor Circuit (non-motor PIC connections not shown). Click for larger image.]]

====Drum actuator - Mechanical Design====

We wanted to use a real drum for our drum beat, so our challenge was to attach a motor and drumstick to a drum. We chose a small rack tom for its resonant tone that is reminiscent of a heart beat.

To attach the drumstick to the motor shaft, we used a small block of acrylic (.5"x.5"x2"). The drumstick was cut down to 8" in length so that it would require less torque from the motor. In one end of the block, a hole was drilled and the drumstick was sanded to the correct diameter in order to snuggly fit into the hole. To ensure that the drumstick could not slide out of the block, a screw was placed in a hole drilled through both the stick and the block. The other end of the block was attached to the motor shaft using a split-clamp method: A hole the size of the motor shaft was drilled through the block, and then a slit was cut from the end of the block to the hole, allowing a screw to tightly clamp the block around the motor.

'''INSERT PICTURE OF DRUMSTICK-MOTORSHAFT ATTACHMENT'''

To attach the motor-stick assembly to the drum, we utilized the tuning screws on the drum. A sheet metal bracket with holes in the appropriate places attached the motor to two of these tuning screws. The bracket was easily made by cutting and bending a piece of 16 gauge steel sheet metal to the appropriate size. Ideally, this part would have been made out of one continuous piece of sheet metal, but we could not find a large enough sheet available in the shop, so we used rivets to connect two smaller pieces together.

After testing the drum striking, we decided it was too loud. To dampen the sound, we taped a piece of foam core and a shop rag to the head of the drum where the stick strikes it.

'''Parts list for drum actuator'''
*Bargain drumstick, at least .5" in diameter
*Small block of acrylic, .5"x.5"x2" (aluminum would work just as well, this is what was available)
*16 gauge steel sheet metal for bracket
*Screws and nuts
*Foam core, shop rag, tape for dampening

==Music Tones - Electrical Design==
The music tones were activated by tilt switches and generated using a [http://pdf1.alldatasheet.com/datasheet-pdf/view/82065/YAMAHA/YMZ284.html YMZ284] chip and were output through a 1/8" jack to a standard set of computer speakers.

Each YMZ284 is capable of producing and mixing any combination of three tones. Since we wanted to have six notes from a [http://en.wikipedia.org/wiki/Pentatonic_scale pentatonic scale], we needed two of these chips and used an [[Operational Amplifiers (Op-Amps)#Summer|summing opamp circuit]] to combine outputs from each chip. We envisioned a possibility of adding [http://en.wikipedia.org/wiki/Overtone overtones] to each note, to make them sound better and more like a real instrument, so we ended up having four YMZ284s attached to our board. When we tried adding an overtone an octave above the fundamental frequency, it ended up sounding harsh and whiny. We decided the tones sounded better with no overtones, so we are only using 2 of the 4 chips on our board.

The YMZ284 communicates with the PIC over an 8-bit databus, plus additional pins for chip select, address, write enable, and reset. All four of our YMZ284s shared all of their pins ''except'' the chip select line; each required their own individual chip select line so that the PIC could specify with which chips it wanted to talk. The circuit diagram below shows how the chips were connected to the PIC and the summing circuit that followed.

[[Image:T21_musicckt_png.PNG|thumb|center|600px|Music circuit diagram. The summing amplifier is not shown. Click for larger image.]]

===Tilt switches - Electrical Design===
In order to detect when the limbs of the user had moved past a certain critical angle, we chose to use tilt switches. We purchased our tilt switches for $2 each from [http://www.goldmine-elec-products.com/prodinfo.asp?number=G16881 Electronics Goldmine]. We chose to use tilt switches instead of an accelerometer because the switches were much cheaper and we figured they would be easier to work with.

The tilt switches we chose are optically-based with an emitter and detector that are selectively blocked by a small ball. When the critical angle is achieved, the tiny ball rolls up a ramp, allowing the emitter to shine directly on the detector, and current flows. When the angle is neutral, the ramp forces the ball to block the light, making current stop flowing through the phototransistor. The "ramp" is really an inverted cone, so the switch can be activated by a change in angle in any direction away from the neutral position. We purchased three different tilt switches to try, each with a different critical angle - 15, 30, and 45 degrees. The configuration we ended up using was:

*30 degrees for shoulders and ankles
*45 degrees for elbows

In hindsight, we would have used all 45-degree switches because they produced the sharpest jump from off to on. The 15-degree switches were practically unusable because they created a large amount of noise as they switched on and off.

We used the tilt switches to provide high-low inputs to the PIC to tell it when to turn on any of the six tones. By attaching these switches to the body such that they are in the neutral position when the body is relaxed, we were able to control the six tones by moving the body in relatively natural ways.

===Tilt switches - Mechanical Design===
The switches were attached to the user's body using adjustable straps and buckles. The wrist and ankle sensors were simply a loop of webbing with an adjustable buckle attached. The straps could be tightened or loosened to fit any size user. To attach the switch to the straps, we created an enclosure for each switch out of high-density foam (left over scraps from DSGN 307). The switch was jammed into a hole in the foam so that it could not easily be moved. The foam was then taped to the straps using electrical tape.

'''INSERT PICTURE OF THE WRIST AND ANKLE STRAPS'''

The shoulder straps were a bit more involved. Two loops with buckles, similar to the wrist and ankle straps, went over the user's shoulder and underneath their armpit. To keep these straps from sliding off the shoulders, a large strap across the user's back connected the two smaller straps together. This large strap was also used for mounting the solder board which gathered the wires from all six tilt switches and sent them to the PIC over one ribbon cable. Using this strap configuration, we found that the user could comfortably and securely wear the sensors.

To attach the switches to the shoulders, we again created a foam encasement. However, electrical tape was not secure enough to hold the foam pieces to the irregularly-shaped shoulder straps. Instead, we riveted a piece of canvas to the webbing straps. We chose to use rivets instead of sewing because the sewing machine could not tightly sew the foam encasement in place. With rivets, we were able to pull the canvas tightly around the foam so that it couldn't move.

'''INSERT PICTURE OF THE SHOULDER STRAPS'''

=Code=
To download the entire C file, click [[Media:Main_music.c|here]]. Below, the file is split into sections for comments.

/**********************************************************
* main_music.c: Main c file for "Music Suit" project
*
* Thomas Peterson, James Rein, Eric West
* ME333 Winter 2010
**********************************************************/

#include <HardwareProfile.h>
#include <delays.c> //Delayms and Delayus functions

The first section defines all the input and output pins, used with the motor, sensor, and music circuits.

////////////////////////////////////////////////////
//Pin Defines

//YMZ Chip selects
#define CS1 LATCbits.LATC2
#define CS2 LATCbits.LATC3
#define CS3 LATCbits.LATC4
#define CS4 LATGbits.LATG6
//YMZ communication pins
#define NWR LATBbits.LATB0 //"Not WRite": active low write line
#define A0 LATBbits.LATB6 //Address 0
#define NIC LATCbits.LATC1 //"Not Input Clear": active low reset line
//YMZ data pins
#define D0 LATGbits.LATG9
#define D1 LATEbits.LATE8
#define D2 LATEbits.LATE9
#define D3 LATBbits.LATB5
#define D4 LATBbits.LATB4
#define D5 LATBbits.LATB3
#define D6 LATBbits.LATB2
#define D7 LATBbits.LATB1

//Tilt inputs
#define ENC PORTDbits.RD3
#define END PORTDbits.RD2
#define ENE PORTDbits.RD1
#define ENG PORTCbits.RC14
#define ENA PORTCbits.RC13
#define ENC5 PORTDbits.RD0

//Motor outputs
#define IN1 LATBbits.LATB7
#define IN2 LATAbits.LATA9
#define EN LATAbits.LATA10

///////////////////////////////////////
//Other defines
//Motor times
#define MS(x) x*312.5
#define DRIVETIME MS(100)
#define BACKTIME MS(75)
#define WAITTIME MS(150)
//Channels
#define CHNA 1
#define CHNB 2
#define CHNC 4

//////////////////////////////////////////
//Function definitions
void write_chip(int address, int data);
void portout(int byte);
void channelSw(int chip, int chn, int *mixer, int state);
//Global variables
int mixer1, mixer2;
int motorflag = 0;
The initialization function sets up various parts of the system.
/* init() : This function runs initializations, setting up the pic and music chips */
void init() {
int pbClk = SYSTEMConfigPerformance(SYS_FREQ);

/////////////////////////////////////////////
//Setup inputs / outputs
AD1PCFG = 0xFFFF; //All digital inputs
TRISG &= 0xFDBF; //sets G9,G6 to 0 (output); all else remains the same
TRISC &= 0xFFE1; //sets C4,C3,C2,C1 to 0s (outputs); all else remains the same
TRISB &= 0xFF80; //sets B0-B6 0 (output)
TRISE &= 0xFCFF; //sets E8,9 to output
TRISB |= 0xF000; //sets B12,B13,B14,B15 to 1s (inputs); all else remains the same
TRISC |= 0x6000; //sets C14,13 to inputs
TRISD |= 0x000F; //Sets D0,D1,D2,D3 to inputs
TRISDbits.TRISD4 = 0; //Output for clock
//Motor outputs
TRISAbits.TRISA9 = 0;
TRISAbits.TRISA10 = 0;
TRISBbits.TRISB7 = 0;
//Pulse inputs
TRISAbits.TRISA14 = 1;
TRISAbits.TRISA15 = 1;
//ODC setup
ODCCbits.ODCC1 = 1; //open drain control; can only float high (when set high) or pull low

/* Initialize outputs */
//YMZs
CS1 = 1;
CS2 = 1;
CS3 = 1;
CS4 = 1;
NWR = 1;
A0 = 0;
NIC = 1;
//Motor
IN2 = 0;
IN1 = 0;
EN = 0;

Delayms(100); //wait for power supply to ramp up
NIC = 0; //resets YMZ284s
Delayms(10);
NIC = 1;

In the init() function, the pic writes all the setup data to the music chips. This includes the frequency registers, which determine the frequency of each output, the mixer, which determines which channels are on or off (1 = off), and the volume registers, which determine the volume of each channel. After the setup, the only register that is changed in normal operation is the mixer register, which merely turns channels on and off.
//////////////////////////////////////////////////
//Setup music chips
//Setup Chip 1//
CS1 = 0;
write_chip(0x00,0xC7); //a low // C4
write_chip(0x01,0x01); //a high
write_chip(0x02,0x98); //b low // D
write_chip(0x03,0x01); //b high
write_chip(0x04,0x6E); //c low
write_chip(0x05,0x01); //c high // E
write_chip(0x07,0xFF); //mixer (0 enables)
write_chip(0x08, 0x0A); //level (volume) A
write_chip(0x09, 0x0A); //level (volume) B
write_chip(0x0A, 0x0A); //level (volume) C
CS1=1;
//Setup Chip 2//
CS2 = 0;
write_chip(0x00,0x2C); //a low //G 392
write_chip(0x01,0x01); //a high
write_chip(0x02,0x0D); //b low //A 440
write_chip(0x03,0x01); //b high
write_chip(0x04,0xE3); //c low //C5 523.25
write_chip(0x05,0x00); //c high
write_chip(0x07,0xFF); //mixer (0 enables)
write_chip(0x08, 0x0A); //level (volume) A
write_chip(0x09, 0x0A); //level (volume) B
write_chip(0x0A, 0x0A); //level (volume) C
CS2=1;

mixer1=0xFF;
mixer2=0xFF;
OC5 is used to create a PWM signal with 50% duty at 4Mhz, in effect creating a 4Mhz square wave. This is used by the music chips as a master clock.
//////////////////////////////////////////////
//Setup OC to create master clock for music chips (~4 Mhz)
OpenOC5( OC_ON | OC_TIMER2_SRC | OC_PWM_FAULT_PIN_DISABLE, 0, 0);
OpenTimer2( T2_ON | T2_PS_1_1 | T2_SOURCE_INT, 20);
SetDCOC5PWM(10);
The interrupts are used, as mentioned above, to control when the motor is driven. The motor should drive once every rising edge.
/////////////////////////////////////////////
//External interrupt setups (for motor) - INT3 (A14)
mINT3ClearIntFlag();
mINT3IntEnable(1);
mINT3SetIntPriority(6);
mINT3SetEdgeMode(1); //Rising edge
/////////////////////////////////////////////
//External interrupt setups (for motor) - INT4 (A15)
mINT4ClearIntFlag();
mINT4IntEnable(1);
mINT4SetIntPriority(5);
mINT4SetEdgeMode(0); //Falling edge
INTEnableSystemMultiVectoredInt();

/////////////////////////////////////////////
//Setup motor timer (used for timing delays)
OpenTimer3(T3_ON | T3_PS_1_256 | T3_SOURCE_INT, 0xFFFF);
ConfigIntTimer3(T3_INT_OFF);
}

Main function
/* Main function */
int main()
{
init(); /* Run initialization functions */
Delayms(1);

/* Main while loop: loop indefinietly */
while (1) {
In the main while loop, the PIC checks every cycle to see if an input has changed since the last cycle. Since the "mixer" variables store the current state, if an input does not match up with its valid mixer bit then it has changed recently. In this case, the channelSw() function is called to switch on or off the music channel controlled by that bit.
//Check for state changes in music notes
if (ENC != (mixer1 & 0x01)) { channelSw(1,CHNA,&mixer1,!ENC); } //If input ENC (enable C) is not equal to the state of channel A1 (note c), change the state
if (END != (mixer1 & 0x02)) { channelSw(1,CHNB,&mixer1,!END); }
if (ENE != (mixer1 & 0x04)) { channelSw(1,CHNC,&mixer1,!ENE); }
if (ENG != (mixer2 & 0x01)) { channelSw(2,CHNA,&mixer2,!ENG); }
if (ENA != (mixer2 & 0x02)) { channelSw(2,CHNB,&mixer2,!ENA); }
if (ENC5 != (mixer2 & 0x04)) { channelSw(2,CHNC,&mixer2,!ENC5); }
During the main while loop, the motor flag variable is checked to see if the motor should be driven. If so, it enters a sequence where it uses timer3 to determine the current stage in the motor cycle, changing the outputs as needed.
//Check for motor state changes
switch (motorflag) {
case 0: break; //Do nothing (motor off)
case 1: //Start motor cycle
WriteTimer3(0); //Reset timer to 0
IN1 = 0; //Set H bridge to forward drive
IN2 = 1;
EN = 1;
motorflag = 2; //In drivedown cycle
break;
case 2: //Drivedown cycle
if (ReadTimer3() > DRIVETIME) { //Wait for DRIVETIME to pass
WriteTimer3(0); //Reset timer to 0
motorflag = 3; //In driveup phase
IN2 = 0; //Switch H bridge
IN1 = 1;
}
break;
case 3: //Driveup cycle
if (ReadTimer3() > BACKTIME) { //Wait for BACKTIME to pass
WriteTimer3(0); //Reset timer to 0
motorflag = 4; //In coast/wait phase
EN = 0; //Turn off motor
}
break;
case 4: //coast / wait cycle
if (ReadTimer3() > WAITTIME) {
motorflag = 5; //more wait
WriteTimer3(0);
}
break;
case 5: //Additional wait cycle
if (ReadTimer3() > WAITTIME) {
//Done!
motorflag = 0; //Motor off (can now be triggered again)
}
break;
//Static wait cycles
case 6:
if (ReadTimer3() > WAITTIME) {
motorflag = 7;
WriteTimer3(0);
}
break;
case 7:
if (ReadTimer3() > WAITTIME) {
WriteTimer3(0);
motorflag = 8;
}
break;
case 8:
if (ReadTimer3() > WAITTIME) {
motorflag = 0;
}
break;
}

Delayms(10);
}
return 0;
}//end main

Write chip function, which is a support function that writes data to the music chips.
/* write_chip: This writes the given byte "data" to the "address" (0 or 1)
on a YMZ284. It is assumed that the chip select is already low */
void write_chip(int address,int data) {
//Write address
portout(address);
A0 = 0; //select address mode
Delayus(1); //setup time
NWR = 0; //Write cycle begin
Delayus(1); //hold time
NWR = 1; //Write cycle end

//Write data
portout(data);
A0 = 1; //select data mode
Delayus(1); //setup time
NWR = 0; //write cycle begin
Delayus(1); //hold time
NWR = 1; //write cycle end
}
Port out function
/* port_out: This function outputs a byte to the D0-D7 port */
void portout(int byte) {
// Note: !! converts an integer expression to a boolean (1 or 0).
D0 = !!(byte & 1);
D1 = !!(byte & 2);
D2 = !!(byte & 4);
D3 = !!(byte & 8);
D4 = !!(byte & 16);
D5 = !!(byte & 32);
D6 = !!(byte & 64);
D7 = !!(byte & 128);
}
Channel switch function, which writes a new mixer value to turn a channel on or off.
/* channelSw: Generic channel switch function
This writes a new mixer value to chip "chip". The mixer value
depends on "chn", the channel turning on or off, "state" whether
the channel is turning on or off, and "*mixer", a pointer to
the old mixer value. */
void channelSw(int chip, int chn, int *mixer, int state) {
/* Enable music chip */
switch(chip) {
case 1: CS1 = 0; break;
case 2: CS2 = 0; break;
case 3: CS3 = 0; break;
case 4: CS4 = 0; break;
}
/* Write mixer value */
/* This writes to channel 7 (mixer channel) the _new_ mixer value, which is
the old mixer value with a particular bit flipped based on "chn" and "state" */
write_chip(0x07, (*mixer) = state ? (*mixer) & (0xFF & ~chn) : (*mixer) | chn);
/* Disable chip */
switch(chip) {
case 1: CS1 = 1; break;
case 2: CS2 = 1; break;
case 3: CS3 = 1; break;
case 4: CS4 = 1; break;
}

}
Interrupt functions
//External interrupt for motor driving
void __ISR(_EXTERNAL_3_VECTOR, ipl6) _SingleVectorHandler(void) {
if (motorflag == 0) {
motorflag = 1; //Start motor cycle
}
//If on already, do nothing
mINT3ClearIntFlag();
}

//External interrupt for motor waiting
void __ISR(_EXTERNAL_4_VECTOR, ipl5) _SingleVectorHandler2(void) {
if (motorflag == 0) {
WriteTimer3(0);
motorflag = 6; //Start wait cycle
}
//If on already, do nothing
mINT4ClearIntFlag();
}

=Results=

The project turned out to be a mild success overall. The tilt switches worked very well for activating the music tones, but the heart rate monitor was less successful. One of the biggest issues was getting rid of very low frequency drift in the signal that made the peaks sometimes as high as 10V, but other times less 1V. Dealing with this fluctuation in peak size was the most difficult part of signal processing. As mentioned above, we tried FFT in order to establish a steady heart rate, but could not get the resolution we desired, thus we abandoned the idea.

'''PROBABLY NEED MORE TECHNICAL RESULTS HERE, BUT I'M NOT SURE WHAT TO SAY RIGHT NOW'''

The best result was that using the device was just plain fun. We each had a great time moving around and hearing the fun sounds that resulted, or if we were feeling ambitious, we would try to play a simple melody like "Mary Had a Little Lamb." It was rather difficult to play anything more complicated than that because it required lots of body control and precise movements.

=Reflections=

'''Successes'''
*tilt switches activated each of the six notes when they were supposed to
**the YMZ284 chips were able to produce all six notes at the same time, allowing cool chords
*tones were in tune and formed fun melodies and chords as the body moved
*drum actuator hit the drum reliably and with good tone
*heart rate monitor usually showed clear peaks on a scope, but was finnicky in practice

'''Room for improvements'''
*tilt switches sometimes bounced, so the beginning, or particularly the ends of the notes sounded jagged
**''Possible Solution:'' add a low pass filter to the switch signal so that the signal ramps up and down.
*the shoulder straps sometimes needed adjustments for each individual in order for the sensors to be in the correct position
**''Possible Solution:'' create straps with more constraints, such as a strap across the chest as well as the back, to ensure that the sensors are in the correct positions and orientations.
*the straps could be easier to put on
**''Possible Solution:'' maybe integrate them into a single garment, like a onesie
*the heart rate monitor was not reliable. Low frequency drift made setting a comparison level nearly impossible, especially for more than one specific user.
**''Possible Solution:'' improve FFT method so that desired resolution could be achieved in a short sample period (around 10 seconds). Or implement a complicated peak detection algorithm on the PIC.

'''JAMES SHOULD ADD SOME KIND OF HEARTWARMING CONCLUSION CUZ HE'S GOOD AT THAT STUFF'''

Music from the Heart -- Music Suit

2010-03-17T04:05:37Z

EricWest: /* Heart rate monitor - Electrical Design */

=Introduction=

This project attempted to create a natural form of musical expression by connecting sensors to the body. Six tilt switches were attached to the wrist, ankles, and shoulders, each controlling a single pitch from the [http://en.wikipedia.org/wiki/Pentatonic_scale pentatonic scale]. The heart beat was obtained using [http://en.wikipedia.org/wiki/Photoplethysmograph photoplethysmography] on the user's finger, and this signal was used to strike a drum in sync with the heart beat.

==Team Members==

*Thomas Peterson (Computer Engineering, 2010)
*James Rein (Biomedical Engineering and Music Cognition, 2010)
*Eric West (Mechanical Engineering, 2011)

'''INSERT TEAM PICTURE HERE'''

=Subsystems=

Although intended as a single, cohesive system that would allow the user to intuitively make music, the project was easily divided into three subsystems: heart rate monitor, drum actuation, and music tones. Below is more explanation about each subsystem.

==Heart rate monitor - Concepts==

In brainstorming how to translate a heart beat into a drum beat, we decided that the least intrusive method would be the best. Attaching electrodes to the user would simplify the process of identifying a heart beat, but attaching the sensors directly to the skin would be a time-consuming and personally-invasive process. Instead, we decided a finger tip sensor would be much more comfortable and easy to use.

To make a finger tip sensor, we used the concepts of [http://en.wikipedia.org/wiki/Photoplethysmograph photoplethysmography]. Photoplethysmography is typically used in [http://en.wikipedia.org/wiki/Pulse_oximeter pulse oximeters] and finger-tip sensors in commercially-available devices. We originally tried to hack a heart rate monitor that we had purchased, but this proved difficult, so we decided to make our own.

The basic concept of photoplethysmography is that blood reflects a certain amount of IR light, and the blood density in the finger changes as the heart pumps, so the IR reflectivity of the finger changes as the heart beats. Using an IR emitter-detector pair found in the mechatronics lab followed by lots of amplification and filtering, we were able to obtain a decent signal with peaks when the user's heart beat.

===Heart rate monitor - Electrical Design===

The signal coming directly out of the IR detector was very weak and noisy. To obtain just the information we desired, we ran it through the following filters and amplifiers:

# [[Passive Filters#High-Pass Filter (HPF)|Passive High Pass Filter]] - cutoff frequency = '''INSERT'''
# [[Operational Amplifiers (Op-Amps)#Inverting Amplifier|Inverting Amplifier]] - gain = '''INSERT'''
# [http://en.wikipedia.org/wiki/Low-pass_filter#Active_electronic_realization Active Low pass filter] - cutoff frequency = '''INSERT'''
# Bandpass filter - Frequency range = '''INSERT'''
# [[Comparators|Comparator]] - output to the PIC

The complete signal processing circuit is shown below.

[[Image:Heartrate monitor.PNG|thumb|center|900px|Heart rate monitor circuit diagram. Click for larger image.]]

===Heart rate monitor - Mechanical Design===

The sensor itself was a '''INSERT COMPONENT NAME HERE''' that was encased in open-cell foam insulation. We inserted it into the foam by drilling and filing a hole in the foam to the appropriate size, and gluing the sensor in place. A round, finger-shaped groove was filed into the foam and the sensor sat flush with the bottom of this groove. The user's finger was held in the correct position with relatively constant pressure using a latex band around the finger and the foam enclosure.

'''INSERT PICTURE OF THE HEART SENSOR'''

==Drum actuator - Electrical design==

Once the signal from the heart rate sensor is sent to the PIC, the rising edge triggers an interrupt which starts the driving sequence for the motor that strikes the drum. The drive sequence was: drive down (into drum) 100ms, drive up 75ms, wait 150ms. The interrupt does not do the entire driving sequence, it merely flags a variable to start the sequence, which is done in the main loop, as seen in the code below.

An additional interrupt was triggered by the falling edge of the signal; this falling edge interrupt added additional wait time that prevented the PIC from being "fooled" by a noisy falling edge. For instance, if the falling signal had some noise in it, the rising edge interrupt would be triggered again, thus causing the drum to strike on both the rising and falling edges of the heartbeat. We only wanted one strike per heartbeat, so the falling edge interrupt was triggered by the ''first'' falling edge, and any noise in the falling edge was ignored because the PIC was told to wait for 300ms. With a maximum delay of 150 + 300 = 450ms from the two interrupts, the fastest heartbeat our drum could play was 133 beats per minute, but we did not expect anyone to come play the instrument after running, so this was plenty high for our purposes.

Initially, we tried skipping the comparator and sending the analog signal directly into one of the PICs analog inputs. Our intention was to use the fast Fourier transform (FFT) library to try to extract the dominant frequency. Unfortunately, we ran into various problems. First, to get the accuracy we wanted for small frequencies, the sample window had to be very long (10 seconds or more), which made the output lag changes in heart rate. Additionally, the FFT was often "messy", which messed up our original algorithm of detecting the peak frequency between .5 and 2.5 hz. The system would sometimes randomly switch between very different frequencies, and although it was right most of the time it was enough to make the drum beating sound bad. We also tried algorithms to find the [http://en.wikipedia.org/wiki/Fundamental_frequency fundamental frequency] using the entire FFT (instead of just the .5-2.5 hz range), but this was still unreliable. We considered FFT peak detection algorithms, but they seemed to complex for the time and computing power we had available. Because of all this, we went with the simple comparator in the end.

The motor for driving the drumstick was driven by an [[media:L298N.pdf|L298 H-bridge]]. See [[Driving a high current DC Motor using an H-bridge]] for more information on how this works. Our particular circuit diagram is shown below:

[[Image:T21_motorckt_png.PNG|thumb|center|600px|Motor Circuit (non-motor PIC connections not shown). Click for larger image.]]

====Drum actuator - Mechanical Design====

We wanted to use a real drum for our drum beat, so our challenge was to attach a motor and drumstick to a drum. We chose a small rack tom for its resonant tone that is reminiscent of a heart beat.

To attach the drumstick to the motor shaft, we used a small block of acrylic (.5"x.5"x2"). The drumstick was cut down to 8" in length so that it would require less torque from the motor. In one end of the block, a hole was drilled and the drumstick was sanded to the correct diameter in order to snuggly fit into the hole. To ensure that the drumstick could not slide out of the block, a screw was placed in a hole drilled through both the stick and the block. The other end of the block was attached to the motor shaft using a split-clamp method: A hole the size of the motor shaft was drilled through the block, and then a slit was cut from the end of the block to the hole, allowing a screw to tightly clamp the block around the motor.

'''INSERT PICTURE OF DRUMSTICK-MOTORSHAFT ATTACHMENT'''

To attach the motor-stick assembly to the drum, we utilized the tuning screws on the drum. A sheet metal bracket with holes in the appropriate places attached the motor to two of these tuning screws. The bracket was easily made by cutting and bending a piece of '''GAUGE''' gauge steel sheet metal to the appropriate size. Ideally, this part would have been made out of one continuous piece of sheet metal, but we could not find a large enough sheet available in the shop, so we used rivets to connect two smaller pieces together.

After testing the drum striking, we decided it was too loud. To dampen the sound, we taped a piece of foam core and a shop rag to the head of the drum where the stick strikes it.

'''Parts list for drum actuator'''
*Bargain drumstick, at least .5" in diameter
*Small block of acrylic, .5"x.5"x2" (aluminum would work just as well, this is what was available)
*'''GAUGE''' steel sheet metal for bracket
*Screws and nuts
*Foam core, shop rag, tape for dampening

==Music Tones - Electrical Design==
The music tones were activated by tilt switches and generated using a [http://pdf1.alldatasheet.com/datasheet-pdf/view/82065/YAMAHA/YMZ284.html YMZ284] chip and were output through a 1/8" jack to a standard set of computer speakers.

Each YMZ284 is capable of producing and mixing any combination of three tones. Since we wanted to have six notes from a [http://en.wikipedia.org/wiki/Pentatonic_scale pentatonic scale], we needed two of these chips and used an [[Operational Amplifiers (Op-Amps)#Summer|summing opamp circuit]] to combine outputs from each chip. We envisioned a possibility of adding [http://en.wikipedia.org/wiki/Overtone overtones] to each note, to make them sound better and more like a real instrument, so we ended up having four YMZ284s attached to our board. When we tried adding an overtone an octave above the fundamental frequency, it ended up sounding harsh and whiny. We decided the tones sounded better with no overtones, so we are only using 2 of the 4 chips on our board.

The YMZ284 communicates with the PIC over an 8-bit databus, plus additional pins for chip select, address, write enable, and reset. All four of our YMZ284s shared all of their pins ''except'' the chip select line; each required their own individual chip select line so that the PIC could specify with which chips it wanted to talk. The circuit diagram below shows how the chips were connected to the PIC and the summing circuit that followed.

[[Image:T21_musicckt_png.PNG|thumb|center|600px|Music circuit diagram. The summing amplifier is not shown. Click for larger image.]]

===Tilt switches - Electrical Design===
In order to detect when the limbs of the user had moved past a certain critical angle, we chose to use tilt switches. We purchased our tilt switches for $2 each from [http://www.goldmine-elec-products.com/prodinfo.asp?number=G16881 Electronics Goldmine]. We chose to use tilt switches instead of an accelerometer because the switches were much cheaper and we figured they would be easier to work with.

The tilt switches we chose are optically-based with an emitter and detector that are selectively blocked by a small ball. When the critical angle is achieved, the tiny ball rolls up a ramp, allowing the emitter to shine directly on the detector, and current flows. When the angle is neutral, the ramp forces the ball to block the light, making current stop flowing through the phototransistor. The "ramp" is really an inverted cone, so the switch can be activated by a change in angle in any direction away from the neutral position. We purchased three different tilt switches to try, each with a different critical angle - 15, 30, and 45 degrees. The configuration we ended up using was:

*30 degrees for shoulders and ankles
*45 degrees for elbows

In hindsight, we would have used all 45-degree switches because they produced the sharpest jump from off to on. The 15-degree switches were practically unusable because they created a large amount of noise as they switched on and off.

We used the tilt switches to provide high-low inputs to the PIC to tell it when to turn on any of the six tones. By attaching these switches to the body such that they are in the neutral position when the body is relaxed, we were able to control the six tones by moving the body in relatively natural ways.

===Tilt switches - Mechanical Design===
The switches were attached to the user's body using adjustable straps and buckles. The wrist and ankle sensors were simply a loop of webbing with an adjustable buckle attached. The straps could be tightened or loosened to fit any size user. To attach the switch to the straps, we created an enclosure for each switch out of high-density foam (left over scraps from DSGN 307). The switch was jammed into a hole in the foam so that it could not easily be moved. The foam was then taped to the straps using electrical tape.

'''INSERT PICTURE OF THE WRIST AND ANKLE STRAPS'''

The shoulder straps were a bit more involved. Two loops with buckles, similar to the wrist and ankle straps, went over the user's shoulder and underneath their armpit. To keep these straps from sliding off the shoulders, a large strap across the user's back connected the two smaller straps together. This large strap was also used for mounting the solder board which gathered the wires from all six tilt switches and sent them to the PIC over one ribbon cable. Using this strap configuration, we found that the user could comfortably and securely wear the sensors.

To attach the switches to the shoulders, we again created a foam encasement. However, electrical tape was not secure enough to hold the foam pieces to the irregularly-shaped shoulder straps. Instead, we riveted a piece of canvas to the webbing straps. We chose to use rivets instead of sewing because the sewing machine could not tightly sew the foam encasement in place. With rivets, we were able to pull the canvas tightly around the foam so that it couldn't move.

'''INSERT PICTURE OF THE SHOULDER STRAPS'''

=Code=
To download the entire C file, click [[Media:Main_music.c|here]]. Below, the file is split into sections for comments.

/**********************************************************
* main_music.c: Main c file for "Music Suit" project
*
* Thomas Peterson, James Rein, Eric West
* ME333 Winter 2010
**********************************************************/

#include <HardwareProfile.h>
#include <delays.c> //Delayms and Delayus functions

The first section defines all the input and output pins, used with the motor, sensor, and music circuits.

////////////////////////////////////////////////////
//Pin Defines

//YMZ Chip selects
#define CS1 LATCbits.LATC2
#define CS2 LATCbits.LATC3
#define CS3 LATCbits.LATC4
#define CS4 LATGbits.LATG6
//YMZ communication pins
#define NWR LATBbits.LATB0 //"Not WRite": active low write line
#define A0 LATBbits.LATB6 //Address 0
#define NIC LATCbits.LATC1 //"Not Input Clear": active low reset line
//YMZ data pins
#define D0 LATGbits.LATG9
#define D1 LATEbits.LATE8
#define D2 LATEbits.LATE9
#define D3 LATBbits.LATB5
#define D4 LATBbits.LATB4
#define D5 LATBbits.LATB3
#define D6 LATBbits.LATB2
#define D7 LATBbits.LATB1

//Tilt inputs
#define ENC PORTDbits.RD3
#define END PORTDbits.RD2
#define ENE PORTDbits.RD1
#define ENG PORTCbits.RC14
#define ENA PORTCbits.RC13
#define ENC5 PORTDbits.RD0

//Motor outputs
#define IN1 LATBbits.LATB7
#define IN2 LATAbits.LATA9
#define EN LATAbits.LATA10

///////////////////////////////////////
//Other defines
//Motor times
#define MS(x) x*312.5
#define DRIVETIME MS(100)
#define BACKTIME MS(75)
#define WAITTIME MS(150)
//Channels
#define CHNA 1
#define CHNB 2
#define CHNC 4

//////////////////////////////////////////
//Function definitions
void write_chip(int address, int data);
void portout(int byte);
void channelSw(int chip, int chn, int *mixer, int state);
//Global variables
int mixer1, mixer2;
int motorflag = 0;
The initialization function sets up various parts of the system.
/* init() : This function runs initializations, setting up the pic and music chips */
void init() {
int pbClk = SYSTEMConfigPerformance(SYS_FREQ);

/////////////////////////////////////////////
//Setup inputs / outputs
AD1PCFG = 0xFFFF; //All digital inputs
TRISG &= 0xFDBF; //sets G9,G6 to 0 (output); all else remains the same
TRISC &= 0xFFE1; //sets C4,C3,C2,C1 to 0s (outputs); all else remains the same
TRISB &= 0xFF80; //sets B0-B6 0 (output)
TRISE &= 0xFCFF; //sets E8,9 to output
TRISB |= 0xF000; //sets B12,B13,B14,B15 to 1s (inputs); all else remains the same
TRISC |= 0x6000; //sets C14,13 to inputs
TRISD |= 0x000F; //Sets D0,D1,D2,D3 to inputs
TRISDbits.TRISD4 = 0; //Output for clock
//Motor outputs
TRISAbits.TRISA9 = 0;
TRISAbits.TRISA10 = 0;
TRISBbits.TRISB7 = 0;
//Pulse inputs
TRISAbits.TRISA14 = 1;
TRISAbits.TRISA15 = 1;
//ODC setup
ODCCbits.ODCC1 = 1; //open drain control; can only float high (when set high) or pull low

/* Initialize outputs */
//YMZs
CS1 = 1;
CS2 = 1;
CS3 = 1;
CS4 = 1;
NWR = 1;
A0 = 0;
NIC = 1;
//Motor
IN2 = 0;
IN1 = 0;
EN = 0;

Delayms(100); //wait for power supply to ramp up
NIC = 0; //resets YMZ284s
Delayms(10);
NIC = 1;

In the init() function, the pic writes all the setup data to the music chips. This includes the frequency registers, which determine the frequency of each output, the mixer, which determines which channels are on or off (1 = off), and the volume registers, which determine the volume of each channel. After the setup, the only register that is changed in normal operation is the mixer register, which merely turns channels on and off.
//////////////////////////////////////////////////
//Setup music chips
//Setup Chip 1//
CS1 = 0;
write_chip(0x00,0xC7); //a low // C4
write_chip(0x01,0x01); //a high
write_chip(0x02,0x98); //b low // D
write_chip(0x03,0x01); //b high
write_chip(0x04,0x6E); //c low
write_chip(0x05,0x01); //c high // E
write_chip(0x07,0xFF); //mixer (0 enables)
write_chip(0x08, 0x0A); //level (volume) A
write_chip(0x09, 0x0A); //level (volume) B
write_chip(0x0A, 0x0A); //level (volume) C
CS1=1;
//Setup Chip 2//
CS2 = 0;
write_chip(0x00,0x2C); //a low //G 392
write_chip(0x01,0x01); //a high
write_chip(0x02,0x0D); //b low //A 440
write_chip(0x03,0x01); //b high
write_chip(0x04,0xE3); //c low //C5 523.25
write_chip(0x05,0x00); //c high
write_chip(0x07,0xFF); //mixer (0 enables)
write_chip(0x08, 0x0A); //level (volume) A
write_chip(0x09, 0x0A); //level (volume) B
write_chip(0x0A, 0x0A); //level (volume) C
CS2=1;

mixer1=0xFF;
mixer2=0xFF;
OC5 is used to create a PWM signal with 50% duty at 4Mhz, in effect creating a 4Mhz square wave. This is used by the music chips as a master clock.
//////////////////////////////////////////////
//Setup OC to create master clock for music chips (~4 Mhz)
OpenOC5( OC_ON | OC_TIMER2_SRC | OC_PWM_FAULT_PIN_DISABLE, 0, 0);
OpenTimer2( T2_ON | T2_PS_1_1 | T2_SOURCE_INT, 20);
SetDCOC5PWM(10);
The interrupts are used, as mentioned above, to control when the motor is driven. The motor should drive once every rising edge.
/////////////////////////////////////////////
//External interrupt setups (for motor) - INT3 (A14)
mINT3ClearIntFlag();
mINT3IntEnable(1);
mINT3SetIntPriority(6);
mINT3SetEdgeMode(1); //Rising edge
/////////////////////////////////////////////
//External interrupt setups (for motor) - INT4 (A15)
mINT4ClearIntFlag();
mINT4IntEnable(1);
mINT4SetIntPriority(5);
mINT4SetEdgeMode(0); //Falling edge
INTEnableSystemMultiVectoredInt();

/////////////////////////////////////////////
//Setup motor timer (used for timing delays)
OpenTimer3(T3_ON | T3_PS_1_256 | T3_SOURCE_INT, 0xFFFF);
ConfigIntTimer3(T3_INT_OFF);
}

Main function
/* Main function */
int main()
{
init(); /* Run initialization functions */
Delayms(1);

/* Main while loop: loop indefinietly */
while (1) {
In the main while loop, the PIC checks every cycle to see if an input has changed since the last cycle. Since the "mixer" variables store the current state, if an input does not match up with its valid mixer bit then it has changed recently. In this case, the channelSw() function is called to switch on or off the music channel controlled by that bit.
//Check for state changes in music notes
if (ENC != (mixer1 & 0x01)) { channelSw(1,CHNA,&mixer1,!ENC); } //If input ENC (enable C) is not equal to the state of channel A1 (note c), change the state
if (END != (mixer1 & 0x02)) { channelSw(1,CHNB,&mixer1,!END); }
if (ENE != (mixer1 & 0x04)) { channelSw(1,CHNC,&mixer1,!ENE); }
if (ENG != (mixer2 & 0x01)) { channelSw(2,CHNA,&mixer2,!ENG); }
if (ENA != (mixer2 & 0x02)) { channelSw(2,CHNB,&mixer2,!ENA); }
if (ENC5 != (mixer2 & 0x04)) { channelSw(2,CHNC,&mixer2,!ENC5); }
During the main while loop, the motor flag variable is checked to see if the motor should be driven. If so, it enters a sequence where it uses timer3 to determine the current stage in the motor cycle, changing the outputs as needed.
//Check for motor state changes
switch (motorflag) {
case 0: break; //Do nothing (motor off)
case 1: //Start motor cycle
WriteTimer3(0); //Reset timer to 0
IN1 = 0; //Set H bridge to forward drive
IN2 = 1;
EN = 1;
motorflag = 2; //In drivedown cycle
break;
case 2: //Drivedown cycle
if (ReadTimer3() > DRIVETIME) { //Wait for DRIVETIME to pass
WriteTimer3(0); //Reset timer to 0
motorflag = 3; //In driveup phase
IN2 = 0; //Switch H bridge
IN1 = 1;
}
break;
case 3: //Driveup cycle
if (ReadTimer3() > BACKTIME) { //Wait for BACKTIME to pass
WriteTimer3(0); //Reset timer to 0
motorflag = 4; //In coast/wait phase
EN = 0; //Turn off motor
}
break;
case 4: //coast / wait cycle
if (ReadTimer3() > WAITTIME) {
motorflag = 5; //more wait
WriteTimer3(0);
}
break;
case 5: //Additional wait cycle
if (ReadTimer3() > WAITTIME) {
//Done!
motorflag = 0; //Motor off (can now be triggered again)
}
break;
//Static wait cycles
case 6:
if (ReadTimer3() > WAITTIME) {
motorflag = 7;
WriteTimer3(0);
}
break;
case 7:
if (ReadTimer3() > WAITTIME) {
WriteTimer3(0);
motorflag = 8;
}
break;
case 8:
if (ReadTimer3() > WAITTIME) {
motorflag = 0;
}
break;
}

Delayms(10);
}
return 0;
}//end main

Write chip function, which is a support function that writes data to the music chips.
/* write_chip: This writes the given byte "data" to the "address" (0 or 1)
on a YMZ284. It is assumed that the chip select is already low */
void write_chip(int address,int data) {
//Write address
portout(address);
A0 = 0; //select address mode
Delayus(1); //setup time
NWR = 0; //Write cycle begin
Delayus(1); //hold time
NWR = 1; //Write cycle end

//Write data
portout(data);
A0 = 1; //select data mode
Delayus(1); //setup time
NWR = 0; //write cycle begin
Delayus(1); //hold time
NWR = 1; //write cycle end
}
Port out function
/* port_out: This function outputs a byte to the D0-D7 port */
void portout(int byte) {
// Note: !! converts an integer expression to a boolean (1 or 0).
D0 = !!(byte & 1);
D1 = !!(byte & 2);
D2 = !!(byte & 4);
D3 = !!(byte & 8);
D4 = !!(byte & 16);
D5 = !!(byte & 32);
D6 = !!(byte & 64);
D7 = !!(byte & 128);
}
Channel switch function, which writes a new mixer value to turn a channel on or off.
/* channelSw: Generic channel switch function
This writes a new mixer value to chip "chip". The mixer value
depends on "chn", the channel turning on or off, "state" whether
the channel is turning on or off, and "*mixer", a pointer to
the old mixer value. */
void channelSw(int chip, int chn, int *mixer, int state) {
/* Enable music chip */
switch(chip) {
case 1: CS1 = 0; break;
case 2: CS2 = 0; break;
case 3: CS3 = 0; break;
case 4: CS4 = 0; break;
}
/* Write mixer value */
/* This writes to channel 7 (mixer channel) the _new_ mixer value, which is
the old mixer value with a particular bit flipped based on "chn" and "state" */
write_chip(0x07, (*mixer) = state ? (*mixer) & (0xFF & ~chn) : (*mixer) | chn);
/* Disable chip */
switch(chip) {
case 1: CS1 = 1; break;
case 2: CS2 = 1; break;
case 3: CS3 = 1; break;
case 4: CS4 = 1; break;
}

}
Interrupt functions
//External interrupt for motor driving
void __ISR(_EXTERNAL_3_VECTOR, ipl6) _SingleVectorHandler(void) {
if (motorflag == 0) {
motorflag = 1; //Start motor cycle
}
//If on already, do nothing
mINT3ClearIntFlag();
}

//External interrupt for motor waiting
void __ISR(_EXTERNAL_4_VECTOR, ipl5) _SingleVectorHandler2(void) {
if (motorflag == 0) {
WriteTimer3(0);
motorflag = 6; //Start wait cycle
}
//If on already, do nothing
mINT4ClearIntFlag();
}

=Results=

The project turned out to be a mild success overall. The tilt switches worked very well for activating the music tones, but the heart rate monitor was less successful. One of the biggest issues was getting rid of very low frequency drift in the signal that made the peaks sometimes as high as 10V, but other times less 1V. Dealing with this fluctuation in peak size was the most difficult part of signal processing. As mentioned above, we tried FFT in order to establish a steady heart rate, but could not get the resolution we desired, thus we abandoned the idea.

'''PROBABLY NEED MORE TECHNICAL RESULTS HERE, BUT I'M NOT SURE WHAT TO SAY RIGHT NOW'''

The best result was that using the device was just plain fun. We each had a great time moving around and hearing the fun sounds that resulted, or if we were feeling ambitious, we would try to play a simple melody like "Mary Had a Little Lamb." It was rather difficult to play anything more complicated than that because it required lots of body control and precise movements.

=Reflections=

'''Successes'''
*tilt switches activated each of the six notes when they were supposed to
**the YMZ284 chips were able to produce all six notes at the same time, allowing cool chords
*tones were in tune and formed fun melodies and chords as the body moved
*drum actuator hit the drum reliably and with good tone
*heart rate monitor usually showed clear peaks on a scope, but was finnicky in practice

'''Room for improvements'''
*tilt switches sometimes bounced, so the beginning, or particularly the ends of the notes sounded jagged
**''Possible Solution:'' add a low pass filter to the switch signal so that the signal ramps up and down.
*the shoulder straps sometimes needed adjustments for each individual in order for the sensors to be in the correct position
**''Possible Solution:'' create straps with more constraints, such as a strap across the chest as well as the back, to ensure that the sensors are in the correct positions and orientations.
*the straps could be easier to put on
**''Possible Solution:'' maybe integrate them into a single garment, like a onesie
*the heart rate monitor was not reliable. Low frequency drift made setting a comparison level nearly impossible, especially for more than one specific user.
**''Possible Solution:'' improve FFT method so that desired resolution could be achieved in a short sample period (around 10 seconds). Or implement a complicated peak detection algorithm on the PIC.

'''JAMES SHOULD ADD SOME KIND OF HEARTWARMING CONCLUSION CUZ HE'S GOOD AT THAT STUFF'''

Music from the Heart -- Music Suit

2010-03-17T04:02:19Z

EricWest: /* Heart rate monitor - Electrical Design */

=Introduction=

This project attempted to create a natural form of musical expression by connecting sensors to the body. Six tilt switches were attached to the wrist, ankles, and shoulders, each controlling a single pitch from the [http://en.wikipedia.org/wiki/Pentatonic_scale pentatonic scale]. The heart beat was obtained using [http://en.wikipedia.org/wiki/Photoplethysmograph photoplethysmography] on the user's finger, and this signal was used to strike a drum in sync with the heart beat.

==Team Members==

*Thomas Peterson (Computer Engineering, 2010)
*James Rein (Biomedical Engineering and Music Cognition, 2010)
*Eric West (Mechanical Engineering, 2011)

'''INSERT TEAM PICTURE HERE'''

=Subsystems=

Although intended as a single, cohesive system that would allow the user to intuitively make music, the project was easily divided into three subsystems: heart rate monitor, drum actuation, and music tones. Below is more explanation about each subsystem.

==Heart rate monitor - Concepts==

In brainstorming how to translate a heart beat into a drum beat, we decided that the least intrusive method would be the best. Attaching electrodes to the user would simplify the process of identifying a heart beat, but attaching the sensors directly to the skin would be a time-consuming and personally-invasive process. Instead, we decided a finger tip sensor would be much more comfortable and easy to use.

To make a finger tip sensor, we used the concepts of [http://en.wikipedia.org/wiki/Photoplethysmograph photoplethysmography]. Photoplethysmography is typically used in [http://en.wikipedia.org/wiki/Pulse_oximeter pulse oximeters] and finger-tip sensors in commercially-available devices. We originally tried to hack a heart rate monitor that we had purchased, but this proved difficult, so we decided to make our own.

The basic concept of photoplethysmography is that blood reflects a certain amount of IR light, and the blood density in the finger changes as the heart pumps, so the IR reflectivity of the finger changes as the heart beats. Using an IR emitter-detector pair found in the mechatronics lab followed by lots of amplification and filtering, we were able to obtain a decent signal with peaks when the user's heart beat.

===Heart rate monitor - Electrical Design===

The signal coming directly out of the IR detector was very weak and noisy. To obtain just the information we desired, we ran it through the following filters and amplifiers:

# [[Passive Filters#High-Pass Filter (HPF)|Passive High Pass Filter]] - cutoff frequency = '''INSERT'''
# [[Operational Amplifiers (Op-Amps)#Inverting Amplifier|Inverting Amplifier]] - gain = '''INSERT'''
# [http://en.wikipedia.org/wiki/Low-pass_filter#Active_electronic_realization Active Low pass filter] - cutoff frequency = '''INSERT'''
# Bandpass filter - Frequency range = '''INSERT'''
# [[Comparators|Comparator]] - output to the PIC

The complete signal processing circuit is shown below.

[[Image:Heartrate monitor.PNG]]

===Heart rate monitor - Mechanical Design===

The sensor itself was a '''INSERT COMPONENT NAME HERE''' that was encased in open-cell foam insulation. We inserted it into the foam by drilling and filing a hole in the foam to the appropriate size, and gluing the sensor in place. A round, finger-shaped groove was filed into the foam and the sensor sat flush with the bottom of this groove. The user's finger was held in the correct position with relatively constant pressure using a latex band around the finger and the foam enclosure.

'''INSERT PICTURE OF THE HEART SENSOR'''

==Drum actuator - Electrical design==

Once the signal from the heart rate sensor is sent to the PIC, the rising edge triggers an interrupt which starts the driving sequence for the motor that strikes the drum. The drive sequence was: drive down (into drum) 100ms, drive up 75ms, wait 150ms. The interrupt does not do the entire driving sequence, it merely flags a variable to start the sequence, which is done in the main loop, as seen in the code below.

An additional interrupt was triggered by the falling edge of the signal; this falling edge interrupt added additional wait time that prevented the PIC from being "fooled" by a noisy falling edge. For instance, if the falling signal had some noise in it, the rising edge interrupt would be triggered again, thus causing the drum to strike on both the rising and falling edges of the heartbeat. We only wanted one strike per heartbeat, so the falling edge interrupt was triggered by the ''first'' falling edge, and any noise in the falling edge was ignored because the PIC was told to wait for 300ms. With a maximum delay of 150 + 300 = 450ms from the two interrupts, the fastest heartbeat our drum could play was 133 beats per minute, but we did not expect anyone to come play the instrument after running, so this was plenty high for our purposes.

Initially, we tried skipping the comparator and sending the analog signal directly into one of the PICs analog inputs. Our intention was to use the fast Fourier transform (FFT) library to try to extract the dominant frequency. Unfortunately, we ran into various problems. First, to get the accuracy we wanted for small frequencies, the sample window had to be very long (10 seconds or more), which made the output lag changes in heart rate. Additionally, the FFT was often "messy", which messed up our original algorithm of detecting the peak frequency between .5 and 2.5 hz. The system would sometimes randomly switch between very different frequencies, and although it was right most of the time it was enough to make the drum beating sound bad. We also tried algorithms to find the [http://en.wikipedia.org/wiki/Fundamental_frequency fundamental frequency] using the entire FFT (instead of just the .5-2.5 hz range), but this was still unreliable. We considered FFT peak detection algorithms, but they seemed to complex for the time and computing power we had available. Because of all this, we went with the simple comparator in the end.

The motor for driving the drumstick was driven by an [[media:L298N.pdf|L298 H-bridge]]. See [[Driving a high current DC Motor using an H-bridge]] for more information on how this works. Our particular circuit diagram is shown below:

[[Image:T21_motorckt_png.PNG|thumb|center|600px|Motor Circuit (non-motor PIC connections not shown). Click for larger image.]]

====Drum actuator - Mechanical Design====

We wanted to use a real drum for our drum beat, so our challenge was to attach a motor and drumstick to a drum. We chose a small rack tom for its resonant tone that is reminiscent of a heart beat.

To attach the drumstick to the motor shaft, we used a small block of acrylic (.5"x.5"x2"). The drumstick was cut down to 8" in length so that it would require less torque from the motor. In one end of the block, a hole was drilled and the drumstick was sanded to the correct diameter in order to snuggly fit into the hole. To ensure that the drumstick could not slide out of the block, a screw was placed in a hole drilled through both the stick and the block. The other end of the block was attached to the motor shaft using a split-clamp method: A hole the size of the motor shaft was drilled through the block, and then a slit was cut from the end of the block to the hole, allowing a screw to tightly clamp the block around the motor.

'''INSERT PICTURE OF DRUMSTICK-MOTORSHAFT ATTACHMENT'''

To attach the motor-stick assembly to the drum, we utilized the tuning screws on the drum. A sheet metal bracket with holes in the appropriate places attached the motor to two of these tuning screws. The bracket was easily made by cutting and bending a piece of '''GAUGE''' gauge steel sheet metal to the appropriate size. Ideally, this part would have been made out of one continuous piece of sheet metal, but we could not find a large enough sheet available in the shop, so we used rivets to connect two smaller pieces together.

After testing the drum striking, we decided it was too loud. To dampen the sound, we taped a piece of foam core and a shop rag to the head of the drum where the stick strikes it.

'''Parts list for drum actuator'''
*Bargain drumstick, at least .5" in diameter
*Small block of acrylic, .5"x.5"x2" (aluminum would work just as well, this is what was available)
*'''GAUGE''' steel sheet metal for bracket
*Screws and nuts
*Foam core, shop rag, tape for dampening

==Music Tones - Electrical Design==
The music tones were activated by tilt switches and generated using a [http://pdf1.alldatasheet.com/datasheet-pdf/view/82065/YAMAHA/YMZ284.html YMZ284] chip and were output through a 1/8" jack to a standard set of computer speakers.

Each YMZ284 is capable of producing and mixing any combination of three tones. Since we wanted to have six notes from a [http://en.wikipedia.org/wiki/Pentatonic_scale pentatonic scale], we needed two of these chips and used an [[Operational Amplifiers (Op-Amps)#Summer|summing opamp circuit]] to combine outputs from each chip. We envisioned a possibility of adding [http://en.wikipedia.org/wiki/Overtone overtones] to each note, to make them sound better and more like a real instrument, so we ended up having four YMZ284s attached to our board. When we tried adding an overtone an octave above the fundamental frequency, it ended up sounding harsh and whiny. We decided the tones sounded better with no overtones, so we are only using 2 of the 4 chips on our board.

The YMZ284 communicates with the PIC over an 8-bit databus, plus additional pins for chip select, address, write enable, and reset. All four of our YMZ284s shared all of their pins ''except'' the chip select line; each required their own individual chip select line so that the PIC could specify with which chips it wanted to talk. The circuit diagram below shows how the chips were connected to the PIC and the summing circuit that followed.

[[Image:T21_musicckt_png.PNG|thumb|center|600px|Music circuit diagram. The summing amplifier is not shown. Click for larger image.]]

===Tilt switches - Electrical Design===
In order to detect when the limbs of the user had moved past a certain critical angle, we chose to use tilt switches. We purchased our tilt switches for $2 each from [http://www.goldmine-elec-products.com/prodinfo.asp?number=G16881 Electronics Goldmine]. We chose to use tilt switches instead of an accelerometer because the switches were much cheaper and we figured they would be easier to work with.

The tilt switches we chose are optically-based with an emitter and detector that are selectively blocked by a small ball. When the critical angle is achieved, the tiny ball rolls up a ramp, allowing the emitter to shine directly on the detector, and current flows. When the angle is neutral, the ramp forces the ball to block the light, making current stop flowing through the phototransistor. The "ramp" is really an inverted cone, so the switch can be activated by a change in angle in any direction away from the neutral position. We purchased three different tilt switches to try, each with a different critical angle - 15, 30, and 45 degrees. The configuration we ended up using was:

*30 degrees for shoulders and ankles
*45 degrees for elbows

In hindsight, we would have used all 45-degree switches because they produced the sharpest jump from off to on. The 15-degree switches were practically unusable because they created a large amount of noise as they switched on and off.

We used the tilt switches to provide high-low inputs to the PIC to tell it when to turn on any of the six tones. By attaching these switches to the body such that they are in the neutral position when the body is relaxed, we were able to control the six tones by moving the body in relatively natural ways.

===Tilt switches - Mechanical Design===
The switches were attached to the user's body using adjustable straps and buckles. The wrist and ankle sensors were simply a loop of webbing with an adjustable buckle attached. The straps could be tightened or loosened to fit any size user. To attach the switch to the straps, we created an enclosure for each switch out of high-density foam (left over scraps from DSGN 307). The switch was jammed into a hole in the foam so that it could not easily be moved. The foam was then taped to the straps using electrical tape.

'''INSERT PICTURE OF THE WRIST AND ANKLE STRAPS'''

The shoulder straps were a bit more involved. Two loops with buckles, similar to the wrist and ankle straps, went over the user's shoulder and underneath their armpit. To keep these straps from sliding off the shoulders, a large strap across the user's back connected the two smaller straps together. This large strap was also used for mounting the solder board which gathered the wires from all six tilt switches and sent them to the PIC over one ribbon cable. Using this strap configuration, we found that the user could comfortably and securely wear the sensors.

To attach the switches to the shoulders, we again created a foam encasement. However, electrical tape was not secure enough to hold the foam pieces to the irregularly-shaped shoulder straps. Instead, we riveted a piece of canvas to the webbing straps. We chose to use rivets instead of sewing because the sewing machine could not tightly sew the foam encasement in place. With rivets, we were able to pull the canvas tightly around the foam so that it couldn't move.

'''INSERT PICTURE OF THE SHOULDER STRAPS'''

=Code=
To download the entire C file, click [[Media:Main_music.c|here]]. Below, the file is split into sections for comments.

/**********************************************************
* main_music.c: Main c file for "Music Suit" project
*
* Thomas Peterson, James Rein, Eric West
* ME333 Winter 2010
**********************************************************/

#include <HardwareProfile.h>
#include <delays.c> //Delayms and Delayus functions

The first section defines all the input and output pins, used with the motor, sensor, and music circuits.

////////////////////////////////////////////////////
//Pin Defines

//YMZ Chip selects
#define CS1 LATCbits.LATC2
#define CS2 LATCbits.LATC3
#define CS3 LATCbits.LATC4
#define CS4 LATGbits.LATG6
//YMZ communication pins
#define NWR LATBbits.LATB0 //"Not WRite": active low write line
#define A0 LATBbits.LATB6 //Address 0
#define NIC LATCbits.LATC1 //"Not Input Clear": active low reset line
//YMZ data pins
#define D0 LATGbits.LATG9
#define D1 LATEbits.LATE8
#define D2 LATEbits.LATE9
#define D3 LATBbits.LATB5
#define D4 LATBbits.LATB4
#define D5 LATBbits.LATB3
#define D6 LATBbits.LATB2
#define D7 LATBbits.LATB1

//Tilt inputs
#define ENC PORTDbits.RD3
#define END PORTDbits.RD2
#define ENE PORTDbits.RD1
#define ENG PORTCbits.RC14
#define ENA PORTCbits.RC13
#define ENC5 PORTDbits.RD0

//Motor outputs
#define IN1 LATBbits.LATB7
#define IN2 LATAbits.LATA9
#define EN LATAbits.LATA10

///////////////////////////////////////
//Other defines
//Motor times
#define MS(x) x*312.5
#define DRIVETIME MS(100)
#define BACKTIME MS(75)
#define WAITTIME MS(150)
//Channels
#define CHNA 1
#define CHNB 2
#define CHNC 4

//////////////////////////////////////////
//Function definitions
void write_chip(int address, int data);
void portout(int byte);
void channelSw(int chip, int chn, int *mixer, int state);
//Global variables
int mixer1, mixer2;
int motorflag = 0;
The initialization function sets up various parts of the system.
/* init() : This function runs initializations, setting up the pic and music chips */
void init() {
int pbClk = SYSTEMConfigPerformance(SYS_FREQ);

/////////////////////////////////////////////
//Setup inputs / outputs
AD1PCFG = 0xFFFF; //All digital inputs
TRISG &= 0xFDBF; //sets G9,G6 to 0 (output); all else remains the same
TRISC &= 0xFFE1; //sets C4,C3,C2,C1 to 0s (outputs); all else remains the same
TRISB &= 0xFF80; //sets B0-B6 0 (output)
TRISE &= 0xFCFF; //sets E8,9 to output
TRISB |= 0xF000; //sets B12,B13,B14,B15 to 1s (inputs); all else remains the same
TRISC |= 0x6000; //sets C14,13 to inputs
TRISD |= 0x000F; //Sets D0,D1,D2,D3 to inputs
TRISDbits.TRISD4 = 0; //Output for clock
//Motor outputs
TRISAbits.TRISA9 = 0;
TRISAbits.TRISA10 = 0;
TRISBbits.TRISB7 = 0;
//Pulse inputs
TRISAbits.TRISA14 = 1;
TRISAbits.TRISA15 = 1;
//ODC setup
ODCCbits.ODCC1 = 1; //open drain control; can only float high (when set high) or pull low

/* Initialize outputs */
//YMZs
CS1 = 1;
CS2 = 1;
CS3 = 1;
CS4 = 1;
NWR = 1;
A0 = 0;
NIC = 1;
//Motor
IN2 = 0;
IN1 = 0;
EN = 0;

Delayms(100); //wait for power supply to ramp up
NIC = 0; //resets YMZ284s
Delayms(10);
NIC = 1;

In the init() function, the pic writes all the setup data to the music chips. This includes the frequency registers, which determine the frequency of each output, the mixer, which determines which channels are on or off (1 = off), and the volume registers, which determine the volume of each channel. After the setup, the only register that is changed in normal operation is the mixer register, which merely turns channels on and off.
//////////////////////////////////////////////////
//Setup music chips
//Setup Chip 1//
CS1 = 0;
write_chip(0x00,0xC7); //a low // C4
write_chip(0x01,0x01); //a high
write_chip(0x02,0x98); //b low // D
write_chip(0x03,0x01); //b high
write_chip(0x04,0x6E); //c low
write_chip(0x05,0x01); //c high // E
write_chip(0x07,0xFF); //mixer (0 enables)
write_chip(0x08, 0x0A); //level (volume) A
write_chip(0x09, 0x0A); //level (volume) B
write_chip(0x0A, 0x0A); //level (volume) C
CS1=1;
//Setup Chip 2//
CS2 = 0;
write_chip(0x00,0x2C); //a low //G 392
write_chip(0x01,0x01); //a high
write_chip(0x02,0x0D); //b low //A 440
write_chip(0x03,0x01); //b high
write_chip(0x04,0xE3); //c low //C5 523.25
write_chip(0x05,0x00); //c high
write_chip(0x07,0xFF); //mixer (0 enables)
write_chip(0x08, 0x0A); //level (volume) A
write_chip(0x09, 0x0A); //level (volume) B
write_chip(0x0A, 0x0A); //level (volume) C
CS2=1;

mixer1=0xFF;
mixer2=0xFF;
OC5 is used to create a PWM signal with 50% duty at 4Mhz, in effect creating a 4Mhz square wave. This is used by the music chips as a master clock.
//////////////////////////////////////////////
//Setup OC to create master clock for music chips (~4 Mhz)
OpenOC5( OC_ON | OC_TIMER2_SRC | OC_PWM_FAULT_PIN_DISABLE, 0, 0);
OpenTimer2( T2_ON | T2_PS_1_1 | T2_SOURCE_INT, 20);
SetDCOC5PWM(10);
The interrupts are used, as mentioned above, to control when the motor is driven. The motor should drive once every rising edge.
/////////////////////////////////////////////
//External interrupt setups (for motor) - INT3 (A14)
mINT3ClearIntFlag();
mINT3IntEnable(1);
mINT3SetIntPriority(6);
mINT3SetEdgeMode(1); //Rising edge
/////////////////////////////////////////////
//External interrupt setups (for motor) - INT4 (A15)
mINT4ClearIntFlag();
mINT4IntEnable(1);
mINT4SetIntPriority(5);
mINT4SetEdgeMode(0); //Falling edge
INTEnableSystemMultiVectoredInt();

/////////////////////////////////////////////
//Setup motor timer (used for timing delays)
OpenTimer3(T3_ON | T3_PS_1_256 | T3_SOURCE_INT, 0xFFFF);
ConfigIntTimer3(T3_INT_OFF);
}

Main function
/* Main function */
int main()
{
init(); /* Run initialization functions */
Delayms(1);

/* Main while loop: loop indefinietly */
while (1) {
In the main while loop, the PIC checks every cycle to see if an input has changed since the last cycle. Since the "mixer" variables store the current state, if an input does not match up with its valid mixer bit then it has changed recently. In this case, the channelSw() function is called to switch on or off the music channel controlled by that bit.
//Check for state changes in music notes
if (ENC != (mixer1 & 0x01)) { channelSw(1,CHNA,&mixer1,!ENC); } //If input ENC (enable C) is not equal to the state of channel A1 (note c), change the state
if (END != (mixer1 & 0x02)) { channelSw(1,CHNB,&mixer1,!END); }
if (ENE != (mixer1 & 0x04)) { channelSw(1,CHNC,&mixer1,!ENE); }
if (ENG != (mixer2 & 0x01)) { channelSw(2,CHNA,&mixer2,!ENG); }
if (ENA != (mixer2 & 0x02)) { channelSw(2,CHNB,&mixer2,!ENA); }
if (ENC5 != (mixer2 & 0x04)) { channelSw(2,CHNC,&mixer2,!ENC5); }
During the main while loop, the motor flag variable is checked to see if the motor should be driven. If so, it enters a sequence where it uses timer3 to determine the current stage in the motor cycle, changing the outputs as needed.
//Check for motor state changes
switch (motorflag) {
case 0: break; //Do nothing (motor off)
case 1: //Start motor cycle
WriteTimer3(0); //Reset timer to 0
IN1 = 0; //Set H bridge to forward drive
IN2 = 1;
EN = 1;
motorflag = 2; //In drivedown cycle
break;
case 2: //Drivedown cycle
if (ReadTimer3() > DRIVETIME) { //Wait for DRIVETIME to pass
WriteTimer3(0); //Reset timer to 0
motorflag = 3; //In driveup phase
IN2 = 0; //Switch H bridge
IN1 = 1;
}
break;
case 3: //Driveup cycle
if (ReadTimer3() > BACKTIME) { //Wait for BACKTIME to pass
WriteTimer3(0); //Reset timer to 0
motorflag = 4; //In coast/wait phase
EN = 0; //Turn off motor
}
break;
case 4: //coast / wait cycle
if (ReadTimer3() > WAITTIME) {
motorflag = 5; //more wait
WriteTimer3(0);
}
break;
case 5: //Additional wait cycle
if (ReadTimer3() > WAITTIME) {
//Done!
motorflag = 0; //Motor off (can now be triggered again)
}
break;
//Static wait cycles
case 6:
if (ReadTimer3() > WAITTIME) {
motorflag = 7;
WriteTimer3(0);
}
break;
case 7:
if (ReadTimer3() > WAITTIME) {
WriteTimer3(0);
motorflag = 8;
}
break;
case 8:
if (ReadTimer3() > WAITTIME) {
motorflag = 0;
}
break;
}

Delayms(10);
}
return 0;
}//end main

Write chip function, which is a support function that writes data to the music chips.
/* write_chip: This writes the given byte "data" to the "address" (0 or 1)
on a YMZ284. It is assumed that the chip select is already low */
void write_chip(int address,int data) {
//Write address
portout(address);
A0 = 0; //select address mode
Delayus(1); //setup time
NWR = 0; //Write cycle begin
Delayus(1); //hold time
NWR = 1; //Write cycle end

//Write data
portout(data);
A0 = 1; //select data mode
Delayus(1); //setup time
NWR = 0; //write cycle begin
Delayus(1); //hold time
NWR = 1; //write cycle end
}
Port out function
/* port_out: This function outputs a byte to the D0-D7 port */
void portout(int byte) {
// Note: !! converts an integer expression to a boolean (1 or 0).
D0 = !!(byte & 1);
D1 = !!(byte & 2);
D2 = !!(byte & 4);
D3 = !!(byte & 8);
D4 = !!(byte & 16);
D5 = !!(byte & 32);
D6 = !!(byte & 64);
D7 = !!(byte & 128);
}
Channel switch function, which writes a new mixer value to turn a channel on or off.
/* channelSw: Generic channel switch function
This writes a new mixer value to chip "chip". The mixer value
depends on "chn", the channel turning on or off, "state" whether
the channel is turning on or off, and "*mixer", a pointer to
the old mixer value. */
void channelSw(int chip, int chn, int *mixer, int state) {
/* Enable music chip */
switch(chip) {
case 1: CS1 = 0; break;
case 2: CS2 = 0; break;
case 3: CS3 = 0; break;
case 4: CS4 = 0; break;
}
/* Write mixer value */
/* This writes to channel 7 (mixer channel) the _new_ mixer value, which is
the old mixer value with a particular bit flipped based on "chn" and "state" */
write_chip(0x07, (*mixer) = state ? (*mixer) & (0xFF & ~chn) : (*mixer) | chn);
/* Disable chip */
switch(chip) {
case 1: CS1 = 1; break;
case 2: CS2 = 1; break;
case 3: CS3 = 1; break;
case 4: CS4 = 1; break;
}

}
Interrupt functions
//External interrupt for motor driving
void __ISR(_EXTERNAL_3_VECTOR, ipl6) _SingleVectorHandler(void) {
if (motorflag == 0) {
motorflag = 1; //Start motor cycle
}
//If on already, do nothing
mINT3ClearIntFlag();
}

//External interrupt for motor waiting
void __ISR(_EXTERNAL_4_VECTOR, ipl5) _SingleVectorHandler2(void) {
if (motorflag == 0) {
WriteTimer3(0);
motorflag = 6; //Start wait cycle
}
//If on already, do nothing
mINT4ClearIntFlag();
}

=Results=

The project turned out to be a mild success overall. The tilt switches worked very well for activating the music tones, but the heart rate monitor was less successful. One of the biggest issues was getting rid of very low frequency drift in the signal that made the peaks sometimes as high as 10V, but other times less 1V. Dealing with this fluctuation in peak size was the most difficult part of signal processing. As mentioned above, we tried FFT in order to establish a steady heart rate, but could not get the resolution we desired, thus we abandoned the idea.

'''PROBABLY NEED MORE TECHNICAL RESULTS HERE, BUT I'M NOT SURE WHAT TO SAY RIGHT NOW'''

The best result was that using the device was just plain fun. We each had a great time moving around and hearing the fun sounds that resulted, or if we were feeling ambitious, we would try to play a simple melody like "Mary Had a Little Lamb." It was rather difficult to play anything more complicated than that because it required lots of body control and precise movements.

=Reflections=

'''Successes'''
*tilt switches activated each of the six notes when they were supposed to
**the YMZ284 chips were able to produce all six notes at the same time, allowing cool chords
*tones were in tune and formed fun melodies and chords as the body moved
*drum actuator hit the drum reliably and with good tone
*heart rate monitor usually showed clear peaks on a scope, but was finnicky in practice

'''Room for improvements'''
*tilt switches sometimes bounced, so the beginning, or particularly the ends of the notes sounded jagged
**''Possible Solution:'' add a low pass filter to the switch signal so that the signal ramps up and down.
*the shoulder straps sometimes needed adjustments for each individual in order for the sensors to be in the correct position
**''Possible Solution:'' create straps with more constraints, such as a strap across the chest as well as the back, to ensure that the sensors are in the correct positions and orientations.
*the straps could be easier to put on
**''Possible Solution:'' maybe integrate them into a single garment, like a onesie
*the heart rate monitor was not reliable. Low frequency drift made setting a comparison level nearly impossible, especially for more than one specific user.
**''Possible Solution:'' improve FFT method so that desired resolution could be achieved in a short sample period (around 10 seconds). Or implement a complicated peak detection algorithm on the PIC.

'''JAMES SHOULD ADD SOME KIND OF HEARTWARMING CONCLUSION CUZ HE'S GOOD AT THAT STUFF'''

File:Heartrate monitor.PNG

2010-03-17T04:01:53Z

EricWest: heart rate monitor circuit diagram for the Music Suit.

heart rate monitor circuit diagram for the Music Suit.

File:Heartrate monitor.JPG

2010-03-17T03:58:36Z

EricWest: Heartrate monitor circuit for Music Suit.

Heartrate monitor circuit for Music Suit.

Music from the Heart -- Music Suit

2010-03-16T09:32:29Z

EricWest: /* Subsystems */

Music from the Heart -- Music Suit

2010-03-16T09:23:35Z

EricWest: /* Heart rate monitor - Electrical Design */

Music from the Heart -- Music Suit

2010-03-16T09:12:55Z

EricWest:

Music from the Heart -- Music Suit

2010-03-16T01:36:13Z

EricWest:

Music from the Heart -- Music Suit

2010-03-15T23:51:35Z

EricWest:

Music from the Heart -- Music Suit

2010-03-15T23:27:21Z

EricWest: /* Team Members */

Music from the Heart -- Music Suit

2010-03-15T23:26:09Z

EricWest: New page: =Introduction= This project attempted to create a natural form of musical expression by connecting sensors to the body. Six tilt switches were attached to the wrist, ankles, and shoulders...

ME 333 final projects

2010-03-15T23:14:04Z

EricWest: /* ME 333 Final Projects 2010 */

See the '''[[ME 333 end of course schedule]]'''.

Final projects for ME 333 in years 2000-2007 can be found
'''[http://lims.mech.northwestern.edu/~design/mechatronics/ here]'''.

__TOC__

== ME 333 Final Projects 2010 ==

=== [[Sample Project Title]] ===

[[Image:Persistence of Vison Display|thumb|150px|Project photo caption.|right]]

You can copy and paste this wiki code to start your wiki page (but don't erase this code). Then replace this text with your own. A few sentences describing what your project does, with a link to a youtube video. Look at other final project wiki pages for ideas, but see [[ME 333 end of course schedule]] for more information on what should be included on your wiki page.

 

=== [[Music from the Heart -- Music Suit]] ===

[[Image:Persistence of Vison Display|thumb|150px|Project photo caption.|right]]

This project attempted to create a natural form of musical expression by connecting sensors to the body. Six tilt switches were attached to the wrist, ankles, and shoulders, each controlling a single pitch from the pentatonic scale. The heart beat was obtained using photoplethysmography on the user's finger, and this signal was used to strike a drum in sync with the heart beat.

 

=== [[Conservation of Angular Momentum Locomotion Robot (Fluffbot)]] ===

[[Image:Persistence of Vison Display|thumb|150px|Project photo caption.|right]]

Cute fluffy robot that uses conservation of angular momentum to move forward and backward. The robot's momentum wheel accelerates in the floor-plane. The robot's net angular momentum must remain zero-- a steering wheel guides the Fluffbot to accelerate in the opposite direction. This moves the robot forward in a curved path. The momentum wheel and steering wheel then change direction of acceleration. This repeated process moves the Fluffbot forward in a sinusoidal path.

 

=== [[Differential Drive Mobile Robot]] ===

[[Image:Persistence of Vison Display|thumb|150px|Project photo caption.|right]]

The goal of this project was to create a small differential drive mobile robot that would act as a low cost replacement for the popular E-Puck Robot. The robot uses hybrid stepper motors to allow it to track its position through odometry, has a laser cut acrylic chassis for easy replication and replacement, and a 1500 mAh, 13.2V battery pack for long run time. The robot also uses the NU32 board for its control logic and a XBee chip for communication.

 

=== [[Ferrofluid Art Display]] ===

[[Image:Persistence of Vison Display|thumb|150px|Place holder text for caption .|right]]

A little blurb about our Ferrofluid Art Display will go here. Just a few sentences talking about blah blah lkasjdfal hfalsdjh.

 

=== [[Can Launching Fridge]] ===

[[Image:27_Fridge.jpg|thumb|150px|Project photo caption.|right]]

The goal of the can launching fridge was to create a fridge that would, when initiated by either a remote control or a wired push button, automatically load, aim, and fire a can to multiple predetermined locations. The fridge uses a combination of stepper motors, a DC motor, and solenoids to create the ultimate mix of convenience, fun, and refreshment.

 

=== [[High Speed Motor Control]] ===

[[Image:2dofArmSetUp.jpg|thumb|150px|Project photo caption.|right]]
The project suggested was to design a system for high speed motor control using the PIC 32. To demonstrate the motor control, a two degree of freedom (2-DOF) parallelogram robot arm was designed to follow paths specified in a MATLAB gui.

 

== ME 333 Final Projects 2009 ==

=== [[Mozart's Right Hand]] ===
[[Image:mrh_box.JPG|thumb|150px|Mozart's Right Hand|right]]
Mozart's Right Hand is a musical instrument capable of playing two full octaves of the [http://en.wikipedia.org/wiki/Diatonic_scale Diatonic Scale.] The user wears a glove on his right hand and uses motions of the hand and fingers to create different notes that are played with a speaker. The pitch of the note is controlled by the orientation of the user's hand as he rotates it ether from the wrist, the elbow, or the shoulder. The LCD on the front of the box tells the user the pitch that corresponds to his or her current hand orientation. When the user touches together his thumb and index finger, the speaker plays the tone. A [http://www.youtube.com/watch?v=vec-W4QeHQU video] of Mozart's Right Hand in action is available on YouTube.

'''Chosen the OUTSTANDING PROJECT by the students of ME 333.'''

 

=== [[Persistence-of-Vision Display]] ===
[[Image:Persistence of Vison Display|right|thumb|150px]]
This is a fully customizable display implemented using the concept of Persistence of Vision. User-specified images (and even moving images) were displayed by rotating a column of LEDs at speeds faster than 300rpm. Each individual LED was modeled as a row of pixels. Conversely, the rotational position of the panel of LEDs represented the pixel columns of the display; the time interval and rotational speed determined the width of the pixel columns.

 

=== [[Rock Paper Scissors Machine]] ===
[[Image:rps whole thing.JPG|thumb|150px|Rock Paper Scissors Machine|right]]
A machine that will play a fully functioning, intuitive game of [http://en.wikipedia.org/wiki/Rock-paper-scissors Rock/Paper/Scissors] (abbreviated as RPS) with a user. The machine is represented by a human-like hand, capable of seperate and independant wrist, arm, finger and thumb motion. The players' hand goes into a glove equipped with flex sensors, which wirelessly transmits data to the machine based on what the player chose. The machine then reads this data, randomly chooses a throw of its own, and displays what the machine threw, what the human threw, total win/loss/tie info, and winner/loser both on an [http://en.wikipedia.org/wiki/Lcd LCD] screen and in the form of a thumbs up/down/side motion. Video of the machine in action can be found [http://www.youtube.com/watch?v=xbLNBSTTrcE here.]
 

=== [[Three-speaker Chladni Patterns]] ===
[[Image:chladni_660hz|right|thumb|150px]]
This project uses three speakers to generate shapes on a circular aluminum plate depending on which frequency the speakers are playing at. Once the speakers hit a resonant frequency of the plate, salt migrates to the nodes (zero amplitude) regions of the plate to form distinct patterns.
 

=== [[Basketball]] ===
[[Image:Mechatronics2009Bball|right|thumb|150px]]
This project consists of a throwing arm propelled by a Pittman motor is mounted on a turntable and throws the ball into the "hoop." The hoop is wrapped in reflective tape and an IR emitter, receiver pair is used to sense where the IR is reflected most (the hoop with highly reflective tape). An ultrasonic sensor then pings the hoop for the distance of the hoop. With this information, the arm is able to "make a basket." A video can be found [http://www.youtube.com/watch?v=Y466dzP-qiY here].
 

=== [[Robot Drummer]] ===
[[Image:Robot_Drummer.jpg|thumb|400pix|right|Robot Drummer]]
The Robot Drummer is a device that demonstrates high-speed motor control by being able to drum when given commands. Through an RS232 cable, Matlab sends commands to a "master" PIC. The master then sends the commands to two "slave" PICs through I2C communication. The slaves take the commands and implement PID control of the motors.
 

=== [[Automated Fish Refuge]] ===
[[Image:Entire Fish Refuge|right|thumb|200px]]
The automated fish refuge allows for the controlled movement of a fish refuge with the goal of recording specific behavior. The mechanical design is completely adjustable and allows adjustable degrees of oscillating movement and orientation of the refuge. The program is primarily in MATLAB for ease of use and the velocity profile can be a sine, square, triangle, or any function that the user inputs. [http://www.youtube.com/watch?v=wGOKujMhN88 Check out the video!]

 

=== [[Marionette]] ===
[[Image: MarionettePicForIntro.JPG|right|thumb]] The Marionette Project focused on using RC Servos to make a puppet that would do a dance with the press of a button. There were 5 different dances programmed for the marionette, showcasing different styles of movement. The movement had 2 degrees of freedom thanks to using 5 bar linkages and 2 RC servos for each arm. Two more RC Servos were used on the back of the marionette to create the appearance of leg movement. The movements included a Hula dance, Jumping Jacks, and even some moves right out of Saturday Night Fever.

 

=== [[Monkeybot]] ===
[[Image:monkeybot_pic|thumb|right|200px|Monkeybot]]
The monkeybot is a swinging robot capable of moving side to side and climbing. It consists of a two link, double pendulum system with an electro-magnet on each end. At the pivot is a DC motor, which provides an input torque and allows the swinging system to gain energy and climb. Check out the video of the monkeybot climbing [http://www.youtube.com/watch?v=TA2VcH_GDJ0 here] and a later brachiation video [http://www.youtube.com/watch?v=0hfwJEVQyeQ&feature=related here].
 

=== [[PPOD-mini: 6-DOF Shaker]] ===
[[Image:PPOD_mini.JPG|thumb|200x200 px|right|PPOD-mini 6-DOF Shaker]]
The PPOD-mini is a miniaturized version of the Programmable Part-feeding Oscillatory Device ([http://lims.mech.northwestern.edu/projects/frictioninducedforcefields/index.htm PPOD]) found in the Laboratory for Intelligent Mechanical Systems (LIMS) at Northwestern. The PPOD-mini utilizes six speakers that act like actuators. The speakers are connected to a acrylic plate via flexures of tygon and iron. In its current implementation, the phase of the speakers can be controlled independently, giving the device six degrees of freedom. The movement of objects placed on the acrylic plate can be controlled by changing the phases of the speakers.

 

=== [[Automated Xylophone]] ===
[[Image:AutomatedXylophonePicture1.jpg|thumb|200x200 px|right|Automated Xylophone]]
The Automated Xylophone controls several solenoids which hit various pitches on an actual xylophone based on the note selected. The device has two main modes: using the keypad, a user can choose to either play notes in real time or store songs to be played back later. A video of the Automated Xylophone playing in real time mode can be found [http://www.youtube.com/watch?v=_ubpAEyq9kg here].

 

=== [[Vision-based Cannon]] ===
[[Image:SM_Gun_Camera_PIC_Setup.JPG|thumb|200x200 px|right|Vision-based Cannon]]
This project uses a webcam and Matlab to analyze an image and direct a modified USB Missile Launcher to fire at targets found in the image.

 

== ME 333 Final Projects 2008 ==

=== [[IR Tracker]] ===

[[Image:IR_Tracker_Main.jpg|right|thumb|200px]]

The IR Tracker (aka "Spot") is a device that follows a moving infrared light. It continuously detects the position of an infrared emitter in two axes, and then tracks the emitter with a laser. [[Media:MT_MS_AZ_TrackerVideo.mp4|See Spot Run.]]

'''Chosen the OUTSTANDING PROJECT by the students of ME 333.'''

 

=== [[Robot Snake]] ===
[[Image:HLSSnakeMain.jpg|right|thumb|200px]]

This remote control robotic snake uses servo motors with a traveling sine wave motion profile to mimic serpentine motion. The robotic snake is capable of moving forward, left, right and in reverse.

[http://www.youtube.com/watch?v=r_GOOFLnI6w Video of the robot snake]

Featured on [http://blog.makezine.com/archive/2009/03/well_documented_robotic_snake.html Makezine.com].
 

=== [[Programmable Stiffness Joint]] ===

[[Image:SteelToePic2.jpg|thumb|200px|The 'Steel Toe' programmable stiffness joint|right]]

The Programmable Stiffness Joint varies rotational stiffness as desired by the user. It is the first step in modeling the mechanical impedance of the human ankle joint (both stiffness and damping) for the purpose of determining the respective breakdown of the two properties over the gait cycle.

 

=== [[Magnetic based sample purification]] ===

 

=== [[Continuously Variable Transmission]] ===

[[image:CVT_system.JPG|thumb|200px]]

This prototype is a proof of concept model of a variable ratio transmission to be implemented in the 2008-2009 Formula SAE competition vehicle. The gear ratio is determined by the distances between the pulley halves which are controllable electronically.

 

=== [[Granular Flow Rotating Sphere]] ===
[[Image:Team-21-main-picture.JPG|right|thumb|200px]]
This device will be used to study the granular flow of particles within a rotating sphere. The sphere is filled with grains of varying size and then rotated about two different axes according to a series of position and angular velocity inputs.

 

=== [[Vibratory Clock]] ===

[[Image:Vibratory_Clock.jpg|right|thumb|Vibratory Clock|200px]]

The Vibratory Clock allows a small object to act as an hour "hand" on a horizontal circular platform that is actuated from underneath by three speakers. The object slides around the circular platform, impelled by friction forces due to the vibration. [http://www.youtube.com/watch?v=KhgTNCfdwZw Check it out!]

 

=== [[WiiMouse]] ===

[[Image:HPIM1027.jpg|right|thumb|200px]]

The WiiMouse is a handheld remote that can be used to move a cursor on a windows-based PC, via accelerometer input captured through device movement.

 

=== [[Intelligent Oscillation Controller]] ===

[[image:ME333_learning_oscillator.jpg|thumb|200px]]

This device "learns" a forcing function that is applied to a spring and mass system to match an arbitrary, periodic acceleration profile.

 

=== [[Baseball]] ===

[[Image:Baseball_Playfield.jpg|Sweet Baseball Game|right|thumb|200px]]

An interactive baseball game inspired by pinball, featuring pitching, batting, light up bases and a scoreboard to keep track of the game.

 

=== [[Ball Balancing Challenge]] ===

[[Image:Ballbalancechallenge.JPG|right|thumb|200px]]

An interactive game involving ball balancing on a touchscreen with touchscreen feedback and joystick action.

ME 333 final projects

2010-03-15T23:13:38Z

EricWest: /* ME 333 Final Projects 2010 */

See the '''[[ME 333 end of course schedule]]'''.

Final projects for ME 333 in years 2000-2007 can be found
'''[http://lims.mech.northwestern.edu/~design/mechatronics/ here]'''.

__TOC__

== ME 333 Final Projects 2010 ==

=== [[Music from the Heart -- Music Suit]] ===

[[Image:Persistence of Vison Display|thumb|150px|Project photo caption.|right]]

This project attempted to create a natural form of musical expression by connecting sensors to the body. Six tilt switches were attached to the wrist, ankles, and shoulders, each controlling a single pitch from the pentatonic scale. The heart beat was obtained using photoplethysmography on the user's finger, and this signal was used to strike a drum in sync with the heart beat.

 

=== [[Sample Project Title]] ===

[[Image:Persistence of Vison Display|thumb|150px|Project photo caption.|right]]

You can copy and paste this wiki code to start your wiki page (but don't erase this code). Then replace this text with your own. A few sentences describing what your project does, with a link to a youtube video. Look at other final project wiki pages for ideas, but see [[ME 333 end of course schedule]] for more information on what should be included on your wiki page.

 

=== [[Conservation of Angular Momentum Locomotion Robot (Fluffbot)]] ===

[[Image:Persistence of Vison Display|thumb|150px|Project photo caption.|right]]

Cute fluffy robot that uses conservation of angular momentum to move forward and backward. The robot's momentum wheel accelerates in the floor-plane. The robot's net angular momentum must remain zero-- a steering wheel guides the Fluffbot to accelerate in the opposite direction. This moves the robot forward in a curved path. The momentum wheel and steering wheel then change direction of acceleration. This repeated process moves the Fluffbot forward in a sinusoidal path.

 

=== [[Differential Drive Mobile Robot]] ===

[[Image:Persistence of Vison Display|thumb|150px|Project photo caption.|right]]

The goal of this project was to create a small differential drive mobile robot that would act as a low cost replacement for the popular E-Puck Robot. The robot uses hybrid stepper motors to allow it to track its position through odometry, has a laser cut acrylic chassis for easy replication and replacement, and a 1500 mAh, 13.2V battery pack for long run time. The robot also uses the NU32 board for its control logic and a XBee chip for communication.

 

=== [[Ferrofluid Art Display]] ===

[[Image:Persistence of Vison Display|thumb|150px|Place holder text for caption .|right]]

A little blurb about our Ferrofluid Art Display will go here. Just a few sentences talking about blah blah lkasjdfal hfalsdjh.

 

=== [[Can Launching Fridge]] ===

[[Image:27_Fridge.jpg|thumb|150px|Project photo caption.|right]]

The goal of the can launching fridge was to create a fridge that would, when initiated by either a remote control or a wired push button, automatically load, aim, and fire a can to multiple predetermined locations. The fridge uses a combination of stepper motors, a DC motor, and solenoids to create the ultimate mix of convenience, fun, and refreshment.

 

=== [[High Speed Motor Control]] ===

[[Image:2dofArmSetUp.jpg|thumb|150px|Project photo caption.|right]]
The project suggested was to design a system for high speed motor control using the PIC 32. To demonstrate the motor control, a two degree of freedom (2-DOF) parallelogram robot arm was designed to follow paths specified in a MATLAB gui.

 

== ME 333 Final Projects 2009 ==

=== [[Mozart's Right Hand]] ===
[[Image:mrh_box.JPG|thumb|150px|Mozart's Right Hand|right]]
Mozart's Right Hand is a musical instrument capable of playing two full octaves of the [http://en.wikipedia.org/wiki/Diatonic_scale Diatonic Scale.] The user wears a glove on his right hand and uses motions of the hand and fingers to create different notes that are played with a speaker. The pitch of the note is controlled by the orientation of the user's hand as he rotates it ether from the wrist, the elbow, or the shoulder. The LCD on the front of the box tells the user the pitch that corresponds to his or her current hand orientation. When the user touches together his thumb and index finger, the speaker plays the tone. A [http://www.youtube.com/watch?v=vec-W4QeHQU video] of Mozart's Right Hand in action is available on YouTube.

'''Chosen the OUTSTANDING PROJECT by the students of ME 333.'''

 

=== [[Persistence-of-Vision Display]] ===
[[Image:Persistence of Vison Display|right|thumb|150px]]
This is a fully customizable display implemented using the concept of Persistence of Vision. User-specified images (and even moving images) were displayed by rotating a column of LEDs at speeds faster than 300rpm. Each individual LED was modeled as a row of pixels. Conversely, the rotational position of the panel of LEDs represented the pixel columns of the display; the time interval and rotational speed determined the width of the pixel columns.

 

=== [[Rock Paper Scissors Machine]] ===
[[Image:rps whole thing.JPG|thumb|150px|Rock Paper Scissors Machine|right]]
A machine that will play a fully functioning, intuitive game of [http://en.wikipedia.org/wiki/Rock-paper-scissors Rock/Paper/Scissors] (abbreviated as RPS) with a user. The machine is represented by a human-like hand, capable of seperate and independant wrist, arm, finger and thumb motion. The players' hand goes into a glove equipped with flex sensors, which wirelessly transmits data to the machine based on what the player chose. The machine then reads this data, randomly chooses a throw of its own, and displays what the machine threw, what the human threw, total win/loss/tie info, and winner/loser both on an [http://en.wikipedia.org/wiki/Lcd LCD] screen and in the form of a thumbs up/down/side motion. Video of the machine in action can be found [http://www.youtube.com/watch?v=xbLNBSTTrcE here.]
 

=== [[Three-speaker Chladni Patterns]] ===
[[Image:chladni_660hz|right|thumb|150px]]
This project uses three speakers to generate shapes on a circular aluminum plate depending on which frequency the speakers are playing at. Once the speakers hit a resonant frequency of the plate, salt migrates to the nodes (zero amplitude) regions of the plate to form distinct patterns.
 

=== [[Basketball]] ===
[[Image:Mechatronics2009Bball|right|thumb|150px]]
This project consists of a throwing arm propelled by a Pittman motor is mounted on a turntable and throws the ball into the "hoop." The hoop is wrapped in reflective tape and an IR emitter, receiver pair is used to sense where the IR is reflected most (the hoop with highly reflective tape). An ultrasonic sensor then pings the hoop for the distance of the hoop. With this information, the arm is able to "make a basket." A video can be found [http://www.youtube.com/watch?v=Y466dzP-qiY here].
 

=== [[Robot Drummer]] ===
[[Image:Robot_Drummer.jpg|thumb|400pix|right|Robot Drummer]]
The Robot Drummer is a device that demonstrates high-speed motor control by being able to drum when given commands. Through an RS232 cable, Matlab sends commands to a "master" PIC. The master then sends the commands to two "slave" PICs through I2C communication. The slaves take the commands and implement PID control of the motors.
 

=== [[Automated Fish Refuge]] ===
[[Image:Entire Fish Refuge|right|thumb|200px]]
The automated fish refuge allows for the controlled movement of a fish refuge with the goal of recording specific behavior. The mechanical design is completely adjustable and allows adjustable degrees of oscillating movement and orientation of the refuge. The program is primarily in MATLAB for ease of use and the velocity profile can be a sine, square, triangle, or any function that the user inputs. [http://www.youtube.com/watch?v=wGOKujMhN88 Check out the video!]

 

=== [[Marionette]] ===
[[Image: MarionettePicForIntro.JPG|right|thumb]] The Marionette Project focused on using RC Servos to make a puppet that would do a dance with the press of a button. There were 5 different dances programmed for the marionette, showcasing different styles of movement. The movement had 2 degrees of freedom thanks to using 5 bar linkages and 2 RC servos for each arm. Two more RC Servos were used on the back of the marionette to create the appearance of leg movement. The movements included a Hula dance, Jumping Jacks, and even some moves right out of Saturday Night Fever.

 

=== [[Monkeybot]] ===
[[Image:monkeybot_pic|thumb|right|200px|Monkeybot]]
The monkeybot is a swinging robot capable of moving side to side and climbing. It consists of a two link, double pendulum system with an electro-magnet on each end. At the pivot is a DC motor, which provides an input torque and allows the swinging system to gain energy and climb. Check out the video of the monkeybot climbing [http://www.youtube.com/watch?v=TA2VcH_GDJ0 here] and a later brachiation video [http://www.youtube.com/watch?v=0hfwJEVQyeQ&feature=related here].
 

=== [[PPOD-mini: 6-DOF Shaker]] ===
[[Image:PPOD_mini.JPG|thumb|200x200 px|right|PPOD-mini 6-DOF Shaker]]
The PPOD-mini is a miniaturized version of the Programmable Part-feeding Oscillatory Device ([http://lims.mech.northwestern.edu/projects/frictioninducedforcefields/index.htm PPOD]) found in the Laboratory for Intelligent Mechanical Systems (LIMS) at Northwestern. The PPOD-mini utilizes six speakers that act like actuators. The speakers are connected to a acrylic plate via flexures of tygon and iron. In its current implementation, the phase of the speakers can be controlled independently, giving the device six degrees of freedom. The movement of objects placed on the acrylic plate can be controlled by changing the phases of the speakers.

 

=== [[Automated Xylophone]] ===
[[Image:AutomatedXylophonePicture1.jpg|thumb|200x200 px|right|Automated Xylophone]]
The Automated Xylophone controls several solenoids which hit various pitches on an actual xylophone based on the note selected. The device has two main modes: using the keypad, a user can choose to either play notes in real time or store songs to be played back later. A video of the Automated Xylophone playing in real time mode can be found [http://www.youtube.com/watch?v=_ubpAEyq9kg here].

 

=== [[Vision-based Cannon]] ===
[[Image:SM_Gun_Camera_PIC_Setup.JPG|thumb|200x200 px|right|Vision-based Cannon]]
This project uses a webcam and Matlab to analyze an image and direct a modified USB Missile Launcher to fire at targets found in the image.

 

== ME 333 Final Projects 2008 ==

=== [[IR Tracker]] ===

[[Image:IR_Tracker_Main.jpg|right|thumb|200px]]

The IR Tracker (aka "Spot") is a device that follows a moving infrared light. It continuously detects the position of an infrared emitter in two axes, and then tracks the emitter with a laser. [[Media:MT_MS_AZ_TrackerVideo.mp4|See Spot Run.]]

'''Chosen the OUTSTANDING PROJECT by the students of ME 333.'''

 

=== [[Robot Snake]] ===
[[Image:HLSSnakeMain.jpg|right|thumb|200px]]

This remote control robotic snake uses servo motors with a traveling sine wave motion profile to mimic serpentine motion. The robotic snake is capable of moving forward, left, right and in reverse.

[http://www.youtube.com/watch?v=r_GOOFLnI6w Video of the robot snake]

Featured on [http://blog.makezine.com/archive/2009/03/well_documented_robotic_snake.html Makezine.com].
 

=== [[Programmable Stiffness Joint]] ===

[[Image:SteelToePic2.jpg|thumb|200px|The 'Steel Toe' programmable stiffness joint|right]]

The Programmable Stiffness Joint varies rotational stiffness as desired by the user. It is the first step in modeling the mechanical impedance of the human ankle joint (both stiffness and damping) for the purpose of determining the respective breakdown of the two properties over the gait cycle.

 

=== [[Magnetic based sample purification]] ===

 

=== [[Continuously Variable Transmission]] ===

[[image:CVT_system.JPG|thumb|200px]]

This prototype is a proof of concept model of a variable ratio transmission to be implemented in the 2008-2009 Formula SAE competition vehicle. The gear ratio is determined by the distances between the pulley halves which are controllable electronically.

 

=== [[Granular Flow Rotating Sphere]] ===
[[Image:Team-21-main-picture.JPG|right|thumb|200px]]
This device will be used to study the granular flow of particles within a rotating sphere. The sphere is filled with grains of varying size and then rotated about two different axes according to a series of position and angular velocity inputs.

 

=== [[Vibratory Clock]] ===

[[Image:Vibratory_Clock.jpg|right|thumb|Vibratory Clock|200px]]

The Vibratory Clock allows a small object to act as an hour "hand" on a horizontal circular platform that is actuated from underneath by three speakers. The object slides around the circular platform, impelled by friction forces due to the vibration. [http://www.youtube.com/watch?v=KhgTNCfdwZw Check it out!]

 

=== [[WiiMouse]] ===

[[Image:HPIM1027.jpg|right|thumb|200px]]

The WiiMouse is a handheld remote that can be used to move a cursor on a windows-based PC, via accelerometer input captured through device movement.

 

=== [[Intelligent Oscillation Controller]] ===

[[image:ME333_learning_oscillator.jpg|thumb|200px]]

This device "learns" a forcing function that is applied to a spring and mass system to match an arbitrary, periodic acceleration profile.

 

=== [[Baseball]] ===

[[Image:Baseball_Playfield.jpg|Sweet Baseball Game|right|thumb|200px]]

An interactive baseball game inspired by pinball, featuring pitching, batting, light up bases and a scoreboard to keep track of the game.

 

=== [[Ball Balancing Challenge]] ===

[[Image:Ballbalancechallenge.JPG|right|thumb|200px]]

An interactive game involving ball balancing on a touchscreen with touchscreen feedback and joystick action.

PIC32MX: I2C Communication between PIC32s

2010-02-10T06:47:29Z

EricWest: /* Circuit */

== Original Assignment ==

'''Do not erase this section!'''

Your assignment is to create code that allows two PIC32s to communicate via I2C.

== Overview ==

Summarize briefly what the page is about.

== Circuit ==

Include a schematic and give any part numbers. A photo of your circuit is OK, but not as a replacement for a schematic.

[[Image:I2C_circuit.PNG]]

== Code ==

Where possible, make it a single piece of well-commented cut-and-pastable code, or at least make each function that way, so others can easily copy it. Most comments should be in the code itself; outside the code (on the wiki) should only be explanatory comments that are too cumbersome to include in the code.

File:I2C circuit.PNG

2010-02-10T06:45:35Z

EricWest: This circuit is for I2C communication between 2 PIC32s. Two push button switches create digital inputs to the master that indicate which byte of data should be sent from the master to the slave. The slave then sends this byte back to master.

This circuit is for I2C communication between 2 PIC32s. Two push button switches create digital inputs to the master that indicate which byte of data should be sent from the master to the slave. The slave then sends this byte back to master.

PIC32MX: SPI Communication between PIC32s

2010-02-10T06:41:43Z

EricWest: /* Circuit */

== Original Assignment ==

'''Do not erase this section!'''

Your assignment is to create code that allows two PIC32 boards to communicate with each other via SPI.

== Overview ==

SPI or [http://en.wikipedia.org/wiki/Serial_Peripheral_Interface_Bus Serial Peripheral Interface] is a communication method that was once used to connect devices such as printers, cameras, scanners, etc. to a desktop computer. This function has largely been taken over by USB, but SPI can still be a useful communication tool for some applications. SPI runs using a master/slave set-up and can run in full duplex mode, meaning that signals can be transmitted between the master and the slave simultaneously. There is no standard communication protocol for SPI.

SPI is still used to control some peripheral devices and has some advantages over [[I2C communication between PICs|I2C]]'''CHANGE THIS TO OUR I2C PAGE!!''' (another type of serial data communication). SPI can communicate at much higher data rates than I2C. Furthermore, when multiple slaves are present, SPI requires no addressing to differentiate between these slaves. Compared to parallel buses, SPI has the additional benefit of requiring only simple wiring. However, one disadvantage when compared to I2C is that each slave must have a dedicated slave line. A slave line is not necessary when only one slave is present.

Peripheral devices that still use SPI:

• Converters (ADC and DAC)

• Memories (EEPROM and FLASH)

• Real Time Clocks (RTC)

• Sensors (temperature, pressure, etc.)

• Others (signal mixer, potentiometer, LCD controller, UART, CAN controller, USB controller, amplifier)

Basic Operation

SPI requires three lines, and the optional slave select, and is therefore often termed the “four wire” serial bus. These four lines are described in the table below.

{| border="1" cellspacing="2" cellpadding="3" align="center"
|-
!Line!! Name!! Description
|-
|SCK1||Serial Clock||Output from master
|-
|SDO1||Master Output, Slave Input||Output from master
|-
|SDI1||Master Input, Slave Output||Output from slave
|-
|SS1||Slave Select||Output from master (active low)
|-
|}

The master, as its name suggests, controls all communication. By controlling the clock, the master decides when data is sent and received. Within each clock cycle a full duplex communication is carried out; each side sends and receives one bit of information. Because there is no standard communication protocol, the master can either send data or both send and receive data, depending on the needs of the application. Likewise, the slave can either receive data or both receive and send data back to the master.

Using the “Slave Select” line, the master chooses which slave with which to communicate. Note that more than one slave may be selected, simply by applying a logic low to the desired SS lines, as illustrated in the schematic diagram shown above. If a given slave is not selected (its SS is high) it disregards signals sent by the master.

References

[http://www.totalphase.com/support/articles/article03/ SPI Background](www.totalphase.com)

[http://en.wikipedia.org/wiki/Serial_Peripheral_Interface_Bus SPI Wikipedia Article] (www.wikipedia.org)

[http://www.mct.net/faq/spi.html More Information] (www.mct.net)

== Circuit ==
[[Image:SPI_circuit.PNG]]

== Code ==

This code, coupled with the circuit diagram above, sends one of two bytes of data from the master to the slave, and back, so the master can output which byte is sent via [[PIC32MX: RS232|RS232]] communication protocol.

The data bytes are 0xAA and 0x23. Slave-LED0 toggles when 0xAA is received from the master, and slave-LED1 toggles when anything else (for example, 0x23) is received from the master.

File:SPI circuit.PNG

2010-02-10T06:38:52Z

EricWest: uploaded a new version of "Image:SPI circuit.PNG": This is the circuit used for SPI communication between two PIC32s. It uses two digital inputs from push button switches to control what byte of data is sent from the master to the slave. Edit: Added t

This is the circuit used for SPI communication between two PIC32s. It uses two digital inputs from push button switches to control what byte of data is sent from the master to the slave.

File:SPI circuit.PNG

2010-02-10T06:33:08Z

EricWest: This is the circuit used for SPI communication between two PIC32s. It uses two digital inputs from push button switches to control what byte of data is sent from the master to the slave.

This is the circuit used for SPI communication between two PIC32s. It uses two digital inputs from push button switches to control what byte of data is sent from the master to the slave.