Name: James Wann
Date: December 2, 1998
Group 4: Phonetics
Task 3: Gateway
1. So far, I have set up the basic functionality for a single point-to-point connection. The gateway is now capable of handling a single call from a phone, reading the extension number, and recording the incoming message. Also, in the case of a hangup from the phone, or an unnecessarily long silence period, the gateway will put the active line onhook. In the case of a computer making a call to the phone, I have created a separate thread that will interface with signaling to find this out. This thread sets an onhook line offhook and then plays any message that go through. I have also created some functions that enable the gateway to service the voice mail application. Specifically, voice mail tells the gateway to read a certain amount of digits pressed on the phone. In return, it receives the digits or a special prompt if the user hung up. This can happen in a loop. When voice mail decides it, it will order the gateway to send messages passing through. Afterwards, the gateway hangs up.
More recently, I have implemented my code to call part of data exchange’s code so that I can send
packets to and from the ethernet. We are successful in sending data to a computer from a phone. However, the voice coming out of the speakers is not what we want. I have written more details in part 2.
2. The biggest problem I am running into in programming the Dialogic card involves multithreading. I am planning to run four threads that will listen for an incoming call. Meanwhile, I am setting the main function to listen for a message from signaling. If a computer is trying to connect to a phone, signaling tells the main function to make a line available. A thread is "forced" to go offhook to send data. This works fine, since the listening thread seems to consider this an incoming call (I have also set it up so that the threads can distinguish between a call from a phone and a "call" from a computer). However, there is a problem when signaling asks the main function to hang up a line. The thread that is servicing the call can go onhook whenever it calls the procedure. However, an "outsider" cannot do this. I think the best way to resolve this is to set a variable. The thread will constantly refer to this and if it is set, the thread will go go onhook.
There was also an interface problem, involving data exchange. I had to change the format of my
recording from raw data to .WAV format in order for the voice to complement team 1’s specifications. This was not too much of a problem. However, we had to experiment with different parameters in order for the voice data to be heard properly. At this point, the sampling rate is too fast. As a result, the voice is discernible, but sounds like a high-speed dub with the volume up. This is the best we have done so far.
Finally, there was the simple hardware problem. Sometimes the Dialogic card would stop
functioning properly. It would do anything from simply refusing to service incoming cards to being unable to find or open any channels. I really appreciate Donna’s patience and willingness to help fix the hardware.
3. Most importantly, I learned how to program the Dialogic board to provide the functionality I need. I have found it surprisingly flexible and versatile in the features it provides. Because of these features, I am able to build a gateway according to the specifications that our group has agreed upon. This is good, since that would save me a lot of work. In addition, I developed some skills in creating workarounds for very serious problems. Because of the board’s limitations, as well as the fact that not everyone is using the same code, this became very important. Finally, I gained an understanding about what it takes to work with others in a big project. All of us need to provide for one another and compromises have to be made in order for all of us to succeed. In short, we have to work as a team.
4. One of the biggest problems I had with was communication. Throughout the semester, I had very little concern with interfacing. I believed I had to make the Dialogic card work as it should and then later make it complement everyone else’s code. What I should have done was work more closely with my teammates and hammer out the important details early. I am glad that at this point I know precisely what others want from me and that I have made clear to others what I need. Also, I should not make too many assumptions about the Dialogic board. Although it has many features, it has some serious limits that require a workaround or a special interface from another team.
5a. Interfaces provided to other teams:
Signaling:
Signaling creates an instance of the class gatewayInterface. It has the following functions:
lineQuery() – What signaling calls to tell gateway to reserve a line for servicing a call. Gateway looks for an available line, sets it offhook, and tells signaling the line number to use. The function returns this number. If no lines are available, the function returns 0.
hangup(int linenumber) – Signaling calls this function to tell gateway to set a particular line onhook.
Voicemail:
Voicemail creates an instance of the class gatewayRequest. It calls one function:
getDigits(int linenumber, int numberdigits) – Receives the number of the line referred to and the number of digits voicemail wants the gateway to listen to. getDigits returns the digits received as a string. If numberdigits = 0, then the gateway is requested to play messages to the phone and record messages from the phone.
Management:
Management creates an instance of the class gateway Interface. It has these functions:
numCallsMade() – number of calls made so far
linesInUse() – which lines are currently engaged
cntLatency() – percentage of packets lost on gateway
(The following functions are used because the gateway has an instance of data exchange’s code running on it. This is really data exchange’s interface with management)
percentPacketsReceived()
packetsReceived()
percentPacketsRecovered()
packetsRecovered()
percentPacketsLost()
packetsLost()
percentPacketsLate()
packetsLate()
numPacketsSent()
avgPacketRate()
cntPacketLate()
5b) Interfaces provided from other teams:
Data Exchange:
SendNextPacket(char* outPacket, char* destAddress) – receives a 960 byte packet in .WAV format and send it out to the designated IP address.
GetPacket(char* inPacket, int portNum) – Tells data exchange to send packets onto the gateway through the designated port number.
Signaling:
isValid(String number) – checks if the extension number entered in from a phone is valid. This returns an IP address.
handleIncomingCall(String number, int line) – requests signaling to make a connection to specified computer
gateHangup(String number, String lin) – informs signaling if someone hung up
References:
"Standard Runtime Library Programmer’s Guide for Windows NT", Dialogic Corporation, December 1997.
"Voice Programmer’s Guide for Windows NT", Dialogic Corporation, September 1996.
"Voice Features Guide for Windows NT", Dialogic Corporation, December 1997.