viterbi_detector.c

GSM 物理层信道编码, 调制, 信道模拟, 同步搜索, 信道估计, 均衡解调, 信道译码

    
    int STATE_CNTR;
    int USED[16];
    
    /*
      if COMPLEX,
    */
    if (COMPLEX) 
      /* COMPLEX=0; */
      COMPLEX=0; 
    /* else */
    else
      /* COMPLEX=1; */
      COMPLEX=1;
    /* end */
    
    /*
      STATE_CNTR=0;
    */
    STATE_CNTR=0;
    /*
      for PS = PREVIOUS_STATES,
    */
    for (n=1;n<=ELEMENTS_IN_PREVIOUS_STATES;n++) { 
      /* The above 'for PS=VECTOR' MATLAB trick is not available in C */
      PS=*(PREVIOUS_STATES+(n-1));
      /*
	STATE_CNTR=STATE_CNTR+1;
      */
      STATE_CNTR=STATE_CNTR+1;      
      /*
	S=NEXT(PS,1);
      */
      S=*(NEXT+((1-1)*M+(PS-1)));
      /*
	METRIC(S,N)=
	METRIC(PS,N-1)+real(conj(SYMBOLS(S,1))*Y(N))-INCREMENT(PS,S);
      */
      *(METRIC+(N-1)*M+(S-1))=*(METRIC+((N-1-1)*M+(PS-1)))
	                      +
                              *(SYMBOLSr+(S-1))**(Yr+(N-1))
                              +
	                      *(SYMBOLSi+(S-1))**(Yi+(N-1))
                              - 
	                      *(INCREMENT+((S-1)*M+(PS-1)));     
      /*	
	SURVIVOR(S,N)=PS;
      */
      *(SURVIVOR+((N-1)*M+(S-1)))=PS;
      /*
	USED(STATE_CNTR)=S;
      */
      *(USED+(STATE_CNTR-1))=S;
      /*
	STATE_CNTR=STATE_CNTR+1;
      */
      STATE_CNTR=STATE_CNTR+1;
      /*
	S=NEXT(PS,2);
      */
      S=*(NEXT+((2-1)*M+(PS-1)));
      /*
	METRIC(S,N)=
	METRIC(PS,N-1)+real(conj(SYMBOLS(S,1))*Y(N))-INCREMENT(PS,S);
      */
      *(METRIC+(N-1)*M+(S-1))=*(METRIC+((N-1-1)*M+(PS-1)))
	                      +
                              *(SYMBOLSr+(S-1))**(Yr+(N-1))
                              +
	                      *(SYMBOLSi+(S-1))**(Yi+(N-1))
                              - 
	                      *(INCREMENT+((S-1)*M+(PS-1)));     
      /*
	SURVIVOR(S,N)=PS;    
      */
      *(SURVIVOR+(N-1)*M+(S-1))=PS;
      /*
	USED(STATE_CNTR)=S;
      */
      *(USED+(STATE_CNTR-1))=S;
      /*
	end
      */
    }
    ELEMENTS_IN_PREVIOUS_STATES=STATE_CNTR;
    /*
      PREVIOUS_STATES=USED;
    */
    for (m=1;m<=ELEMENTS_IN_PREVIOUS_STATES;m++)
      *(PREVIOUS_STATES+(m-1))=*(USED+(m-1));
    /*
      end
    */
  }

  /*
    % AT ANY RATE WE WILL HAVE PROCESSED Lh STATES AT THIS TIME
    %
  PROCESSED=Lh;
  */
  PROCESSED=Lh;  
  /*
    % WE WANT AN EQUAL NUMBER OF STATES TO BE REMAINING. THE NEXT LINES ENSURE
    % THIS.
    %
    if ~COMPLEX,
  */
  if (!COMPLEX) {    
    /*
      COMPLEX=1;
    */
    COMPLEX=1;
    /*
      PROCESSED=PROCESSED+1;
    */
    PROCESSED=PROCESSED+1;
    /*
      N=PROCESSED;
    */
    N=PROCESSED;
    /*
      for S = 2:2:M,
    */
    for (S=2;S<=M;S=S+2) {
      int M1,M2;
      /*
	PS=PREVIOUS(S,1);
      */
      PS=*(PREVIOUS+((1-1)*M+(S-1)));
      /*
	M1=METRIC(PS,N-1)+real(conj(SYMBOLS(S,1))*Y(N)-INCREMENT(PS,S));
      */
      M1=*(METRIC+((N-1-1)*M+(PS-1)))
	 +
	 *(SYMBOLSr+(S-1))**(Yr+(N-1))
	 +
	 *(SYMBOLSi+(S-1))**(Yi+(N-1))
	 - 
	 *(INCREMENT+((S-1)*M+(PS-1)));
      /*
	PS=PREVIOUS(S,2);
      */
      PS=*(PREVIOUS+((2-1)*M+(S-1)));
      /*
	M2=METRIC(PS,N-1)+real(conj(SYMBOLS(S,1))*Y(N)-INCREMENT(PS,S)); 
      */
      M2=*(METRIC+((N-1-1)*M+(PS-1)))
	 +
	 *(SYMBOLSr+(S-1))**(Yr+(N-1))
	 +
	 *(SYMBOLSi+(S-1))**(Yi+(N-1))
	 - 
	 *(INCREMENT+((S-1)*M+(PS-1)));
      /*
	if M1 > M2,
      */
      if (M1>M2) {
	/*
	  METRIC(S,N)=M1;
	*/
	*(METRIC+(M*(N-1)+(S-1)))=M1;
	/*
	  SURVIVOR(S,N)=PREVIOUS(S,1);
	*/
	*(SURVIVOR+((N-1)*M+(S-1)))=*(PREVIOUS+((1-1)*M+(S-1)));
	/*
	  else
	*/
      }
      else {
	/*
	  METRIC(S,N)=M2;
	*/
	*(METRIC+(M*(N-1)+(S-1)))=M2;
	/*
	  SURVIVOR(S,N)=PREVIOUS(S,2);
	*/
	*(SURVIVOR+((N-1)*M+(S-1)))=*(PREVIOUS+((2-1)*M+(S-1)));
	/*
	  end
	*/
      }
      /*	
		end
      */
    }
    /*
      end
    */
  }

#if DEBUG_RUN_IN
  /* The metric matrix is originally is MxSTEPS */
  /* Only the first PROCESSED columns are printed */
  /* Here it is addressed using MATLAB indexes */
  printf("METRIC=");
  for (m=1;m<=M;m++) {
    printf("\n ");
    for (n=1;n<=PROCESSED;n++) {
      printf("%3.0f ",*(METRIC+((n-1)*M+(m-1))));
    }
  }
  printf("\n");
#endif

  /*
    % NOW THAT WE HAVE MADE THE RUN-IN THE REST OF THE METRICS ARE
    % CALCULATED IN THE STRAIGHT FORWARD MANNER. OBSERVE THAT ONLY
    % THE RELEVANT STATES ARE CALCULATED, THAT IS REAL FOLLOWS COMPLEX
    % AND VICE VERSA.
    %
    N=PROCESSED+1;
  */
  N=PROCESSED+1;
  /*
    while N <= STEPS,
  */
  while (N<=STEPS) {
    int M1,M2;
    /*
      for S = 1:2:M-1,
    */
    for (S=1;S<=(M-1);S=S+2) {
      /*
	PS=PREVIOUS(S,1);
      */
      PS=*(PREVIOUS+((1-1)*M+(S-1)));
      /*
	M1=METRIC(PS,N-1)+real(conj(SYMBOLS(S,1))*Y(N)-INCREMENT(PS,S));
      */
      M1=*(METRIC+((N-1-1)*M+(PS-1)))
	 +
	 *(SYMBOLSr+(S-1))**(Yr+(N-1))
	 +
	 *(SYMBOLSi+(S-1))**(Yi+(N-1))
	 - 
	 *(INCREMENT+((S-1)*M+(PS-1)));      
      /*
	PS=PREVIOUS(S,2);
      */
      PS=*(PREVIOUS+((2-1)*M+(S-1)));
      /*
	M2=METRIC(PS,N-1)+real(conj(SYMBOLS(S,1))*Y(N)-INCREMENT(PS,S)); 
      */
      M2=*(METRIC+((N-1-1)*M+(PS-1)))
	 +
	 *(SYMBOLSr+(S-1))**(Yr+(N-1))
	 +
	 *(SYMBOLSi+(S-1))**(Yi+(N-1))
	 - 
	 *(INCREMENT+((S-1)*M+(PS-1)));
      /*	
	if M1 > M2,
      */
      if (M1>M2) {
	/*
	  METRIC(S,N)=M1;
	*/
	*(METRIC+(M*(N-1)+(S-1)))=M1;
	/*
	  SURVIVOR(S,N)=PREVIOUS(S,1);
	*/
	*(SURVIVOR+((N-1)*M+(S-1)))=*(PREVIOUS+((1-1)*M+(S-1)));
	/*
	  else
	*/
      }
      else {
	/*
	  METRIC(S,N)=M2;
	*/
	*(METRIC+(M*(N-1)+(S-1)))=M2;
	/*
	  SURVIVOR(S,N)=PREVIOUS(S,2);
	*/
	*(SURVIVOR+((N-1)*M+(S-1)))=*(PREVIOUS+((2-1)*M+(S-1)));
	/*
	  end
	*/
      }
      /*	
		end
      */
    }
    /*
      N=N+1;
    */
    N=N+1;
    /*
      for S = 2:2:M,
    */
    for (S=2;S<=M;S=S+2) {
      /*
	PS=PREVIOUS(S,1);
      */
      PS=*(PREVIOUS+((1-1)*M+(S-1)));
      /*
	M1=METRIC(PS,N-1)+real(conj(SYMBOLS(S,1))*Y(N)-INCREMENT(PS,S));
      */
      M1=*(METRIC+((N-1-1)*M+(PS-1)))
	 +
	 *(SYMBOLSr+(S-1))**(Yr+(N-1))
	 +
	 *(SYMBOLSi+(S-1))**(Yi+(N-1))
	 - 
	 *(INCREMENT+((S-1)*M+(PS-1)));      
      /*
	PS=PREVIOUS(S,2);
      */
      PS=*(PREVIOUS+((2-1)*M+(S-1)));
      /*
	M2=METRIC(PS,N-1)+real(conj(SYMBOLS(S,1))*Y(N)-INCREMENT(PS,S)); 
      */
      M2=*(METRIC+((N-1-1)*M+(PS-1)))
	 +
	 *(SYMBOLSr+(S-1))**(Yr+(N-1))
	 +
	 *(SYMBOLSi+(S-1))**(Yi+(N-1))
	 - 
	 *(INCREMENT+((S-1)*M+(PS-1)));
      /*	
	if M1 > M2,
      */
      if (M1>M2) {
	/*
	  METRIC(S,N)=M1;
	*/
	*(METRIC+(M*(N-1)+(S-1)))=M1;
	/*
	  SURVIVOR(S,N)=PREVIOUS(S,1);
	*/
	*(SURVIVOR+((N-1)*M+(S-1)))=*(PREVIOUS+((1-1)*M+(S-1)));
	/*
	  else
	*/
      }
      else {
	/*
	  METRIC(S,N)=M2;
	*/
	*(METRIC+(M*(N-1)+(S-1)))=M2;
	/*
	  SURVIVOR(S,N)=PREVIOUS(S,2);
	*/
	*(SURVIVOR+((N-1)*M+(S-1)))=*(PREVIOUS+((2-1)*M+(S-1)));
	/*
	  end
	*/
      }
      /*	
		end
      */
    }
    /*
      N=N+1;
    */
    N=N+1;
    /*
      end  
    */
  }

#if DEBUG_METRIC
  /* The metric matrix is originally is MxSTEPS */
  /* Only the first 10 columns are printed */
  /* Here it is addressed using MATLAB indexes */
  printf("Only printing first 10 columns of METRIC\n");
  printf("METRIC=");
  for (m=1;m<=M;m++) {
    printf("\n ");
    for (n=1;n<=10;n++) {
      printf("%3.0f ",*(METRIC+((n-1)*M+(m-1))));
    }
  }
  printf("\n");
  /* Also the last 10 columns are printed */
  printf("Only printing last 10 columns of METRIC\n");
  printf("METRIC=");
  for (m=1;m<=M;m++) {
    printf("\n ");
    for (n=(STEPS-10);n<=STEPS;n++) {
      printf("%3.0f ",*(METRIC+((n-1)*M+(m-1))));
    }
  }
  printf("\n");
#endif
  
  /*
    % HAVING CALCULATED THE METRICS, THE MOST PROBABLE STATESEQUENCE IS
    % INITIALIZED BY CHOOSING THE HIGHEST METRIC AMONG THE LEGAL STOP 
    % STATES.
    %
    BEST_LEGAL=0;
  */
  BEST_LEGAL=0;
  /*
    for FINAL = STOPS,
    
    The for FINAL=STOPS, shown above isn't available in C.  The thing
    to do is to determine the number of elements in STOPS, and then
    access them as they are needed.  
  */  
  switch (Lh) {
  case 2:
  case 3:
    ELEMENTS_IN_STOPS=1;
  case 4:
    ELEMENTS_IN_STOPS=2;
  }
  
  /*
    Now it is time to comence the for loop;
  */
  for (n=1;n<=ELEMENTS_IN_STOPS;n++) {
    FINAL=*(STOPS+(n-1));
    /*
      if METRIC(FINAL,STEPS) > BEST_LEGAL,
    */
    if (*(METRIC+((STEPS-1)*M+(FINAL-1)))>BEST_LEGAL) {
      /*
	S=FINAL;
      */
      S=FINAL;
      /*
	BEST_LEGAL=METRIC(FINAL,STEPS);
      */
      BEST_LEGAL=*(METRIC+((STEPS-1)*M+(FINAL-1)));
      /*
	end
      */
    }
    /*
      end
    */
  }
  
#if DEBUG_BEST_LEGAL
  printf("BEST_LEGAL=\n");
  printf(" %d \n\n",BEST_LEGAL);
  printf("S=\n");
  printf(" %d\n",S);
#endif 
  
  /*
    % UNCOMMENT FOR TEST OF METRIC
    %
    % METRIC
    % BEST_LEGAL
    % S
    % pause
    
    % HAVING FOUND THE FINAL STATE, THE MSK SYMBOL SEQUENCE IS ESTABLISHED
    %
    IEST(STEPS)=SYMBOLS(S,1);
  */
  *(IESTr+(STEPS-1))=*(SYMBOLSr+((1-1)*M+(S-1)));
  *(IESTi+(STEPS-1))=*(SYMBOLSi+((1-1)*M+(S-1)));
  /*
    N=STEPS-1;
  */
  N=STEPS-1;
  /*
    while N > 0,
  */
  while (N>0) {
    /*
      S=SURVIVOR(S,N+1);
    */
    S=*(SURVIVOR+((N+1-1)*M+(S-1)));
    /*
      IEST(N)=SYMBOLS(S,1);
    */
    *(IESTr+(N-1))=*(SYMBOLSr+((1-1)*M+(S-1)));
    *(IESTi+(N-1))=*(SYMBOLSi+((1-1)*M+(S-1)));
    /*
      N=N-1;
    */
    N=N-1;
    /*
      end
    */
  }
  /*
    % THE ESTIMATE IS NOW FOUND FROM THE FORMULA:
    % IEST(n)=j*rx_burst(n)*rx_burst(n-1)*IEST(n-1)
    % THE FORMULA IS REWRITTEN AS:
    % rx_burst(n)=IEST(n)/(j*rx_burst(n-1)*IEST(n-1))
    % FOR INITIALIZATION THE FOLLOWING IS USED:
    % IEST(0)=1 og rx_burst(0)=1
    %

    In lack of complex numbers the above is rewritten:

    We use the fact

    if IESTr(N)!=0 then 
    IESTi(N)==0 , IESTr(N-1)==0 and IESTi(N-1)!=0.
    
    rx_burst(1)=IEST(1)/(j*1*1);
  */
  *(rx_burst+(1-1))=*(IESTi+(1-1));
  /*
    for n = 2:STEPS,
  */
  for (n=2;n<=STEPS;n++) {
    /*
      rx_burst(n)=IEST(n)/(j*rx_burst(n-1)*IEST(n-1));
    */
    if (*(IESTr+(n-1)))
      *(rx_burst+(n-1))=-*(IESTr+(n-1))/(*(rx_burst+(n-1-1))**(IESTi+(n-1-1)));
    else 
      *(rx_burst+(n-1))=*(IESTi+(n-1))/(*(rx_burst+(n-1-1))**(IESTr+(n-1-1)));
    /*
      end
    */
  }
  /*
    % rx_burst IS POLAR (-1 AND 1), THIS TRANSFORMS IT TO
    % BINARY FORM (0 AND 1).
    %
    rx_burst=(rx_burst+1)./2;
  */
  for (n=1;n<=STEPS;n++) {
    *(rx_burst+(n-1))=(*(rx_burst+(n-1))+1)/2;
  }

#if DEBUG_RX_BURST
  printf("rx-burst=\n");
  for (n=1;n<=STEPS;n++) {
    printf("%2.0f ",*(rx_burst+(n-1)));
  }
  printf("\n");
#endif

}