mex_scrambler.c

一个UWB仿真程序包

#include <math.h>
#include <assert.h>

#include "mex.h"

#define NB 16 /* Size of the LFSR */

short int*
run_lfsr(int row, int col,
	 double* init_buf);
void
get_scrambler(int row, int col,
	      short int* register_buf, double* scrambler);
void
get_ths(int row, int col,
	int Ncpb, int m,
	short int* register_buf, double* ths);
void
print_usage();

void mexFunction(int nlhs, mxArray *plhs[], int nrhs,
                 const mxArray *prhs[])
{
  int row,col,Ncpb,m;
  int k;
  short int* register_buf;
  double *init_buf;

  
  /* Check for proper number of arguments */
  if (nrhs != 5) {
    print_usage();
    mexErrMsgTxt("5 inputs required");
  }
  
  /* The inputs must be a noncomplex scalar double */
  if (!mxIsDouble(prhs[0]) || mxIsComplex(prhs[0]) ||
      !(mxGetM(prhs[0]) == 1 && mxGetN(prhs[0]) == 1))
    mexErrMsgTxt("Input 1 must be a noncomplex scalar double");
  /* Assign (default) values to input */
  row = (int)mxGetScalar(prhs[0]);


  if (!mxIsDouble(prhs[1]) || mxIsComplex(prhs[1]) ||
      !(mxGetM(prhs[1]) == 1 && mxGetN(prhs[1]) == 1))
    mexErrMsgTxt("Input 2 must be a noncomplex scalar double");
  /* Assign pointers to input */
  col = (int)mxGetScalar(prhs[1]);

  if (!mxIsDouble(prhs[2]) || mxIsComplex(prhs[2]) ||
      !(mxGetM(prhs[2]) == 1 && mxGetN(prhs[2]) == 1))
    mexErrMsgTxt("Input 3 must be a noncomplex scalar double");
  /* Assign pointers to input */
  Ncpb = (int)mxGetScalar(prhs[2]);

  if (!mxIsDouble(prhs[3]) || mxIsComplex(prhs[3]) ||
      !(mxGetM(prhs[3]) == 1 && mxGetN(prhs[3]) == 1))
    mexErrMsgTxt("Input 4 must be a noncomplex scalar double");
  /* Assign pointers to input */
  m = (int)mxGetScalar(prhs[3]);


  if (!mxIsDouble(prhs[4]) || mxIsComplex(prhs[4]) ||
      !(mxGetM(prhs[4]) == 1 && mxGetN(prhs[4]) == NB))
    mexErrMsgTxt("Input 5 must be a vector of size [1 x NB]");
  /* Assign pointers to input */
  init_buf = mxGetPr(prhs[4]);

#ifdef MATLABDEBUG
  mexPrintf("lfsr: row  = %d\n",row);
  mexPrintf("lfsr: col  = %d\n",col);
  mexPrintf("lfsr: Ncpb = %d\n",Ncpb);
  mexPrintf("lfsr: m    = %d\n",m);
#endif

  /* Create matrix for the return argument */
  plhs[0] = mxCreateDoubleMatrix(row,col,mxREAL);
  plhs[1] = mxCreateDoubleMatrix(1,((row*col)-((row*col) % Ncpb))/Ncpb,mxREAL);
  
  /* Call the lfrs subroutine */
  register_buf = run_lfsr(row, col, init_buf);

  /* Format the output */
  get_scrambler(row, col, register_buf, mxGetPr(plhs[0]));

  /* Compute the THS */
  get_ths(row, col, Ncpb, m, register_buf, mxGetPr(plhs[1]));

  /* Cleanup */
  mxFree(register_buf);

}

short int*
run_lfsr(int row, int col,
	 double* init_buf)
{
  int k,l,r;
  short int* register_buf;

  /* n+1 necessary to make space for the second line */
  if ( (row+1)*NB > (row+1)*col ) {
    register_buf = (short int *)mxMalloc((size_t)(((row+1)*NB)* sizeof(short int)));
  } else {
    register_buf = (short int *)mxMalloc((size_t)(((row+1)*col)* sizeof(short int)));
  }

  if (!register_buf) {
    mexErrMsgTxt("lfsr: allocation failure");
    exit(-1);
  }

  /* Initialize the buffer */
  if (!init_buf) {
    for (k=0; k<NB-1; k++) {
      register_buf[k]=0;
    }
    register_buf[NB-1]=1;
  } else {
    for (k=0; k<NB; k++) {
      /* Input checking */
      if ((short int)init_buf[k] == 1 || (short int)init_buf[k] == 0)
	register_buf[k]=(short int)init_buf[k];
      else
	mexErrMsgTxt("lfsr: register should be initialized to 0 or 1");
    }
  }

#ifdef MATLABDEBUG
  mexPrintf("lfsr: ");
  for (k=0; k<NB; k++) {
    mexPrintf("%d ",register_buf[k]);
  }
  mexPrintf("\n");
#endif

  /* Start to iterate on the LFSR */
  for (k=0; k<row*col; k++) {
    register_buf[NB+k] = register_buf[k] ^ register_buf[k+1];
  }

  return register_buf;
}

void
get_scrambler(int row, int col,
	      short int* register_buf, double* scrambler)
{
  int k,l,r;

  /* Extract the output */
  l = 0;
  r = 0;
  for (k=0; k<row*col; k++) {
    scrambler[l] = (double)register_buf[NB+k];
    /* register_content[l] = (double)k; */
    l+=row;
    if (l>=row*col) {
      r++;
      l = r;
    }
  }

}

void
get_ths(int row, int col,
	int Ncpb, int m,
	short int* register_buf, double* ths)
{
  int k,l,n;

#ifdef MATLABDEBUG
  mexPrintf("Compute the THS\n");
  mexPrintf("lfsr: Ncpb = %d\n",Ncpb);
  mexPrintf("lfsr: m    = %d\n",m);
#endif

  /* Compute THS */
  n = 0;
  for (k=0; k<row*col; k += Ncpb) {
    ths[n] = (double)register_buf[NB+k];
    /* mexPrintf("%u\n",register_buf[NB+k]); */
    for (l=1; l<m; l++) {
      ths[n] += (register_buf[NB+k-l])*pow(2,l);
    }
    /* mexPrintf("%2.2f\n",ths[n]); */
    n++;
  }

}

void
print_usage()
{
  mexPrintf("usage: mex_scrambler(row,col,Ncpb,m,init)\n");
  mexPrintf("usage:\n");
  mexPrintf("usage: ACHTUNG! the LFSR is initialized from right to left.\n");
  mexPrintf("       The oldest state is on the left.\n");
}