trigwksp.c

Proakis《contemporarycommunication systems using matlab》matlab源代码

/*
 * TRIGWKSP   A SIMULINK trigged read from workspace
 *
 *           Syntax:  [sys, x0] = TRIGWKSP(t,x,u,flag,var, thd, cycl_flag, ini)
 *      This function is for SIMULINK Triggered read-from-workspace block.
 *      The block output a row of VAR at the raising edge of of the input
 *      inpulse. The output inpulse equals the colomn number of VAR. The 
 *      raising edge of the trigger signal is detected by greater or
 *      equals to the threshold. When the output index is greater than
 *      the row number of VAR, the block outputs zero if cycl_flag == 0.
 *      The block return to the vary begining of the VAR and cyclically
 *      output the same variable agian when cycl_flag ~= 0.
 *
 * Wes Wang  August 25, 1994
 * Copyright (c) 1995-6 by The MathWorks, Inc.
 * All Rights Reserved
 * $Revision: 1.1 $  $Date: 1996/04/01 19:07:23 $
 */

#define S_FUNCTION_NAME trigwksp


#ifdef MATLAB_MEX_FILE
#include <stdio.h>    /* needed for declaration of sprintf */
#include "mex.h"      /* needed for declaration of mexErrMsgTxt */
#endif

/*
 * need to include simstruc.h for the definition of the SimStruct and
 * its associated macro definitions.
 */

#include "simstruc.h"

/*
 * Defines for easy access of the input parameters
 */

#define NUM_ARGS       4
#define VARIABLE       ssGetArg(S,0)
#define THRESHOLD      ssGetArg(S,1)
#define CYCL_FLAG      ssGetArg(S,2)
#define INIOUTPUT      ssGetArg(S,3)

/*
 * mdlInitializeSizes - called to initialize the sizes array stored in
 *                      the SimStruct.  The sizes array defines the
 *                      characteristics (number of inputs, outputs,
 *                      states, etc.) of the S-Function.
 */

static void mdlInitializeSizes(S)
     SimStruct *S;
{
    /*
     * Set-up size information.
     */ 
    
    if (ssGetNumArgs(S) == NUM_ARGS) {
	int numOutput, maxBuffer;

	numOutput = mxGetN(VARIABLE);
	maxBuffer = mxGetM(VARIABLE);
	if (numOutput < 1) {
#ifdef MATLAB_MEX_FILE
	    char err_msg[256];
	    sprintf(err_msg, "Input variable is empty.");
	    mexErrMsgTxt(err_msg);
#endif    
        }

	if ((mxGetM(THRESHOLD) != 1) || (mxGetN(THRESHOLD) != 1) ) {
#ifdef MATLAB_MEX_FILE
	    char err_msg[256];
	    sprintf(err_msg, "Threshold must be a scalar.");
	    mexErrMsgTxt(err_msg);
#endif    
        }

	if ((mxGetM(CYCL_FLAG) != 1) || (mxGetN(CYCL_FLAG) != 1) ) {
#ifdef MATLAB_MEX_FILE
	    char err_msg[256];
	    sprintf(err_msg, "Cyclic flag must be a scalar.");
	    mexErrMsgTxt(err_msg);
#endif    
        }               
        
        ssSetNumContStates(    S, 0);
	ssSetNumDiscStates(    S, 0);
	ssSetNumInputs(        S, 1);
	ssSetNumOutputs(       S, numOutput);
	ssSetDirectFeedThrough(S, 1);
	ssSetNumInputArgs(     S, NUM_ARGS);
	ssSetNumSampleTimes(   S, 1);
	ssSetNumRWork(         S, 0);
	ssSetNumIWork(         S, 2);  /*Index and lastTrig*/
	ssSetNumPWork(         S, 0);
    } else {
#ifdef MATLAB_MEX_FILE
	char err_msg[256];
	sprintf(err_msg, "Wrong number of input arguments passed to S-function MEX-file.\n"
		"%d input arguments were passed in when expecting %d input arguments.\n", ssGetNumArgs(S) + 4, NUM_ARGS + 4);
	mexErrMsgTxt(err_msg);
#endif
    }
}

/*
 * mdlInitializeSampleTimes - initializes the array of sample times stored in
 *                            the SimStruct associated with this S-Function.
 */

static void mdlInitializeSampleTimes(S)
    SimStruct *S;
{
    /*
     * Note, blocks that are continuous in nature should have a single
     * sample time of 0.0.
     */

    ssSetSampleTimeEvent(S, 0, 0.0);
    ssSetOffsetTimeEvent(S, 0, 0.0);
}

/*
 * mdlInitializeConditions - initializes the states for the S-Function
 */

static void mdlInitializeConditions(x0, S)
    double *x0;
    SimStruct *S;
{

    int    *Index          = ssGetIWork(S);
    int    *lastTrig       = ssGetIWork(S) + 1;    

    int     numOutput      = mxGetN(VARIABLE);
    
    int i;
    
    *Index          = 0;
    *lastTrig       = 0;
}

/*
 * mdlOutputs - computes the outputs of the S-Function
 */

static void mdlOutputs(y, x, u, S, tid)
    double *y, *x, *u;
    SimStruct *S;
    int tid;
{
    int    *Index          = ssGetIWork(S);
    int    *lastTrig       = ssGetIWork(S) + 1;    

    int     numOutput      = mxGetN(VARIABLE);
    int     maxBuffer      = mxGetM(VARIABLE);
    int     cyclFlag       = (int)mxGetPr(CYCL_FLAG)[0];
    double  thd            = mxGetPr(THRESHOLD)[0];
    
    int     i, outIndex;
    
    if ((u[0] >= thd) & (*lastTrig == 0)) {
        outIndex = *Index;
        *Index += 1;
        if (cyclFlag != 0)
            outIndex %= maxBuffer;
	
        if (outIndex < maxBuffer) {
            for (i = 0; i < numOutput; i++)
                y[i] = mxGetPr(VARIABLE)[outIndex + i * maxBuffer];
        } else {
            for (i = 0; i < numOutput; i++)
                y[i] = 0.0;            
        }
        *lastTrig = 1;
    } else {
	if (ssGetT(S) <= 0.0) {
      if ((mxGetN(INIOUTPUT) * mxGetM(INIOUTPUT)) == numOutput) {
		for (i = 0; i < numOutput; i++)
		    y[i] = mxGetPr(INIOUTPUT)[i];
	    } else if ((mxGetN(INIOUTPUT) * mxGetM(INIOUTPUT)) <= 0) {
		for (i = 0; i < numOutput; i++)
		    y[i] = 0.0;
	  } else {
		for (i = 0; i < numOutput; i++)
		    y[i] = mxGetPr(INIOUTPUT)[0];
	    }	
	}
	if (*lastTrig == 1) {
	    if (u[0] < thd)
		*lastTrig = 0;
	}
  }
}

/*
 * mdlUpdate - computes the discrete states of the S-Function
 */

static void mdlUpdate(x, u, S, tid)
     double *x, *u;
     SimStruct *S;
     int tid;
{
}

/*
 * mdlDerivatives - computes the derivatives of the S-Function
 */

static void mdlDerivatives(dx, x, u, S, tid)
     double *dx, *x, *u;
     SimStruct *S; 
     int tid;
{
}

/*
 * mdlTerminate - called at termination of model execution.
 */

static void mdlTerminate(S)
     SimStruct *S;
{
}

#ifdef  MATLAB_MEX_FILE    /* Is this file being compiled as a MEX-file? */
#include "simulink.c"      /* MEX-File interface mechanism */
#else
#include "cg_sfun.h"       /* Code generation registration function */
#endif