|
I came across this paragraph in an article about signal processing. Addition of redundant bits for improving the error probability leads to bandwidth expansion of the transmitted signal by an amount equal to the reciprocal of the code rate. (page 16) http://www.ece.rice.edu/~ashu/publications/encylopedia.pdf I am not sure I understand this. why adding redundancy means increasing the bandwidth? it will just take more time to transmit this signal, no? Please help me clarify this. thanks. |
|||||||||||
|
|
As per @JasonR's suggestion (but no longer succinct...., though hopefully still correct...) Error-control coding creates redundant symbols that are also transmitted over the channel. A simple description of what happens is as follows. The data symbols are divided into chunks of $k$ (data) symbols and to each such chunk is appended a chunk of $n-k$ redundant symbols to create a codeword of $n$ symbols. The rate of the code is $R = \frac{k}{n}$ since $n$ symbols must be transmitted over the channel in order to get $k$ data symbols across more reliably. The device that creates and appends the redundant symbols is called an encoder. Note that the encoder accepts $k$ symbols as input and spits out $n > k$ symbols as output. Now, it is possible for the encoder to send the $n$ symbols to the transmitter for transmission using the system and signaling design, modulation method that is already set up. In this case, the channel signaling rate is not changed at all and so the bandwidth remains the same. However, the codeword, consisting of $n$ symbols, takes longer to transmit than the $k$ data symbols would have using the same transmitter and channel that we have available. There is also the issue of what happens to the next chunk of $k$ data symbols that are knocking at the encoder input while the encoder is still busy sending the redundant symbols to the transmitter. So this scheme can be implemented if we don't really care about how long it takes to transmit the data (which is presumed to be a finite-length file or audio track (say) and not a (potentially) infinite never-ending stream of data all of which needs to be delivered to the receiver, and are willing to have lots of buffers between the encoder and the transmitter to save the codewords being generated until the transmitter gets around to transmitting them. We will also need buffers at the receiver where the redundant symbols will be stripped off, and the data symbols delivered to the destination in chunks of $k$ symbols followed by $n-k$ intervals of dead silence: buffering can be used to save the $k$ symbol chunks and patch them into a continuous stream of data. The alternative, which most people opt for, is to modify the transmitter and receiver so that each channel symbol takes less time (by a factor of $R$) to be transmitted, so that the $n$ symbols of the codeword can be transmitted in the same time that the $k$ data symbols would have been in absence of error-control coding. The increase in the signaling rate means that the transmitter output requires a larger bandwidth (by a factor of $R^{-1}$) for transmission. The channel thus must have larger bandwidth too, which can create problems if wireless channels are being used. Frequency bands are allotted by government agencies and if your transmitter is already using the full spectrum allotted to you, a Plan B and a complete re-design might be needed. These systems with larger bandwidth also need buffers at the transmitting end as well as the receiving end, but only two relatively small ones of $k$ symbols at both ends. The two buffers precede the encoder and are used in ping-pong fashion. The data source is reading in $k$ symbols into one buffer, say one symbol every $T$ seconds, and thus taking a total of $kT$ seconds to fill the buffer. During this time, the encoder reads out the $k$ data symbols from the other previously filled buffer at a rate of one symbol every $RT$ seconds for a total of $k(RT)$ seconds. The data symbols are also sent on to the transmitter while the $n-k$ redundant symbols are created within the encoder, which then spends the remaining $kT-k(RT) = (n-k)(RT)$ seconds sending the $n-k$ redundant symbols to the transmitter at a rate of one every $RT$ seconds. At the end of a $kT$ second period, the data source starts to fill the buffer just emptied by the encoder, while the encoder starts to accept data from the buffer just filled by the data source. If you are still following all this, note that the encoder and the transmitter are working with a clock that is running at a higher rate (by a factor of $R^{-1}$) than the clock of the data source, while the clock signals to the buffers are alternately at the low rate (when connected to data source) and at high rate (when connected to encoder). Similar things occur in reverse between the receiver output and the data destination but I will skip the details. A third alternative, as pointed out by Bryan, is to change the modulation format on the channel so that, for example, instead of transmitting one channel bit with each channel symbol (as in BPSK), you transmit more channel bits per symbol (e.g. use QPSK to send two bits per channel symbol). In this case, there need not be any increase in bandwidth (which is primarily determined by the symbol rate (rate in baud)). A common use of the BPSK/QPSK usage is the use of rate-$\frac{1}{2}$ convolutional coding which would double the bandwidth if BPSK were used, but by switching to QPSK, the bandwidth remains the same even when coding is used. However, as also noted by Bryan, the transmitter and receiver become more complicated. |
|||||||||||
|
