2 कंप्यूटरों के बीच ध्वनि के माध्यम से डेटा संचारित करें (बहुत निकट दूरी)


12

मैं ध्वनि betwwen 2 कंप्यूटर के माध्यम से डेटा संचारित करने पर एक उदाहरण लिख रहा हूं। कुछ आवश्यकताएँ:

  • दूरी बहुत करीब है, यानी 2 कंप्यूटर मूल रूप से एक दूसरे से सटे हुए हैं

  • बहुत कम शोर (मुझे नहीं लगता कि मेरे शिक्षक एक रॉक गीत को शोर स्रोत के रूप में चालू करेंगे)

  • त्रुटि स्वीकार्य है: उदाहरण के लिए यदि मैं "रेडियो संचार" भेजता हूं, तो यदि दूसरा कंप्यूटर "रेडियोक्यू कम्युनिकेशन" प्राप्त करता है, तो यह ठीक भी है।

  • यदि संभव हो तो: कोई हेडर, झंडा, चेकसम, .... क्योंकि मैं सिर्फ ध्वनि के माध्यम से डेटा प्रसारित करने की मूल बातें प्रदर्शित करने वाला एक बहुत ही मूल उदाहरण चाहता हूं। फैंसी होने की जरूरत नहीं है।

मैंने इस लिंक के अनुसार ऑडियो फ़्रीक्वेंसी शिफ़्ट कीइंग का उपयोग करने की कोशिश की:

लैब 5 APRS (ऑटोमैटिक पैकेज रिपोर्टिंग सिस्टम)

और कुछ परिणाम मिले: मेरा जीथूब पृष्ठ

लेकिन यह पर्याप्त नहीं है। मुझे नहीं पता है कि घड़ी की रिकवरी, सिंक्रोनाइज़ेशन कैसे किया जाता है, ... (लिंक में टाइमिंग रिकवरी मैकेनिज्म के रूप में एक फेज़ लॉक्ड लूप है, लेकिन यह स्पष्ट रूप से पर्याप्त नहीं था)।

इसलिए मुझे लगता है कि मुझे एक सरल तरीका खोजना चाहिए। यहां एक लिंक मिला:

डेटा ऑडियो और वापस करने के लिए। स्रोत कोड के साथ मॉड्यूलेशन / डिमॉड्यूलेशन

लेकिन ओपी ने उत्तर में सुझाई गई विधि को लागू नहीं किया, इसलिए मुझे डर है कि यह बहुत जटिल हो सकता है। इसके अलावा मैं स्पष्ट रूप से जवाब में सुझाए गए डिकोडिंग विधि को नहीं समझता:

डिकोडर थोड़ा और अधिक जटिल है, लेकिन यहां एक रूपरेखा है:

वैकल्पिक रूप से बैंड-पास फ़िल्टर किए गए सिग्नल को 11Khz के आस-पास। यह एक शोर वातावरण में प्रदर्शन में सुधार करेगा। एफआईआर फ़िल्टर बहुत सरल हैं और कुछ ऑनलाइन डिज़ाइन एप्लेट हैं जो आपके लिए फ़िल्टर उत्पन्न करेंगे।

सिग्नल को थ्रेसहोल्ड करें। 1/2 अधिकतम आयाम के ऊपर प्रत्येक मान 1 है नीचे प्रत्येक मान 0 है। यह मान लिया है कि आपने पूरे संकेत का नमूना लिया है। यदि यह वास्तविक समय में है तो आप या तो एक निश्चित सीमा चुनते हैं या कुछ प्रकार के स्वचालित लाभ नियंत्रण करते हैं जहां आप कुछ समय के लिए अधिकतम सिग्नल स्तर को ट्रैक करते हैं।

डॉट या डैश की शुरुआत के लिए स्कैन करें। आप शायद नमूनों को एक बिंदु मानने के लिए अपने डॉट पीरियड में कम से कम 1 की निश्चित संख्या देखना चाहते हैं। फिर यह देखने के लिए स्कैन करें कि क्या यह डैश है। एक सही संकेत की उम्मीद न करें - आप अपने 1 के बीच में कुछ 0 और अपने 1 के बीच में कुछ 1 के बीच में देखेंगे। अगर थोड़ा शोर है तो "ऑफ" अवधि से "ऑन" अवधि को अलग करना काफी आसान होना चाहिए।

फिर उपरोक्त प्रक्रिया को उल्टा करें। यदि आप डैश को अपने बफर पर 1 बिट पुश करते देखते हैं, अगर एक डॉट एक शून्य को धक्का देता है।

मुझे समझ में नहीं आता कि कितने 1 के पहले इसे डॉट के रूप में वर्गीकृत किया गया है, ... इसलिए कई चीजें हैं जो मुझे अभी समझ में नहीं आती हैं। कृपया मुझे ध्वनि के माध्यम से डेटा संचारित करने के लिए एक सरल विधि का सुझाव दें ताकि मैं इस प्रक्रिया को समझ सकूं। आपका बहुत बहुत धन्यवाद :)

अपडेट करें:

मैंने कुछ मैटलैब कोड बनाए हैं जो कुछ हद तक (कुछ हद तक) चालू होते हैं। मैं पहले एम्पलीफिट शिफ्ट कीइंग (नमूना आवृत्ति 48000 हर्ट्ज, F_on = 5000 हर्ट्ज, बिट दर = 10 बिट्स / एस) का उपयोग करके सिग्नल को मॉड्यूलेट करता हूं, फिर इसे हेडर और एक एंड सीक्वेंस के साथ जोड़ते हैं (बेशक उन्हें अच्छी तरह से मॉड्यूलेट करें)। शीर्ष लेख और अंतिम अनुक्रम एक तदर्थ आधार पर चुना गया था (हाँ यह एक हैक था):

header = [0 0 1 0 1 1 1 1   1 0 0 0 0 0 0 1   1 0 0 0 0 0 0 1   1 0 1 1 0 1 0 1];  
end_seq = [1 1 1 1 1 0 1 0 1  0 1 0 1 0 1 0 1   0 1 0 1 0 1 0 1     0 1 0 1 0 1 0 1    0 1 0 1 0 1 0 1   0 1 0 1 0 1 0 1  1 0 0 1 0 0 0 1];

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

  • "DigitalCommunication_ask": यहाँ लिंक यह पाठ "डिजिटल संचार" भेजता है। अपेक्षाकृत शोर-रहित हालांकि आप शुरुआत और अंत में कुछ पृष्ठभूमि शोर सुन सकते हैं। हालांकि परिणाम केवल "डिजिटल कॉम्मिनकैटियो" दिखा

  • "HelloWorld_ask": यहाँ लिंक यह पाठ "हैलो वर्ल्ड" भेजता है। "DigitalCommunication_ask" की तरह शोर मुक्त। हालांकि इस एक के लिए परिणाम सही था

  • "HelloWorld_noise_ask": यहाँ लिंक यह पाठ "हैलो दुनिया" भेजता है। हालांकि, कुछ शोर है जो मैंने बनाया है (मैंने ट्रांसमिशन के दौरान कुछ यादृच्छिक सामान "ए, बी, सी, डी, ई, ...." कहा है)। दुर्भाग्य से यह असफल रहा

यहाँ प्रेषक के लिए कोड है (प्रेषक।):

 clear
fs = 48000;
F_on = 5000;
bit_rate = 10;

% header = [0 0 1 0 1 1 1 1  1 1 1 1 1 1 1 1   1 1 1 1 1 1 1 1   1 1 1 1 1 1 1 1   1 1 1 1 1 1 1 1     1 1 1 1 1 1 1 1      1 1 1 1 1 1 1 1    1 1 1 1 1 1 1 1     1 1 1 1 1 1 1 1    1 1 1 1 1 1 1 1  1 1 1 1 1 1 1 1 ];
% header = [0 0 1 0 1 1 1 1  1 0 0 0 0 0 0 1   1 0 0 0 0 0 1   1 0 0 0 0 0 0 1   1 0 0 0 0 0 0 1     1 0 0 0 0 0 0 1      1 0 0 0 0 0 0 1    1 0 0 0 0 0 0 1  1 0 0 0 0 0 0 1    1 0 0 0 0 0 0 1  1 1 1 1 1 1 1 1 ];
header = [0 0 1 0 1 1 1 1   1 0 0 0 0 0 0 1   1 0 0 0 0 0 0 1   1 0 1 1 0 1 0 1];  

% end_seq = [1 0 0 1 0 1 0 0  1 0 1 1 0 0 0 1  0 0 0 0 1 0 0 1  1 0 0 0 1 0 0 1];
% end_seq = [1 0 0 1 0 1 0 0  1 0 1 1 0 0 0 1  0 0 0 0 1 0 0 1  1 0 0 0 1 0 0 1   0 1 0 0 1  1 0 0   1 1 0 1 1 0 0 1  ];
% end_seq = [0 0 0 1 0 0 0 1  0 0 0 0 0 0 0 0    0 0 0 0 0 0 0 0   1 1 0 0 1 1 0 0];
end_seq = [1 1 1 1 1 0 1 0 1  0 1 0 1 0 1 0 1   0 1 0 1 0 1 0 1     0 1 0 1 0 1 0 1    0 1 0 1 0 1 0 1   0 1 0 1 0 1 0 1  1 0 0 1 0 0 0 1];


num_of_samples_per_bit = round(fs / bit_rate);
modulated_header = ask_modulate(header, fs, F_on, bit_rate);
modulated_end_seq = ask_modulate(end_seq, fs, F_on, bit_rate);
% input_str = 'Ah';
input_str = 'Hello world';
ascii_list = double(input_str); % https://www.mathworks.com/matlabcentral/answers/298215-how-to-get-ascii-value-of-characters-stored-in-an-array
bit_stream = [];
for i = 1:numel(ascii_list)
    bit = de2bi(ascii_list(i), 8, 'left-msb');
    bit_stream = [bit_stream bit];
end
bit_stream = [header bit_stream  end_seq];
num_of_bits = numel(bit_stream);
bandlimited_and_modulated_signal = ask_modulate(bit_stream, fs, F_on, bit_rate);
sound(bandlimited_and_modulated_signal, fs);

रिसीवर के लिए (रिसीवर दोपहर):

clear
fs = 48000;
F_on = 5000;
bit_rate = 10;

% header = [0 0 1 0 1 1 1 1  1 1 1 1 1 1 1 1   1 1 1 1 1 1 1 1   1 1 1 1 1 1 1 1   1 1 1 1 1 1 1 1     1 1 1 1 1 1 1 1      1 1 1 1 1 1 1 1    1 1 1 1 1 1 1 1     1 1 1 1 1 1 1 1    1 1 1 1 1 1 1 1  1 1 1 1 1 1 1 1 ];
% header = [0 0 1 0 1 1 1 1  1 0 0 0 0 0 0 1   1 0 0 0 0 0 1   1 0 0 0 0 0 0 1   1 0 0 0 0 0 0 1     1 0 0 0 0 0 0 1      1 0 0 0 0 0 0 1    1 0 0 0 0 0 0 1  1 0 0 0 0 0 0 1    1 0 0 0 0 0 0 1  1 1 1 1 1 1 1 1 ];
header = [0 0 1 0 1 1 1 1   1 0 0 0 0 0 0 1   1 0 0 0 0 0 0 1   1 0 1 1 0 1 0 1];  

% end_seq = [1 0 0 1 0 1 0 0  1 0 1 1 0 0 0 1  0 0 0 0 1 0 0 1  1 0 0 0 1 0 0 1];
% end_seq = [1 0 0 1 0 1 0 0  1 0 1 1 0 0 0 1  0 0 0 0 1 0 0 1  1 0 0 0 1 0 0 1   0 1 0 0 1  1 0 0   1 1 0 1 1 0 0 1  ];
% end_seq = [0 0 0 1 0 0 0 1  0 0 0 0 0 0 0 0    0 0 0 0 0 0 0 0   1 1 0 0 1 1 0 0];
end_seq = [1 1 1 1 1 0 1 0 1  0 1 0 1 0 1 0 1   0 1 0 1 0 1 0 1     0 1 0 1 0 1 0 1    0 1 0 1 0 1 0 1   0 1 0 1 0 1 0 1  1 0 0 1 0 0 0 1];


modulated_header = ask_modulate(header, fs, F_on, bit_rate);
modulated_end_seq = ask_modulate(end_seq, fs, F_on, bit_rate);

% recObj = audiorecorder(fs,8,1);
% time_to_record = 10; % In seconds
% recordblocking(recObj, time_to_record);
% received_signal = getaudiodata(recObj);

% [received_signal, fs] = audioread('SounddataTruong_Ask.m4a');
% [received_signal, fs] = audioread('HelloWorld_noise_ask.m4a');
% [received_signal, fs] = audioread('HelloWorld_ask.m4a');
[received_signal, fs] = audioread('DigitalCommunication_ask.m4a');
ereceived_signal = received_signal(:)';
num_of_samples_per_bit = round(fs / bit_rate);

modulated_header = ask_modulate(header, fs, F_on, bit_rate);
modulated_end_seq = ask_modulate(end_seq, fs, F_on, bit_rate);

y= xcorr(modulated_header, received_signal); % do cross correlation
[m,ind]=max(y); % location of largest correlation
headstart=length(received_signal)-ind+1;

z = xcorr(modulated_end_seq, received_signal);
[m,ind]=max(z); % location of largest correlation
end_index=length(received_signal)-ind+1; 

relevant_signal = received_signal(headstart + num_of_samples_per_bit * numel(header) : end_index - 1);
% relevant_signal = received_signal(headstart + num_of_samples_per_bit * numel(header): end);
demodulated_signal = ask_demodulate(relevant_signal, fs, F_on, bit_rate);
sampled_points_in_demodulated_signal = demodulated_signal(round(num_of_samples_per_bit / 2) :  num_of_samples_per_bit :end);
digital_output = (sampled_points_in_demodulated_signal > (max(sampled_points_in_demodulated_signal(:)) / 2));
% digital_output = (sampled_points_in_demodulated_signal > 0.05);

% Convert to characters 
total_num_of_bits = numel(digital_output);
total_num_of_characters = total_num_of_bits / 8;
first_idx = 0;
last_idx = 0;
output_str = '';
for i = 1:total_num_of_characters
    first_idx = last_idx + 1;
    last_idx = first_idx + 7;
    binary_repr = digital_output(first_idx:last_idx); 
    ascii_value = bi2de(binary_repr(:)', 'left-msb');  
    character = char(ascii_value);
    output_str = [output_str character];    
end
output_str

ASK मॉड्यूलेशन कोड (ask_modulate):

function [bandlimited_and_modulated_signal] = ask_modulate(bit_stream, fs, F_on, bit_rate)
% Amplitude shift keying: Modulation
% Dang Manh Truong (dangmanhtruong@gmail.com)
num_of_bits = numel(bit_stream);
num_of_samples_per_bit = round(fs / bit_rate);
alpha = 0;
d_alpha = 2 * pi * F_on / fs;
A = 3;
analog_signal = [];
for i = 1 : num_of_bits
    bit = bit_stream(i);
    switch bit
        case 1
            for j = 1 : num_of_samples_per_bit
                analog_signal = [analog_signal A * cos(alpha)];
                alpha = alpha + d_alpha;

            end
        case 0
            for j = 1 : num_of_samples_per_bit
                analog_signal = [analog_signal 0];
                alpha = alpha + d_alpha;                
            end
    end    
end
filter_order = 15;
LP_filter = fir1(filter_order, (2*6000)/fs, 'low');
bandlimited_analog_signal = conv(analog_signal, LP_filter,'same');
% plot(abs(fft(bandlimited_analog_signal)))
% plot(bandlimited_analog_signal)
bandlimited_and_modulated_signal = bandlimited_analog_signal;

end

ASK डिमॉड्यूलेशन (ask_demodulate.m) (मूल रूप से यह सिर्फ लिफाफा का पता लगाने के लिए है, जिसके लिए मैंने हिल्बर्टन का उपयोग किया था)

function [demodulated_signal] = ask_demodulate(received_signal, fs, F_on, bit_rate)
% Amplitude shift keying: Demodulation
% Dang Manh Truong (dangmanhtruong@gmail.com)

demodulated_signal = abs(hilbert(received_signal));

end

कृपया मुझे बताएं कि यह काम क्यों नहीं कर रहा है? आपका बहुत बहुत धन्यवाद


सिद्धांत रूप में (शोर-रहित वातावरण में), इसे लागू करना तुच्छ होगा लेकिन व्यवहार में यह बहुत अधिक कठिन है। फिर भी, यह उस सूचना के प्रकार पर निर्भर करता है जिसे आप भेजने की कोशिश कर रहे हैं। पाठ को मज़बूती से प्रसारित करना बहुत मुश्किल होगा क्योंकि यहां तक ​​कि सबसे छोटा शोर पाठ को पहचानने योग्य नहीं बना देगा।
dsp_user

@dsp_user मैं पाठ भेजने का प्रयास कर रहा हूं। मैं कुछ त्रुटि के साथ रह सकता हूं (जैसे "ऑडियो" -> "एपिडियो") :) इसके अलावा, मुझे वास्तव में यह समझ में नहीं आता है, उदाहरण के लिए, शिफ्ट की कीपिंग के लिए, जब आपके पास 1 है तो आप साइन वेव भेजते हैं, 0 फिर कुछ नहीं लेकिन कैसे क्या आप पहले 0 जानते हैं? मेरा मतलब शोर-शराबा भरे माहौल में है, लेकिन पहले 1 से पहले बहुत कुछ सही होगा? फिर आप इसे कैसे जानते हैं?
डांग मन

मेरा सुझाव है कि आप विचारों के लिए पुराने जमाने के 14.4 मॉडेम की तरह कुछ देखते हैं।

@StanleyPawlukiewicz मैंने कुछ प्रगति की है। कृपया अद्यतन की जाँच करें। आपका बहुत बहुत धन्यवाद।
डांग मन

टिप्पणी करने के लिए बहुत कुछ है। आप अपनी प्रस्तावना के लिए बार्कर दृश्यों को देखना चाहते हैं, यह देखते हुए कि आप

जवाबों:


8

जैसा कि आपने महसूस किया है, डिजिटल संचार करने का कठिन हिस्सा वाहक, प्रतीक और फ्रेम सिंक्रोनाइज़ेशन, और चैनल अनुमान / समीकरण है।

बुरी खबर यह है कि आप इन समस्याओं के आसपास नहीं पहुँच सकते। अच्छी खबर यह है कि इन्हें लागू करना इतना कठिन नहीं है, जब तक आप खुद को संकीर्ण बीपीएसके तक सीमित नहीं रखते। मुझे पता है, क्योंकि मैंने खुद ऐसा किया है, और इसलिए मेरे (अंडरग्रेड) छात्र हैं (देखें http://ieeexplore.ieee.org/document/5739249/ )

वाहक सिंक्रनाइज़ेशन की समस्या के आसपास पाने का एक सरल सुझाव यह है कि आप अपने बेसबैंड सिग्नल को अपकनेक्ट करने के लिए AM DSB-LC का उपयोग करें। फिर, आप वाहक और चरण तुल्यकालन के बिना एक लिफाफा डिटेक्टर का उपयोग कर सकते हैं। यह आपको बिजली दक्षता में खर्च करेगा, लेकिन यह आपके मामले में प्राथमिकता नहीं है।

एक और सरल सुझाव "वास्तविक समय प्रसंस्करण" के बजाय "बैच प्रोसेसिंग" करना है; इसका मतलब क्या है, पूरे प्राप्त सिग्नल को स्टोर करें और उसके बाद की प्रक्रिया करें। यह स्ट्रीम या रीयल-टाइम प्रोसेसिंग की तुलना में लागू करना अधिक आसान है।

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

सौभाग्य; और कृपया नए, अधिक विशिष्ट प्रश्न पूछें यदि आपके पास है।


मैंने तुम्हारा पेपर पढ़ा है। अच्छा काम करते रहें! एक प्रश्न: पेपर में, आपने छात्रों से चैनल प्रतिक्रिया (आवेग, साइन तरंगों का उपयोग करके ..) का उपयोग करने के लिए कई तरीकों के बारे में बात की थी। क्या मुझे चैनल की प्रतिक्रिया भी खोजने की आवश्यकता होगी? :)
डांग मान

1
अपनी तरह के शब्दों के लिए धन्यवाद :) बात यह है कि आप यह सुनिश्चित करना चाहते हैं कि आप एक आवृत्ति बैंड पर संचारित हों जहां चैनल प्रतिक्रिया सपाट है; अन्यथा, आपको रिसीवर में एक तुल्यकारक की आवश्यकता होगी। यदि आप चैनल की प्रतिक्रिया का अनुमान नहीं लगाना चाहते हैं, तो आप क्या कर सकते हैं एक आवृत्ति पर बहुत कम डेटा दर (कहते हैं, 100 बी / एस) का उपयोग करें कि सभी ऑडियो लैस को (जैसे, 5000 हर्ट्ज) के साथ सहज होना चाहिए।
16

1
@DangManhTruong एक और बात: चौकोर रूट वाली कोसाइन के रूप में बैंडविड्थ-सीमित दालों का उपयोग करना सुनिश्चित करें, न कि वर्गाकार दालों जिसमें एक बड़ी बैंडविड्थ है और इससे विकृति का बहुत नुकसान होगा।
एमबीज

मैंने आपके द्वारा सुझाई गई पुस्तक सॉफ़्टवेयर रिसीवर डिज़ाइन को पढ़ा है (वास्तव में मैंने इसमें से अधिकांश के माध्यम से स्किम्ड किया और अध्याय 8: बिट्स टू सिंबल्स टू सिग्नल) पर ध्यान केंद्रित किया। इसलिए मेरे कुछ सवाल हैं। आपने दालों के बारे में कुछ कहा था, लेकिन किताब के उदाहरण में उन्होंने एक हैमिंग विंडो का इस्तेमाल दाल के रूप में किया है, क्या ऐसा करना मेरे लिए ठीक है? और क्या मेरी समझ सही है: पहले आप एएसके का उपयोग करते हुए सिग्नल को संशोधित करते हैं, कहते हैं, फिर आप पल्स शेपिंग का उपयोग करते हैं। फिर रिसीवर पर, आप पहले संशोधित सिग्नल प्राप्त करने के लिए पल्स सिग्नल के साथ सहसंबंधित करते हैं। तब आप डिमॉड्यूलेट करते हैं। क्या यह सही है?
डांग मन

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

4

अंत में, मैंने DTMF (ड्यूल टोन मल्टी फ्रिक्वेंसी सिग्नलिंग) का उपयोग किया। मूल DTMF में 2 आवृत्तियों के संयोजन का उपयोग करते हुए प्रत्येक में 16 सिग्नल होते हैं। लेकिन यहां मैंने केवल "1" (697 हर्ट्ज और 1209 हर्ट्ज) और "0" (941Hz और 139 हर्ट्ज) का इस्तेमाल किया

कोड कैसे काम करता है, इसकी एक रूपरेखा:

  • प्रेषक पाठ को बाइनरी में कनवर्ट करता है, फिर "0" / "1" DTMF सिग्नल प्रसारित करता है (यहां टोन अवधि के लिए समय 0.3 और टोन के बीच मौन अवधि के लिए 0.1 s) है। ट्रांसमिशन कोड से लिया गया है: https://sites.google.com/a/nd.edu/adsp-nik-kleber/home/advanced-digital-signal-processing/project-3-touch-tone । जाहिर तौर पर लेखक ने डिजिटल थरथरानवाला को लागू करने के लिए कुछ हद तक स्थिर IIR फिल्टर का इस्तेमाल किया।
  • रिसीवर पक्ष पहले क्रमशः "0" और "1" आवृत्ति घटकों को निकालने के लिए 2 हास्यास्पद-उच्च-क्रम-और-हास्यास्पद-बैंडबैंड फ़िल्टर का उपयोग करता है:

    फ़िल्टर_ऑर्डर = 1000;

    one_band = [[((2696)/Fs) ((2698)/Fs)] [((21208)/Fs) ((21210)/Fs)]];
    
    one_dtmf_filter = fir1(filter_order, one_band);
    
    zero_band = [[((2940)/Fs) ((2942)/Fs)] [((21335)/Fs) ((21337)/Fs)]];
    
    zero_dtmf_filter = fir1(filter_order, zero_band);
    

ऐसा होने के बाद हम प्रत्येक "1" और "0" सिग्नल की शुरुआत और अंत पाएंगे। कोड https://github.com/codyaray/dtmf-signaling से है । मूल रूप से इसमें मौन की अवधि होती है जो कम से कम 10 एमएस और किसी भी टोन की अवधि 100ms से अधिक है):

यहाँ छवि विवरण दर्ज करें

(ऊपर से नीचे तक: जीरो सिग्नल, मूविंग एवरेज फिल्टर के बाद सिग्नल, थ्रेशोल्ड के नीचे से हटाने के बाद सिग्नल का अंतर, थ्रेसहोल्ड के बाद सिग्नल)

  • पहले पिछले चरण से परिणाम को सामान्य किया जाता है फिर एक चलती औसत फिल्टर के माध्यम से चला जाता है (फिल्टर आकार 10ms * एफएस के बराबर होता है)। यदि हम परिणाम की साजिश करते हैं तो हम देखेंगे कि "0" और "1" का आकार स्पष्ट रूप से देखा जा सकता है। इसलिए मुझे लगता है कि यह थोड़े इस मामले में एक लिफाफा डिटेक्टर के रूप में काम करता है।
  • फिर एक निश्चित सीमा के नीचे सभी सिग्नल काट दिया जाता है (मैंने 0.1 चुना)।
  • अंत में दहलीज के ऊपर के सभी अंतरालों को खोजें, जिसमें समय अंतराल 100ms से अधिक है (ध्यान दें कि छवि कोड से प्रतिलिपि प्रस्तुत करने योग्य नहीं है, आपको इसे बनाने के लिए चारों ओर खुदाई करनी होगी)

फिर हम बिट्स को इकट्ठा करते हैं और टेक्स्ट में वापस आते हैं :)

वीडियो डेमो: https://www.youtube.com/watch?v=vwQVmNnWa4s , जहां मैं अपने लैपटॉप और अपने भाई के पीसी के बीच "Xin chao" पाठ भेजता हूं :)

पी / एस: मूल रूप से मैंने ऐसा किया क्योंकि मेरे डिजिटल संचार शिक्षक ने कहा कि जिसने भी ऐसा किया है उसे अंतिम परीक्षा करने के बिना ए मिलेगा, लेकिन मैं केवल परीक्षा के बाद ऐसा करने में सक्षम था। तो यहाँ मेरे सारे प्रयास हैं :(

P / S2: मुझे C + :( मिला है


0

यदि आप बहुत अच्छे सिंक्रोनाइज़ेशन के साथ एक ओपन सोर्स लाइब्रेरी चाहते हैं, तो मैं https://github.com/jgaeddert/liquid-dsp का उपयोग करने की सलाह देता हूं, जो कि एलाइनर के लिए माइग्रेशन का उपयोग करता है, फिर पेलोड को बराबर करता है और डिमॉडलाइज़ करता है। मैंने एक ऑडियो मॉडेम बनाया जो शीर्ष पर चलता है और यह काफी अच्छी तरह से काम करता है, इसलिए यदि और कुछ नहीं, तो तरल के तरीकों से कुछ मदद मिलनी चाहिए

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.