• documentation
main content

number of bit errors and bit error rate (ber) -凯发k8网页登录

number of bit errors and bit error rate (ber)

syntax

[number,ratio] = biterr(x,y)
[number,ratio] = biterr(x,y,k)
[number,ratio] = biterr(x,y,k,flag)
[number,ratio,individual] = biterr(___)

description

example

[number,ratio] = biterr(x,y) compares the unsigned binary representation of elements in x to those in y. the function returns number, the number of bits that differ in the comparison, and ratio, the ratio of number to the total number of bits. the function determines the order in which it compares x and y based on their sizes. for more information, see the algorithms section.

[number,ratio] = biterr(x,y,k) also specifies k, the maximum number of bits for each element in x and y. if the unsigned binary representation of any element in x or y is more than k digits, the function errors.

example

[number,ratio] = biterr(x,y,k,flag) specifies a flag to override default settings for how the function compares the elements and computes the outputs. for more information, see the algorithms section.

[number,ratio,individual] = biterr(___) returns the binary comparison result of x and y as matrix individual. you can specify any of the input argument combination from the previous syntaxes.

examples

create two binary matrices.

x = [0 0; 0 0; 0 0; 0 0]
x = 4×2
     0     0
     0     0
     0     0
     0     0

y = [0 0; 0 0; 0 0; 1 1]
y = 4×2
     0     0
     0     0
     0     0
     1     1

determine the number of bit errors.

numerrs = biterr(x,y)
numerrs = 2

compute the number of column-wise errors.

numerrs = biterr(x,y,[],'column-wise')
numerrs = 1×2
     1     1

compute the number of row-wise errors.

numerrs = biterr(x,y,[],'row-wise')
numerrs = 4×1
     0
     0
     0
     2

compute the number of overall errors. behavior is the same as the default behavior.

numerrs = biterr(x,y,[],'overall')
numerrs = 2

demodulate a noisy 64-qam signal and estimate the bit error rate (ber) for a range of eb/no values. compare the ber estimate to theoretical values.

set the simulation parameters.

m = 64;                 % modulation order
k = log2(m);            % bits per symbol
ebnovec = (5:15);      % eb/no values (db)
numsymperframe = 100;   % number of qam symbols per frame

convert the ebn0 values to snr.

snrdb =convertsnr(ebnovec,"ebno","snr",bitspersymbol=k);

initialize the results vector.

berest = zeros(size(ebnovec));

the main processing loop executes these steps.

  • generate binary data and convert to 64-ary symbols.

  • qam-modulate the data symbols.

  • pass the modulated signal through an awgn channel.

  • demodulate the received signal.

  • convert the demodulated symbols into binary data.

  • calculate the number of bit errors.

the while loop continues to process data until either 200 errors are encountered or 1e7 bits are transmitted.

for n = 1:length(snrdb)
    % reset the error and bit counters
    numerrs = 0;
    numbits = 0;
    
    while numerrs < 200 && numbits < 1e7
        % generate binary data and convert to symbols
        datain = randi([0 1],numsymperframe*k,1);
        datasym = bit2int(datain,k);
        
        % qam modulate using 'gray' symbol mapping
        txsig = qammod(datasym,m);
        
        % pass through awgn channel
        rxsig = awgn(txsig,snrdb(n),'measured');
        
        % demodulate the noisy signal
        rxsym = qamdemod(rxsig,m);
        % convert received symbols to bits
        dataout = int2bit(rxsym,k);
        
        % calculate the number of bit errors
        nerrors = biterr(datain,dataout);
        
        % increment the error and bit counters
        numerrs = numerrs   nerrors;
        numbits = numbits   numsymperframe*k;
    end
    
    % estimate the ber
    berest(n) = numerrs/numbits;
end

determine the theoretical ber curve by using the berawgn function.

bertheory = berawgn(ebnovec,'qam',m);

plot the estimated and theoretical ber data. the estimated ber data points are well aligned with the theoretical curve.

semilogy(ebnovec,berest,'*')
hold on
semilogy(ebnovec,bertheory)
grid
legend('estimated ber','theoretical ber')
xlabel('eb/no (db)')
ylabel('bit error rate')

figure contains an axes object. the axes object with xlabel eb/no (db), ylabel bit error rate contains 2 objects of type line. one or more of the lines displays its values using only markers these objects represent estimated ber, theoretical ber.

input arguments

inputs to be compared, specified as separate arguments, as a vector or matrix of nonnegative integer elements. the function converts each element of x and y to its unsigned binary representation for comparison.

data types: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64 | logical

maximum number of bits for input elements of x and y, specified as a positive integer. if the number of bits required for binary representation of any element in x or y is greater than k, the function errors.

if you do not set k, the function sets it as the number of bits in the binary representation of the largest element in x and y.

data types: single | double

flag to override default settings of the function, specified as 'overall', 'row-wise', or 'column-wise'. flag specifies how the function compares elements in inputs x,y and computes the output. for more information, see the algorithms section.

data types: string | char

output arguments

number of bit errors, returned as a nonnegative integer or integer vector.

data types: single | double

bit error rate, returned as a scalar. ratio is the number of bit errors, number, to the total number of bits used in the binary representation. the total number of bits is k times the number of entries in the smaller of the inputs x,y.

results of each individual binary comparison, returned as a matrix whose dimensions are those of the larger of inputs x and y. each element specifies the number of bits by which the elements in the pair differ. for more information, see the algorithms section.

data types: single | double

algorithms

comparing inputs based on sizes

the function uses the sizes of x and y to determine the order in which it compares their elements.

  • if inputs are matrices of the same dimensions, then the function compares the inputs element by element. number is a nonnegative integer in this case. for example, see case (a) in the figure.

  • if one input is a matrix and the other input is a column vector, then the function compares each column of the matrix element by element with the column vector. the number of rows in the matrix must be equal to the length of the column vector. in other words, if the matrix has dimensions m-by-n, then the column vector must have dimensions m-by-1. for example, see case (b) in the figure.

  • if one input is a matrix and the other input is a row vector, then the function compares each row of the matrix element by element with the row vector. the number of columns in the matrix must be equal to the length of the row vector. in other words, if the matrix has dimensions m-by-n, then the row vector must have dimensions 1-by-n. for example, see case (c) in the figure.

comparing inputs based on flag

this table describes how the output is computed based on the different values of flag. x is considered as a matrix in this table and the size of y is varied.

size of yflag valuetype of comparisonnumber valuetotal number of bits
matrix 'overall' (default)element by elementtotal number of bit errorsk times the number of elements in y
'row-wise'mth row of x to mth row of ycolumn vector whose elements represent the bit errors in each row k times the number of elements in y
'column-wise'mth column of x to mth column of y row vector whose elements represent the bit errors in each columnk times the number of elements in y
row vector 'overall'y to each row of xtotal number of bit errorsk times the number of elements of x
'row-wise'(default) y to each row of xcolumn vector whose elements represent the bit errors in each row of xk times the size of y
column vector 'overall'y to each column of xtotal number of bit errorsk times the number of elements of x
'column-wise' (default) y to each column of xrow vector whose elements represent bit errors in each column of xk times the size of y

extended capabilities

c/c code generation
generate c and c code using matlab® coder™.

version history

introduced before r2006a

see also

| |

网站地图