एक सॉफ्टवेयर (सॉफ्टवेयर) बनाओ!

Question

उद्देश्य

सिम्युलेटेड सादे पुराने टेलीफोन सेवा (POTS) पर जितनी जल्दी हो सके डेटा संचारित करने के लिए मो ड्युलेटर / डे ओमुलेटर जोड़ी डिज़ाइन करें ।

कदम

1. कुछ यादृच्छिक ( /dev/randomया जैसे) डेटा उत्पन्न करें जो संचारित करने में 3-4 सेकंड लगेंगे
2. एक ऑडियो फ़ाइल का उत्पादन करने के लिए अपने न्यूनाधिक के साथ डेटा को संशोधित करें
3. POTS सिम्युलेटर के माध्यम से ऑडियो फ़ाइल पास करें । यदि आपके पास पाइथन / स्किप नहीं है तो आप फॉर्म के साथ फाइल अपलोड कर सकते हैं, या JSON API अनुरोध कर सकते हैं।
4. बाइनरी डेटा के लिए ऑडियो फ़ाइल को फिर से प्रदर्शित करें
5. सत्यापित करें कि इनपुट और आउटपुट समान-ईश * हैं (प्रत्येक 1000 बिट्स में से 1 को दूषित किया जा सकता है)
6. स्कोर ऑडियो फ़ाइल की लंबाई (बिट्स / सेकंड) द्वारा विभाजित बिट्स की संख्या है

नियम

• इनपुट फ़ाइल 3-4 सेकंड, 44.1 kHz, मोनो होनी चाहिए।
• सिम्युलेटर को 30 dB के SNR के साथ चलाएँ (यह डिफ़ॉल्ट है)
• डेमोडुलेटर को संचरित डेटा को 10 ^-3 (1 प्रति हजार बिट्स) से अधिक की बिट त्रुटि दर के साथ फिर से बनाना होगा ।
• कोई डिजिटल संपीड़न की अनुमति नहीं है (यानी डेटा को ज़िप करना। यह चुनौती के दायरे से बाहर है।)
• 4 kHz से अधिक आवृत्तियों में डेटा को हटाने का प्रयास नहीं किया गया। (मेरे फ़िल्टर सही नहीं हैं, लेकिन वे अपेक्षाकृत कम संख्या में टैप के साथ POTS की तरह हैं।)
• यदि आपके मॉडेम प्रोटोकॉल को रिसीवर को सिंक्रनाइज़ / कैलिब्रेट करने के लिए एक छोटी प्रस्तावना (1 सेकंड से अधिक नहीं) की आवश्यकता होती है, तो इसे दंडित नहीं किया जाता है।
• यदि संभव हो, तो कृपया ऑडियो फ़ाइल को कहीं सुलभ रूप से होस्ट करें ताकि हम बीप और बूप्स के कैकोफोनी को सुन सकें।

उदाहरण

यहां एक उदाहरण नोटबुक है जो सरल "ऑन-ऑफ कीिंग" के साथ मॉड्यूलेशन / डिमोड्यूलेशन को दर्शाता है (ऑडियो नमूने शामिल हैं!)।

यह 100 (बिट्स / सेकंड) स्कोर होगा। ध्यान दें कि यह बहुत खराब 5 डीबी एसएनआर के साथ संचारित हो रहा है।

Comments

क्या यह एक साधारण "द्विआधारी डेटा को संकुचित करें" चुनौती से अलग है? यदि हां, तो क्या आप स्पष्ट कर सकते हैं कि यह कितना भिन्न है?

— दरवाज़े

यहां आप डेटा को संशोधित कर रहे हैं (इसे कुछ एनालॉग में बदल रहे हैं) फिर रिवर्स। शायद इसे "एनालॉग कम्प्रेशन" कहा जा सकता है

— Nick T

क्षमा करें, मुझे यकीन नहीं है कि मैं समझता हूं कि यह चुनौती कैसे काम करती है। शब्द "मॉड्यूलेट" आपके द्वारा लिंक किए गए विकिपीडिया लेख में भी दिखाई नहीं देता है। क्या आप अधिक पृष्ठभूमि जानकारी शामिल कर सकते हैं, या कल्पना को स्पष्ट कर सकते हैं?

— दरवाज़े

wget wikipedia.org/Special:Random | grep title | texttospeech audio.wav speechtotext POTSaudio.wav | wget wikipedia/wiki/$text

— TessellatingHeckler

यह एक भयानक चुनौती है, मैं उत्तर प्रस्तुत करने का समय खोजने की कोशिश करूंगा!

— गोआटइनइमैकाइन

Answer 1

MATLAB, 1960 बीपीएस

यहाँ मेरा अद्यतन प्रयास है:

fs = 44100; %44.1kHz audio rate
fc = 2450;  %2.45kHz carrier - nice fraction of fs!
fsym = fc/5; %symbol rate

tmax = 4; %about 4 seconds worth

preamblesyms = 6;

t = 1/fs:1/fs:(tmax+preamblesyms/fsym);

symbols = preamblesyms+fsym*tmax;
symbollength = length(t)/symbols;
bits = symbols*3;
bitstream = [zeros(1,preamblesyms*3),rand(1,bits-preamblesyms*3)>0.5]; %Add a little preamble of 18 bits
data = bin2dec(char(reshape(bitstream,3,symbols)'+'0'))';

greycode = [0 1 3 2 6 7 5 4];

%Encode the symbols using QAM8 - we use effectively grey code so that
%adjacent symbols in the constellation have only one bit difference
%(minimises error rate)
encoded = zeros(2,symbols);
encoded(1,data==1) = 1/sqrt(2);
encoded(1,data==3) = 1;
encoded(1,data==2) = 1/sqrt(2);
encoded(1,data==7) = -1/sqrt(2);
encoded(1,data==5) = -1;
encoded(1,data==4) = -1/sqrt(2);
encoded(2,data==0) = 1;
encoded(2,data==1) = 1/sqrt(2);
encoded(2,data==2) = -1/sqrt(2);
encoded(2,data==6) = -1;
encoded(2,data==7) = -1/sqrt(2);
encoded(2,data==4) = 1/sqrt(2);

%Modulate onto carrier
carrier = [sin(2*pi*fc*t);cos(2*pi*fc*t)];
signal = reshape(repmat(encoded(1,:)',1,symbollength)',1,[]);
signal(2,:) = reshape(repmat(encoded(2,:)',1,symbollength)',1,[]);
modulated = sum(signal.*carrier)';

%Write out an audio file
audiowrite('audio.wav',modulated,fs);

%Wait for the user to run through the POTS simulator
input('');

%Read in the filtered data
filtered=audioread('audio.pots-filtered.wav')';

%Recover the two carrier signals
preamblecos = filtered(symbollength+1:symbollength*2);
preamblesin = filtered(symbollength+1+round(symbollength*3/4):symbollength*2+round(symbollength*3/4));

%Replicated the recovered carriers for all symbols
carrierfiltered = [repmat(preamblesin,1,symbols);repmat(preamblecos,1,symbols)];

%Generate a demodulation filter (pass up to 0.66*fc, stop at 1.33*fc
%(really we just need to kill everything around 2*fc where the alias ends up)
d=fdesign.lowpass('Fp,Fst,Ap,Ast',0.05,0.1,0.5,60);
Hd = design(d,'equiripple');

%Demodulate the incoming stream
demodulated = carrierfiltered .* [filtered;filtered];
demodulated(1,:)=filtfilt(Hd.Numerator,1,demodulated(1,:));
demodulated(2,:)=filtfilt(Hd.Numerator,1,demodulated(2,:));

%Split signal up into bit periods
recovereddemodulated=[];
recovereddemodulated(1,:,:) = reshape(demodulated(1,:),symbollength,symbols);
recovereddemodulated(2,:,:) = reshape(demodulated(2,:),symbollength,symbols);

%Extract the average level for each bit period. Only look at the second
%half to account for slow rise times in the signal due to filtering
recoveredsignal=mean(recovereddemodulated(1,round(symbollength/2):symbollength,:));
recoveredsignal(2,:)=mean(recovereddemodulated(2,round(symbollength/2):symbollength,:));

%Convert the recovered signal into a complex number.
recoveredsignal=recoveredsignal(2,:) + 1j*recoveredsignal(1,:);

%Determine the magnitude and angle of the symbol. The phase is normalised
%to pi/4 as that is the angle between the symbols. Rounding this to the
%nearest integer will tell us which of the 8 phases it is closest to
recoveredphase = round(angle(recoveredsignal)/(pi/4));
recoveredphase = mod(recoveredphase+8,8)+1; %Remap to an index in the grey code vector.

%Determine the symbol in the QAM8 constellation
recoveredencoded=greycode(recoveredphase);
recoveredencoded(1:preamblesyms)=0; %Assume the preamble is correct for comparison

%Turn it back in to a bit stream
bitstreamRecovered = reshape(dec2bin(recoveredencoded)'-'0',1,[]);

%And check if they are all correct...
if(all(bitstream==bitstreamRecovered))
    disp(['Woop, ' num2str(fsym*4) 'bps']);
else
    error('Its corrupt Jim.');
end

अपने पहले प्रयास के बाद से, मैंने लगभग थोड़ा सा खेला है। अब शुरुआत में एक छोटी सी प्रस्तावना है (18 बिट अवधियों, लेकिन कम हो सकती है) जिसमें सिर्फ एक कोसिन तरंग होती है। मैं इसे निकालता हूं और इसे डिमॉड्यूलेशन के लिए सही ढंग से चरणबद्ध साइन और कोज़ेन कैरियर्स बनाने के लिए दोहराया है - क्योंकि यह एक बहुत ही छोटी प्रस्तावना है, मैंने इसे आपके निर्देशों के अनुसार बिट दर में नहीं गिना है।

इसके अलावा पहले प्रयास के बाद से मैं अब QAM8 तारामंडल का उपयोग कर रहा हूं 2. 2 के बजाय प्रति प्रतीक 3 बिट प्राप्त करने के लिए। यह प्रभावी रूप से हस्तांतरण दर को दोगुना करता है। इसलिए ~ 2.4kHz वाहक के साथ अब मैं 1960bps प्राप्त कर रहा हूं।

मैंने प्रतीक का पता लगाने में भी सुधार किया है ताकि फ़िल्टरिंग के कारण धीमी वृद्धि के समय से औसत प्रभावित न हो - मूल रूप से प्रत्येक बिट अवधि का केवल दूसरा छमाही वृद्धि के समय के प्रभाव को हटाने के लिए औसत होता है।

शैनन-हार्टले थ्योरी से 40kbps सैद्धांतिक चैनल बैंडविड्थ के पास अभी भी (30dB SNR मानकर)

सिर्फ उन लोगों के लिए जो भयानक लगता है, यह नई प्रविष्टि है:

---

और अगर किसी को दिलचस्पी है, तो यह पिछली 960bps की प्रविष्टि है

Comments

स्कोरिंग केवल स्थानांतरण दर है, इसलिए अपना कोड स्पष्ट रखें। मैंने अपनी ऑडियो फ़ाइल को कहीं और होस्ट करने का सुझाव दिया, अगर यह फन के लिए आसान हो: D

— Nick T

मैं अपनी साइट पर ऑडियो अपलोड करूंगा। ऐसा लगता है बल्कि ईरी!

— टॉम कारपेंटर

@NickT ऑडियो फ़ाइल अपलोड की गई - पोस्ट के नीचे लिंक देखें।

— टॉम कारपेंटर

यदि आपके पास एक साउंडक्लाउड खाता है, तो आप अपना ऑडियो अपलोड कर सकते हैं और एक लिंक पोस्ट कर सकते हैं और यह आपके पोस्ट में खेलने योग्य होगा। ( उदाहरण )

— केल्विन के शौक

@NTT धन्यवाद मैंने एक साउंडक्लाउड खाता बनाया है और इसे अपलोड किया है। मैं भी डबल डेटा दर के साथ एक अद्यतन संस्करण बनाया है :)

— टॉम बढ़ई