trellis.m

空时格码编码器

function [last_state, last_input, next_state,codes,Modulate_codes] = trellis(Input_codes, Branch_coef, States)
          last_state = zeros(1,4);
          size_States = size(States);
          La_States = zeros(4,size_States(2));
          sizeBc = size(Branch_coef); 
          mem_order = sizeBc(1)-2;                              % the memory order 
          states = 2^mem_order;                                   % n states
                                              
          upper_order = mem_order/2 - mod(mem_order/2,1);                                    % the memory order of the upper and lower branches
          lower_order = (mem_order+1)/2 - mod((mem_order+1)/2,1);
          last_input = [States(1),States(upper_order+1)];
          Upper_stream = Input_codes(1);                                     % the upper branch's stream
          Lower_stream = Input_codes(2);                                       % the lower branch's stream

          upper_codes = 0;
          lower_codes = 0;
          upper_codes = upper_codes + Upper_stream * Branch_coef(1,1);
          lower_codes = lower_codes + Upper_stream * Branch_coef(1,2);
          for p = 1:upper_order                      
              upper_codes = upper_codes + States(p)*Branch_coef(p+1,1);
              lower_codes = lower_codes + States(p)*Branch_coef(p+1,2);
          end
          for k = 1:upper_order-1
              La_States(:,k) = States(k+1);
          end
          La_States(1:2,upper_order) = 0;
          La_States(3:4,upper_order) = 1;
          for k = 1:lower_order-1
              La_States(:,upper_order+k) = States(upper_order+k+1);
          end
          La_States([1,3],upper_order+lower_order) = 0;
          La_States([2,4],upper_order+lower_order) = 1;
          while p > 1
                States(p) = States(p-1);
                p = p-1;
          end
          States(1) = Upper_stream;
          upper_codes = upper_codes + Lower_stream * Branch_coef(p+2,1);
          lower_codes = lower_codes + Lower_stream * Branch_coef(p+2,2);
          for q = 1:lower_order
              upper_codes = upper_codes + States(p+q)*Branch_coef(p+q+2,1);
              lower_codes = lower_codes + States(p+q)*Branch_coef(p+q+2,2);
          end
          while q > 1
                States(upper_order+q) = States(upper_order+q-1);
                q = q-1;
          end
          States(upper_order+1) = Lower_stream;
          upper_codes = mod(upper_codes,4);
          lower_codes = mod(lower_codes,4);
          codes = [upper_codes; lower_codes];
          next_state = 0;
          for i = 1:size_States(2)
              if States(i) == 1
                  next_state = next_state + 2^(size_States(2)-i);
              end
          end
          next_state = next_state + 1;
          for k = 1:4
              for i = 1:size_States(2)
                  if La_States(k,i) == 1
                     last_state(1,k) = last_state(1,k) + 2^(size_States(2)-i);
                  end
              end
              last_state(1,k) = last_state(1,k) + 1;
          end
          Modulate_codes = zeros(2,1);
          for i = 1:2                                                        % modulate the output codes
              if codes(i) == 0
                 Modulate_codes(i) = 1;
              end
              if codes(i) == 1
                 Modulate_codes(i) = sqrt(-1);
              end
              if codes(i) == 2
                 Modulate_codes(i) = -1;
              end
              if codes(i) == 3
                 Modulate_codes(i) = -sqrt(-1);
              end 
         end