www.pudn.com > RS_BCH.rar > bch.m

%bch decoder using Berlekamp-Massey and Chien search 
%standard bch decoder simulation 
%by: yumi 
%10/21/2005 
close all; clear all; 
 
m=12; 
n=2^m-1; 
t=2; 
k=2^m-1-m*t; 
simplified = 1; 
 
%the constants used in the algorithm 
alpha = gf(2, m); 
zero = gf(0, m); 
one = gf(1, m); 
 
%since all zero is always a codeword, only have to specify the error 
%code = zeros(1, n); 
code=gf(zeros(1, n), 1); 
 
code(1)=gf(1, 1); 
code(2)=gf(1, 1); 
 
codev = code.x; 
reccode=gf(codev, m); 
 
%creating alpha array 
%note that syndrome should be in the order [s3, s2, s1, s0] 
alpha_tb=gf(zeros(1, 2*t), m); 
for i=1:2*t, 
    alpha_tb(i)=alpha^(2*t-i+1); 
end; 
 
%syndrome generation 
syndrome=gf(zeros(1, 2*t), m); 
for i=1:n, 
    syndrome=syndrome.*alpha_tb+reccode(i); 
end; 
 
 
%imba 
lambda = gf([1, zeros(1, t)], m); 
lambda0= lambda; 
b=gf([0, 1, zeros(1, t)], m); 
b2 = gf([0, 0, 1, zeros(1, t)], m); 
k=0; 
gamma = one; 
delta = zero; 
syndrome_array = gf(zeros(1, t+1), m); 
 
if(simplified == 1)  
    for r=1:t, 
        r1 = 2*t-2*r+2; 
        r2 = min(r1+t, 2*t); 
        num = r2-r1+1; 
        syndrome_array(1: num) = syndrome(r1:r2); 
        delta = syndrome_array*lambda'; 
         
        lambda0 = lambda; 
        lambda = gamma*lambda-delta*b2(2:t+2); 
         
        if((delta~= zero) && (k>=0)) 
            b2(3)=zero; 
            b2(4:3+t) = lambda0(1:t); 
            gamma = delta; 
            k = -k; 
        else 
            b2(3:3+t) = b2(1:t+1); 
            gamma = gamma; 
            k=k+2; 
        end 
        joke=1; 
    end 
else 
    for r=1:2*t, 
        r1 = 2*t-r+1; 
        r2 = min(r1+t, 2*t); 
        num = r2-r1+1; 
        syndrome_array(1:num) = syndrome(r1:r2); 
        delta = syndrome_array*lambda'; 
 
        lambda0 = lambda; 
        lambda = gamma*lambda-delta*b(1:t+1); 
 
        if((delta ~= zero) && (k>=0)) 
            b(2:2+t)=lambda0; 
            gamma = delta; 
            k=-k-1; 
        else 
            b(2:2+t) = b(1:t+1); 
            gamma = gamma; 
            k=k+1; 
        end    
        joke=1; 
    end 
end 
 
%inverstable 
inverse_tb = gf(zeros(1, t+1), m); 
for i=1:t+1, 
    inverse_tb(i) = alpha^(-i+1); 
end; 
 
%chien's search 
lambda_v = zero; 
accu_tb=gf(ones(1, t+1), m); 
for i=1:n, 
    lambda_v=lambda*accu_tb'; 
    accu_tb = accu_tb.*inverse_tb; 
    if(lambda_v==zero) 
        error(1,n-i+1)=1; 
    else 
        error(1,n-i+1)=0; 
    end 
end 
 
found = find(error(1,:)~=0)