This simple behavior of a receiver, just summing up, is close to the best possible as stated by the Theory of Information. (At least when a lot of signal periods are used per bit transmitted.)
The Shannon theorem tells the following. If b is the maximum number of bits that can be transmitted errorless, r the number of samples taken by the receiver, S the power of the signal received and N the power of the noise received, b = r/2 log2 (1 + S/N).
There is a way to increase slightly the yield of the transmission, closer to the limit. The cheat is the receiver sends a strong signal back towards the emitter to tell the state of the sum it is doing. That is the state of the receiver accumulator. This allows the emitter to stop the emission when it becomes clear it is no more necessary. Indeed, the Brownian behavior of the accumulator, due to the noise it is summing up, sometimes makes it diverge in the right direction up to a level that makes it statistically impossible for the receiver to make a wrong guess about the data bit being transmitted. The criterion I used is the receiver accumulator must contain a value proportional to the square root of the amount of remaining periods while receiving the bit.
This method being very expensive and yielding very few advantage I doubt it will ever be used for data transmission. Perhaps for space probes? Yet it works. At least that's the result shown by following data transmission simulation programs written in C++. They assume only I bits are being transmitted (100 of them, and each bit takes 10000 signal periods), they use no modulation (to make things simple). The attenuation of the signal is computed according to the formula above, so it would be possible to transmit exactly 100 bits correctly if the transmission was perfect.
This first program simulates a normal transmission. The result is 92% of the bits are transmitted correctly.
#include <stdlib.h> #include <iostream.h> #include <math.h> // Return a noise float number between -7 and 7 // whose average square is 1 double fn_noise () { int i, n = 0; for (i = 1; i <= 8; i++) n += rand () / 8 - rand () / 8; return ((double) n / (double) RAND_MAX) * 6.9293 ; } void main () { int periods_per_bit = 10000; int number_of_bits = 100; double attenuation = sqrt (pow (2, 2.0 / periods_per_bit) - 1); int i, j; int hits = 0; double acc = 0; double signal = 1 * attenuation; for (i = 1; i <= number_of_bits; i++) { acc = 0; for (j = 1; j <= periods_per_bit; j++) { acc += signal + fn_noise (); } if (acc > 0) hits++; } cout << "Hits : " << hits << endl; }
This second program allows the emitter algorithm
to use a knowledge of the content of the receiver
accumulator to calculate the signal emitted.
#include <stdlib.h> #include <iostream.h> #include <math.h> // Return a noise float number between -7 and 7 // whose average square is 1 double fn_noise () { int i, n = 0; for (i = 1; i <= 8; i++) n += rand () / 8 - rand () / 8; return ((double) n / (double) RAND_MAX) * 6.9293 ; } void main () { int periods_per_bit = 10000; int number_of_bits = 100; double attenuation = sqrt (pow (2, 2.0 / periods_per_bit) - 1); int i, j; int hits = 0; double acc = 0; double signal; double energy_emitted = 0; double energy_ratio = 0; for (i = 1; i <= number_of_bits; i++) { acc = 0; for (j = 1; j <= periods_per_bit; j++) { signal = 1.58; if (acc > sqrt (periods_per_bit - j) / 2) { signal = 0; } energy_emitted += signal * signal; acc += signal * attenuation + fn_noise (); } if (acc > 0) hits++; } cout << "Hits : " << hits << endl; energy_ratio = energy_emitted/(number_of_bits*periods_per_bit); cout << "Energy : " << energy_ratio * 100 << " %" << endl; }
The result is now 96% of the bits are
being transmitted correctly.
The yield of this method depends on the nature of the noise. I tried it out with a few different noise types and always got good results.
I tried out a symmetric behavior : cancel the emission when it becomes obvious the bit can no more be received correctly. This spares a few energy that can be used to increase the emission amplitude too. But the yield is very weak and almost zero with some noise patterns. On the other hand it is interesting to emit a stronger signal when it seems the receiver is receiving a bit wrongly, in order to correct it. I don't know the optimal formula for the emission amplitude in function of bit emission period and receiver accumulator status.
In the case of a remote space probe the powerful feedback from the Earth receiver towards the emitting probe cannot occur while the probe is emitting a data bit. Due to the time delay. The solution is the probe gathers a bunch of data into a big file and transmits that file over and over again, using each time just a few periods for each bit. The receiver on Earth uses an accumulator for each bit and sends the states of all of them with a strong signal back towards the probe. That way the probe has the time to receive the state of each receiver accumulator without loosing any bandwidth. On Earth, the whole file slowly becomes correctly received. All accumulators together contain more and more accurate data till nearly all of them are correctly received. When the transmission ends the probe can send specific information to point out the few bits that are being wrongly received. This allows for even more energy saving. (The classic way to do this is to send a checksum after each packet of bits and let the receiver ask the emitter to re-emit the few packets that seem to have been wrongly received.)