View Question
Q: Algortims ( Answered ,   1 Comment )
 Question
 Subject: Algortims Category: Computers > Algorithms Asked by: cool2-ga List Price: \$20.00 Posted: 04 Jul 2004 21:30 PDT Expires: 03 Aug 2004 21:30 PDT Question ID: 369746
 ```Suppose a file of 10,000 bytes is to be sent over a line at 2400 bps. a. Calculate the overhead in bits and time in using asynchronous communication. Assume one start bit and a stop element of length of one bit, and 8 bits to send the byte itself for each character. The 8-bit character consists of all data bits, with no parity bit. b. Calculate the overhead in bits and teim using synchronous communication. Assume that the data are sent in frames. Each frame consists of 1000 characters = 8000 bits, and an overhead of 48 control bits per frame. c. What would the answers to parts a) and b) be for a file of 100,000 characters. d. What would the answers to parts a) and b) be for the original file of 10,000 characters except at a rate of 96000 bps.```
 ```Hi cool2, a) For each 8-bit character sent, there is one start bit and one stop bit, therefore each character requires 10 bits to send. The stated line speed is 2400 bps, with ?bps? standing for ?bits per second?. [ http://www.computerdictionary.info/computer-term-details/bps ] Also, one needs to know that one byte is equal to 8 bits, and each is just a quantity of information. [ http://www.cknow.com/tutorcom/term06_bitsbytes.htm ] Doing some simple calculations, the file we?re trying to send is 10,000 bytes, which is the same as 80,000 bits. For every 8 of those bits, we must add 2 more, one for the start bit and one for the stop bit, so the in reality 100,000 bits must be sent. 100,000 bits at a rate of 2400 bits per second would require (100000/2400) = 41.6666 seconds. Because 2 out of every 10 of those bits sent are either a start or stop bit, collectively called ?overhead?, we can say that 20,000 bits of overhead are transmitted that collectively require (20,000/2400) = 8.3333 seconds to send. b) If each frame consists of 8000 bits plus 48 control bits, this is 8048 bits, and we could say that (48/8048) = 1/167.6666th of each frame?s size is overhead. Again, a file of 10,000 bytes consists of 80,000 bits. Of these bits, (80,000/167.6666) = 477 bits will be overhead. So, at a bit rate of 2400 bits per second, 80477 bits will require 33.532 seconds to send. Of this 1/167.6666th of them will be spent sending overhead bits, therefore the overhead of 477 bits will require (33.532/167.6666) = 0.2 seconds to send. c) If the file to be sent were ten times greater (100,000 characters), all of the overhead sizes and transmit times will be ten times greater as well. For part (a), the overhead would be (20,000x10) = 200,000 bits and would require (8.3333x10) = 83.333 seconds to transmit. For part (b), the overhead would be (477x10) = 4,770 bits and would require (0.2x10) = 2 seconds to send. d) If the original file (10,000 bytes) were to be sent at the rate of 96000 bps, this rate is (96000/2400) = 40 times faster than the original rate. So, for part (a), the overhead of 20,000 bits would require (8.3333/40) = 0.208 seconds to send. For part (b), the overhead of 477 bits would require (0.2/40) = 0.005 seconds to send. Clearly, the synchronous communication mode is much more efficient for sending larger files, as it requires a smaller percentage of the total bits sent to be overhead. More information on the differences between these two modes can be found at: [ http://www.erg.abdn.ac.uk/users/gorry/eg2069/async.html ] I trust this information has shed light on your questions, but if you require a clarification, please request one, especially before rating this answer. Thank you for bringing this question to Google Answers! Regards, -Andrewxmp```
 cool2-ga rated this answer: `Outstanding detailed explanation of the answer. Thanks so much.`
 `Is this for a problem set or something?`