QPSK सिस्टम का मतलाब प्लॉट सैद्धांतिक BER घटता से पूरी तरह सहमत नहीं है

क्या किसी को पता है कि इस तथ्य पर एक सरल व्याख्या है कि एक द्विघात चरण-शिफ्ट कुंजीयन (QPSK) प्रणाली की सैद्धांतिक बिट-त्रुटि दर (BER) नकली वक्रों से लगभग 1 डीबी स्थानांतरित है?

matlab qpsk

— दीपन मेहता
स्रोत

यदि यह बहुत लंबा नहीं है, तो क्या आप अपना कोड साझा कर सकते हैं? यह कई तरह की चीजें हो सकती हैं।

@ जॉर्ज - कृपया अपने कोड को jeep9911 द्वारा अनुरोधित पोस्ट करें! इसके बिना, हम केवल संभावित कारणों का अनुमान लगा सकते हैं। मैं डिजिटल सिग्नल प्रोसेसिंग के लिए इस प्रश्न को हमारी साइट पर ले जा रहा हूं, वे वहां आपकी मदद करने में बेहतर होंगे।

— केविन वर्मियर

शायद आप सैद्धांतिक बीईआर वक्र की गणना करने के लिए इस्तेमाल की गई अभिव्यक्ति को भी साझा कर सकते हैं? ऐसे कई मामले सामने आए हैं जहां प्रतीक त्रुटि संभावना के लिए सैद्धांतिक अभिव्यक्ति से प्राप्त वक्र की तुलना बिट त्रुटि संभावना (और इसके विपरीत) के लिए नकली वक्र के साथ की गई है जिसके परिणामस्वरूप बहुत भ्रम और दिल का दर्द होता है। एसएनआर की गणना में त्रुटियां, या संकेत आयामों के लिए दिए गए एसएनआर का अनुवाद करना, बहुत आम हैं।

— दिलीप सरवटे

सरल व्याख्या यह है कि आपके सिमुलेशन में कोई त्रुटि है। यहाँ एक है कि MATLAB में काम करता है:

% number of symbols in simulation
Nsyms = 1e6;
% energy per symbol
Es = 1;
% energy per bit (2 bits/symbol for QPSK)
Eb = Es / 2;
% Eb/No values to simulate at, in dB
EbNo_dB = linspace(0, 10, 11);

% Eb/No values in linear scale
EbNo_lin = 10.^(EbNo_dB / 10);
% keep track of bit errors for each Eb/No point
bit_err = zeros(size(EbNo_lin));
for i=1:length(EbNo_lin)
    % generate source symbols
    syms = (1 - 2 * (randn(Nsyms,1) > 0)) + j * (1 - 2 * (randn(Nsyms, 1) > 0));
    % add noise
    syms_noisy = sqrt(Es/2) * syms + sqrt(Eb/(2*EbNo_lin(i))) * (randn(size(syms)) + j * randn(size(syms)));
    % recover symbols from each component (real and imaginary)
    syms_rec_r = sign(real(syms_noisy));
    syms_rec_i = sign(imag(syms_noisy));
    % count bit errors
    bit_err(i) = sum((syms_rec_r ~= real(syms)) + (syms_rec_i ~= imag(syms)));
end
% convert to bit error rate
bit_err = bit_err / (2 * Nsyms);

% calculate theoretical bit error rate, functionally equivalent to:
% bit_err_theo = qfunc(sqrt(2*EbNo_lin));
bit_err_theo = 0.5*erfc(sqrt(2*EbNo_lin)/sqrt(2));
figure;
semilogy(EbNo_dB, bit_err, 'bx', EbNo_dB, bit_err_theo, 'r', 'MarkerSize', 10, 'LineWidth', 2);
xlabel('Eb/No (dB)');
ylabel('Bit error rate');
title('QPSK bit error rate');
legend('Simulation','Theory');
grid on;

QPSK बिट त्रुटि दर प्लॉट

ध्यान दें कि BPSK / QPSK मॉडुलन के लिए बिट त्रुटि दर के लिए सैद्धांतिक अभिव्यक्ति है:

P_{b} = Q (\sqrt{\frac{2 E_{b}}{N_{0}}})

$P_b = Q\left(\sqrt{\frac{2E_b}{N_0}}\right)$

keeping in mind that $E_b$ is the energy per information bit. The somewhat subtle distinction between $E_b$ and $E_s$ , the energy per symbol, is something that often trips up people new to the subject. This difference also explains why QPSK and BPSK have the same bit error rate when expressed as a function of $\frac{E_b}{N_0}$ ; you don't get any bit-error performance benefit by moving to QPSK, although you can achieve a given bit rate with less occupied bandwidth.

— Jason R
स्रोत

As I noted in my comment on the main question, another source of confusion is that the symbol error rate is

P_{s} = 2 Q (\sqrt{\frac{2 E_{b}}{N_{0}}}) - {[Q (\sqrt{\frac{2 E_{b}}{N_{0}}})]}^{2}

$P_s= 2Q\left(\sqrt{\frac{2E_b}{N_0}}\right) - \left[Q\left(\sqrt{\frac{2E_b}{N_0}}\right)\right]^2$ since the symbol is incorrect if at least one bit is demodulated incorrectly, the bit errors in in-phase and quadrature branches are independent, and

P (A \cup B) = P (A) + P (B) - P (A \cap B) = P (A) + P (B) - P (A) P (B) = 2 p - p^{2}

$P(A\cup B) = P(A) + P(B) - P(A\cap B) = P(A) + P(B) - P(A)P(B) = 2p-p^2$ for independent events of probability

p

$p$

— Dilip Sarwate

Can I ask a question? How do you calculate the energy per bit? I mean, in reality, it doesn't equal 1. So can you explain in reality how do I caculate the energy per bit? Thank you very much!

— Khanh Nguyen

@KhanhNguyen: Assuming you have achieved timing synchronization, you can estimate the energy per symbol by averaging the accumulated squared magnitude of the observed signal over many symbol periods. That is,

E_{s} \approx \frac{1}{M} \sum_{k = 0}^{K} \sum_{n = 0}^{N_{s}} | x [k N_{s} + n] |^{2}

$E_s \approx \frac{1}{M} \sum_{k=0}^K \sum_{n=0}^{N_s} |x[kN_s + n]|^2$ , where

M

$M$ is the number of symbols that you average over and

N_{s}

$N_s$ is the number of samples that you have per symbol. For QPSK, there are 2 bits per symbol, so

E_{b} = \frac{E_{s}}{2}

$E_b = \frac{E_s}{2}$ .

— Jason R