SI204 Spring 2010
Programming Project 1
Audio Speed Dial
Pre-Coding
Analysis: Due at start of class on Monday, 1 February 2010. Turn in a flowchart or
pseudocode (either neatly hand-drawn or using a drawing/text tool) for a Step 3 solution for the program in Project 1. Make sure that your
flowchart/pseudcode clearly shows how you intend to solve the conceptually difficult parts of the
project. Note that you DO NOT have to
actually code up the solution as part of the Pre-Coding Analysis. This “Step 0”
analysis is worth 5 points of your final project grade.
1.
Note that this Pre-Coding Analysis is NOT a routine out-of-class
assignment, but rather is part of the project and therefore subject to the
Department's policy concerning programming projects.
2.
Recall that the Department’s policy states that for a
programming project “midshipmen may give no assistance whatsoever to any person
and may receive no assistance whatsoever from any person other than the
midshipman’s instructor for the course assigning the project.” Please view http://www.usna.edu/CS/academics/ProgrammingPolicy.pdf
for additional details on this issue.
Executive Summary
Touch-tone dialing is used to signal a number to connect to the
call switching center. It is a
trademarked form of dual-tone multi-frequency signaling that is in the
voice-frequency band. Every time a key
is pressed on a touch tone phone, two distinct frequencies are transmitted from
the phone to the call switching center.
The switching center then determines the number pressed from the two
tones. The consequence of this system is
that you do not have to press a key to make a call if you can generate the
tones required.
For this project, you will write a program
that creates a sound wave (as a .wav file) that plays a telephone number. By holding the telephone up to your computer
speakers, playing the file will dial a number on your telephone. (Caveat:
cordless phones don’t give you the direct access you need – test with a corded
phone instead!)
Due Dates and Honor
The Pre-Coding
Analysis will be due in class on Mon Feb 1 2010.
This project will be due by the close of
business on Thursday Feb 11, 2010. See
the course policy for details about due dates and late penalties.
Again, this is a Programming Project, and it is very
important that you understand and abide by the Department's policy concerning
programming projects. Please view: http://www.usna.edu/CS/academics/ProgrammingPolicy.pdf
Extra Information
1. Sound and wave
files
What our ears
perceives as sound is simply a wave moving through the air that vibrates our
eardrums. This wave propagates by the compression and rarefaction of the
atmosphere (Figure 1). This change in air density at a single point can
be graphed with respect to time (Figure 2) This change in air density
over time is the data that describes any sound wave and is encoded in a wave
file.
|
|
|
|
Figure 1 |
Figure 2 |
A wave file is data consisting of two
parts: a header chunk that describes the amount of information that it
contains and a data chunk that contains numbers that correspond to sound
amplitudes (or air pressure) over time. This data chunk is exactly what is
encoded on a compact disc. The header portion is not required for CDs
because the encoding options are fixed. To understand the files you will be
creating, you need to understand the options for encoding a wave file.
The header chunk contains the following
pieces of information (among others):
sample rate: samples per second
bits per channel: 8 or 16
number of channels: mono or stereo
Channels should be self-explanatory.
Sample rate and bits per channel are necessary because computers can only handle
discrete numbers. In the real world, waves are continuous but computers
need to approximate to represent continuous numbers. This is shown below.
In order to represent a continuous wave,
the computer will connect a series of points that are close to the original
waveform. The red, smooth line represents the original
waveform. The black, jagged line represents the waveform played by the
computer. This example shows 4 bits per channel (24=16 levels) and a sample taken every 0.1 seconds.
This means the sample rate is 10 Hz (=1/0.1 seconds).
We will use mono
(1 channel) 8-bit encoding at a sample rate of 8000 Hz.
2. Useful data
A basic sine wave is described by the
following formula:
y(t)
= Amplitude * sin (2 * π * frequency_in_Hertz * t)
where y(t) is the value of the waveform at
time t (t is measured in seconds).
The tone for a single telephone digit is
created by adding together two sine waves at different
frequencies. For instance, a ‘1’ is made
by adding sine waves of frequency 697 Hz and 1209 Hz. So the sound for a ‘1’ is described by this
formula:
y(t) = Amplitude * sin (2 * π * 697 * t) + Amplitude * sin (2 * π * 1209 * t)
The table below shows the other frequency
combinations:
|
Hz |
1209 |
1336 |
1477 |
|
697 |
1 |
2 |
3 |
|
770 |
4 |
5 |
6 |
|
852 |
7 |
8 |
9 |
|
941 |
* |
0 |
# |
Touchtone Frequencies
3. Useful code
A Visual Studio “project” with some needed
code is provided: starter.zip. Download this and
unzip it somewhere (your X: drive would be ideal – if you haven’t already, set
up access to that from Bancroft; see the course home page for help). Then from
Visual Studio, choose “Open Project” and browse to and open “Project1.sln.”
A file project1.cpp is provided – this is the only file you should change and
submit! (i.e. do not modify other
.cpp or .h files). Along with the standard stuff, this file has some starter
code for you. At the top, to provide
access to the code that will generate sound files for you, is this:
#include "Wave.h"
Then in main() is the following code.
Start your code after this:
WaveFile
out;
//creates WaveFile object named out
string fileName = "frequency.wav"; //creates variable to
hold wave file name
bool success = out.OpenWrite(fileName.c_str()); //link ‘out’
object to filename
if (success == false)
{
cout <<
"Failed to open output file "
<< fileName << endl;
cout <<
"Close other applications using the file and
try again." << endl;
return 0;
}
out.SetupFormat(8000,8,1);
//sampleRate = 8000 Hz
//bitsPerSample = 8, channels = mono
Whenever you have a number y that
you want to write to the wave file use the statement:
out.WriteSample(y);
y must be a continuous number between -1
and 1. You also must output y to the screen. This will aid
your debugging, but you will only see the last few samples on the screen.
See the sample output below for an example.
Note: if you make a statement such as
out.WriteSample(0.5)
you may receive a compile error regarding
“ambiguous overloaded function.” This will make sense later – for now, instead
always use a variable (such as y) instead of a constant (such as the literal 0.5)
when you use WriteSample.
Also,
the constant PI has been provided for you. You can use it just like a variable,
e.g.
area = 2 * PI * radius * radius;
Details
The project is divided up into four steps.
You are strongly encouraged to solve each step completely - including thorough
testing - before you move on to the next step. You must submit each step on Blackboard after you complete it (see
details later).
Also, remember that your program’s source
code must
comply with the Required Style Guide in order to
maximize the grade you receive on this project.
Compile your program often so you don’t end up with a snake’s nest of
errors at your first compile, and occasionally save a backup copy of your
program’s source code in case your sponsor’s dog eats your X drive.
Step 1: Create a waveform from a user
frequency and write it to a wave file
Write a program that reads in a frequency (in
Hz) from a user and creates a wave file named frequency.wav with the
corresponding waveform. This waveform should have an amplitude = 0.5 and a
length of 1 second. Sample output is shown below.
If your sample output looks reasonable
(try 800 Hz), try playing the sound by double-clicking on the .wav file (it
will be in the same directory as your .cpp file). This will run Windows Media
Player or a similar player. You should
be able to hear a 800 Hz tone.
Key tip #1: If your program doesn’t stop
running, click on the output window, then press Ctrl-C to kill it.
Key tip #2: You MUST close Windows Media
Player after you play your sound.
Key tip #3: Your output may not exactly
match the sample output shown below. How
can you tell though if it is truly outputting a 800 Hz wave? (think about the
period of the wave)
Key tip #4: Until you get to step 4, you
should need no more than 40 lines of code (at most). Otherwise, you’re probably not on the right
track.
Key tip #5: Save a complete copy of
each step when it works before you go on to the next step.
Key tip #6: If you’re not sure why your
program doesn’t work, add additional “cout” statements to test the values of
variables at different points in your program (or just to see how far your
program is getting).
Step 2: Create a waveform from a user
frequency and amplitude and write it to a wave file
Write a program that reads in a frequency
and amplitude from the user and creates a wave file named amplitude.wav with
the corresponding waveform. See sample output for expected values.
Check that the amplitude provided by the user is between 0 and 0.5. If it is outside this range, set it to 0.5.
Step 3: Create a wave file that dials a
single button
Write a program that creates a file named
star.wav that dials the star key. It should still get the user input for
the amplitude and be one second in length. Check that the amplitude is
between 0 and 0.5. If it is outside this range, set it to 0.5. It should
sound like your phone when the star key is pressed. Here’s a sample with amplitude 0.5:
Step 4: Create a
wave file that dials a five digit extension
Write a program that creates a single wave
file named dial.wav that dials a phone number provided by the user. In
particular, the user will enter any number of digits (or # or * symbols), terminated
by an X.
Use the frequencies given above to make a
dual tone waveform for each number (0.1 seconds for each) separating
each number by 0.1 seconds of silence (how do you think silence should be produced?)
It should still get the user input for the amplitude. Check that the
amplitude is between 0 and 0.5. If it is outside this range, set it to
0.5.
You can stop outputting each “y” value to
the screen now. Instead, output the frequencies that you are using for each
tone.
Once you think it is working, hold your
phone up to the speakers on your computer and play the sound! Try calling 30123 (voicemail) or some other
number you like. Remember that you
probably need a corded (NOT cordless) phone for this to work. If you really can’t get a corded phone,
compare your sound with the 30123.wav file provided on the course calendar. You
can also use the 30123.wav file to test out how the “audio” dialing should work.
Tip #1: Your program should work for any
number of digits! (not just 5). Think first about how you will handle this.
Tip #2: Don’t forget to save a complete
copy of Step 3 before you start this!
What to submit and how it will be graded
You will only submit a solution to one
of the four steps above. You will submit your solution for the highest numbered
step that actually works! For example, if you had a working solution to
Step 3, but only a partially completed solution to Step 4, you would submit
your Step 3 solution.
The maximum points for a Step 0
solution is 5 pts, for a Step 1 solution, 30, for a Step 2 solution, 50, for a
step 3 solution, 70, and for a Step 4 solution, 100 pts. How points are
assigned for a particular solution is at your instructor's discretion, however,
program structure, documentation, variable names, etc. will be considered along
with program correctness. Important points:
·
If your program does not compile as submitted, you will receive
a zero.
·
If your program does not give correct results, penalties will be
substantial. If you can't get a working Step k+1 solution, submit your Step k
solution instead.
·
Your program must read input and write output in the exact
format specified in this project description.
·
Your program’s source code must comply with the Required
Style Guide in order to maximize the grade you receive on this project
There will be both a paper and an electronic part to your
submissions. The paper submission can be handed to your instructor in class or
slid under their office door (do NOT put it in their mailbox or outside their
door). For the purposes of any late penalties, your project is not considered
submitted until your instructor receives BOTH the electronic and paper portions
of your submission.
Reminder -- You MUST submit (via Blacboard) a working
solution for EACH of the above steps as you complete them.
Submit just the project1.cpp file. It’s okay if you make some changes to a step
after you submit it, but we want to see the progression of your steps. The
individual steps will not be graded for style or functionality – as long as it
looks reasonably like you submitted the steps, what counts will be the style
and functionality of the final result (submit on Blackboard as such).
Electronic submission: Unless otherwise specified by your
instructor, electronic submission should be made via Blackboard. You will
submit only your project1.cpp file (the other files should not be changed).
Submit each step as you complete it, then when all finished submit your final
project1.cpp file under the “Final Submission” link (regardless of how many
steps you completed).
Here's what to
submit (follow instructions for one
of the following):
Step 0 Pre-coding
Analysis: (5 pts). See description at start of project.
Step 1 submission: (max 30 pts)
Paper: Submit a printout of your source
code and a screen capture showing your program being run on input 800. You will also
submit a signed copy of the project
cover page (see SI204 home page).
Electronic: See above.
Step 2 submission: (max 50 pts)
Paper: Submit a printout of your source
code and a screen capture showing your program being run on input 800 and 1.5. You will also
submit a signed copy of the project
cover page (see SI204 home page).
Electronic: See above.
Step 3 submission: (max 70 pts)
Paper: Submit a printout of your source
code and a screen capture showing your program being run on input 1.5. You will also submit a signed copy of the project cover page (see SI204 home
page) .
Electronic: See above.
Step 4 submission: (max 100 pts)
Paper: Submit a printout of your source
code, a screen capture showing your program being run on input 30123X. You will also
submit a signed copy of the project
cover page (see SI204 home page).
Electronic: See above.
Extra Credit #1:
(Maximum of 5 points) Add a “pause” capability to your program, so that a
“number” entered of P causes the sound to pause with silence for an extra 0.1
seconds. Thus, I should be able to “dial” the number 30123PP36811#X.
Extra Credit #2:
(Maximum of 5 points) Submit a separate program that first reads a
name from the user, then reads phone numbers from a file that looks like this:
John 36811X
Sally 4105551212
Mail 30123X
Find the phone number that matches the name and output the
dialing waveform for that number to an appropriately named file. Then ask the
user if they want to do any more names and repeat if so.