/*
 * PWM_sf.c
 *
 * Code generation for model "PWM_sf".
 *
 * Model version              : 1.825
 * Simulink Coder version : 9.4 (R2020b) 29-Jul-2020
 * C source code generated on : Fri Apr 14 12:53:29 2023
 *
 * Target selection: rtwsfcn.tlc
 * Note: GRT includes extra infrastructure and instrumentation for prototyping
 * Embedded hardware selection: ARM Compatible->ARM Cortex-M
 * Emulation hardware selection:
 *    Differs from embedded hardware (MATLAB Host)
 * Code generation objectives:
 *    1. Execution efficiency
 *    2. RAM efficiency
 * Validation result: Not run
 */

#include <math.h>
#include "PWM_sf.h"
#include "PWM_sf_private.h"
#include "simstruc.h"
#include "fixedpoint.h"
#if defined(RT_MALLOC) || defined(MATLAB_MEX_FILE)

extern void *PWM_malloc(SimStruct *S);

#endif

#ifndef __RTW_UTFREE__
#if defined (MATLAB_MEX_FILE)

extern void * utMalloc(size_t);
extern void utFree(void *);

#endif
#endif                                 /* #ifndef __RTW_UTFREE__ */

/* Forward declaration for local functions */
static real_T PWM_rt_remd_snf(real_T u0, real_T u1);

#if defined(MATLAB_MEX_FILE)
#include "rt_nonfinite.c"
#endif

static const char_T *RT_MEMORY_ALLOCATION_ERROR =
  "memory allocation error in generated S-Function";

/*
 * Time delay interpolation routine
 *
 * The linear interpolation is performed using the formula:
 *
 *          (t2 - tMinusDelay)         (tMinusDelay - t1)
 * u(t)  =  ----------------- * u1  +  ------------------- * u2
 *              (t2 - t1)                  (t2 - t1)
 */
real_T PWM_sf_rt_TDelayInterpolate(
  real_T tMinusDelay,                 /* tMinusDelay = currentSimTime - delay */
  real_T tStart,
  real_T *tBuf,
  real_T *uBuf,
  int_T bufSz,
  int_T *lastIdx,
  int_T oldestIdx,
  int_T newIdx,
  real_T initOutput,
  boolean_T discrete,
  boolean_T minorStepAndTAtLastMajorOutput)
{
  int_T i;
  real_T yout, t1, t2, u1, u2;

  /*
   * If there is only one data point in the buffer, this data point must be
   * the t= 0 and tMinusDelay > t0, it ask for something unknown. The best
   * guess if initial output as well
   */
  if ((newIdx == 0) && (oldestIdx ==0 ) && (tMinusDelay > tStart))
    return initOutput;

  /*
   * If tMinusDelay is less than zero, should output initial value
   */
  if (tMinusDelay <= tStart)
    return initOutput;

  /* For fixed buffer extrapolation:
   * if tMinusDelay is small than the time at oldestIdx, if discrete, output
   * tailptr value,  else use tailptr and tailptr+1 value to extrapolate
   * It is also for fixed buffer. Note: The same condition can happen for transport delay block where
   * use tStart and and t[tail] other than using t[tail] and t[tail+1].
   * See below
   */
  if ((tMinusDelay <= tBuf[oldestIdx] ) ) {
    if (discrete) {
      return(uBuf[oldestIdx]);
    } else {
      int_T tempIdx= oldestIdx + 1;
      if (oldestIdx == bufSz-1)
        tempIdx = 0;
      t1= tBuf[oldestIdx];
      t2= tBuf[tempIdx];
      u1= uBuf[oldestIdx];
      u2= uBuf[tempIdx];
      if (t2 == t1) {
        if (tMinusDelay >= t2) {
          yout = u2;
        } else {
          yout = u1;
        }
      } else {
        real_T f1 = (t2-tMinusDelay) / (t2-t1);
        real_T f2 = 1.0 - f1;

        /*
         * Use Lagrange's interpolation formula.  Exact outputs at t1, t2.
         */
        yout = f1*u1 + f2*u2;
      }

      return yout;
    }
  }

  /*
   * When block does not have direct feedthrough, we use the table of
   * values to extrapolate off the end of the table for delays that are less
   * than 0 (less then step size).  This is not completely accurate.  The
   * chain of events is as follows for a given time t.  Major output - look
   * in table.  Update - add entry to table.  Now, if we call the output at
   * time t again, there is a new entry in the table. For very small delays,
   * this means that we will have a different answer from the previous call
   * to the output fcn at the same time t.  The following code prevents this
   * from happening.
   */
  if (minorStepAndTAtLastMajorOutput) {
    /* pretend that the new entry has not been added to table */
    if (newIdx != 0) {
      if (*lastIdx == newIdx) {
        (*lastIdx)--;
      }

      newIdx--;
    } else {
      if (*lastIdx == newIdx) {
        *lastIdx = bufSz-1;
      }

      newIdx = bufSz - 1;
    }
  }

  i = *lastIdx;
  if (tBuf[i] < tMinusDelay) {
    /* Look forward starting at last index */
    while (tBuf[i] < tMinusDelay) {
      /* May occur if the delay is less than step-size - extrapolate */
      if (i == newIdx)
        break;
      i = ( i < (bufSz-1) ) ? (i+1) : 0;/* move through buffer */
    }
  } else {
    /*
     * Look backwards starting at last index which can happen when the
     * delay time increases.
     */
    while (tBuf[i] >= tMinusDelay) {
      /*
       * Due to the entry condition at top of function, we
       * should never hit the end.
       */
      i = (i > 0) ? i-1 : (bufSz-1);   /* move through buffer */
    }

    i = ( i < (bufSz-1) ) ? (i+1) : 0;
  }

  *lastIdx = i;
  if (discrete) {
    /*
     * tempEps = 128 * eps;
     * localEps = max(tempEps, tempEps*fabs(tBuf[i]))/2;
     */
    double tempEps = (DBL_EPSILON) * 128.0;
    double localEps = tempEps * fabs(tBuf[i]);
    if (tempEps > localEps) {
      localEps = tempEps;
    }

    localEps = localEps / 2.0;
    if (tMinusDelay >= (tBuf[i] - localEps)) {
      yout = uBuf[i];
    } else {
      if (i == 0) {
        yout = uBuf[bufSz-1];
      } else {
        yout = uBuf[i-1];
      }
    }
  } else {
    if (i == 0) {
      t1 = tBuf[bufSz-1];
      u1 = uBuf[bufSz-1];
    } else {
      t1 = tBuf[i-1];
      u1 = uBuf[i-1];
    }

    t2 = tBuf[i];
    u2 = uBuf[i];
    if (t2 == t1) {
      if (tMinusDelay >= t2) {
        yout = u2;
      } else {
        yout = u1;
      }
    } else {
      real_T f1 = (t2-tMinusDelay) / (t2-t1);
      real_T f2 = 1.0 - f1;

      /*
       * Use Lagrange's interpolation formula.  Exact outputs at t1, t2.
       */
      yout = f1*u1 + f2*u2;
    }
  }

  return(yout);
}

real_T PWM_look1_binlx(real_T u0, const real_T bp0[], const real_T table[],
  uint32_T maxIndex)
{
  real_T frac;
  real_T yL_0d0;
  uint32_T bpIdx;
  uint32_T iLeft;
  uint32_T iRght;

  /* Column-major Lookup 1-D
     Search method: 'binary'
     Use previous index: 'off'
     Interpolation method: 'Linear point-slope'
     Extrapolation method: 'Linear'
     Use last breakpoint for index at or above upper limit: 'off'
     Remove protection against out-of-range input in generated code: 'off'
   */
  /* Prelookup - Index and Fraction
     Index Search method: 'binary'
     Extrapolation method: 'Linear'
     Use previous index: 'off'
     Use last breakpoint for index at or above upper limit: 'off'
     Remove protection against out-of-range input in generated code: 'off'
   */
  if (u0 <= bp0[0U]) {
    iLeft = 0U;
    frac = (u0 - bp0[0U]) / (bp0[1U] - bp0[0U]);
  } else if (u0 < bp0[maxIndex]) {
    /* Binary Search */
    bpIdx = maxIndex >> 1U;
    iLeft = 0U;
    iRght = maxIndex;
    while (iRght - iLeft > 1U) {
      if (u0 < bp0[bpIdx]) {
        iRght = bpIdx;
      } else {
        iLeft = bpIdx;
      }

      bpIdx = (iRght + iLeft) >> 1U;
    }

    frac = (u0 - bp0[iLeft]) / (bp0[iLeft + 1U] - bp0[iLeft]);
  } else {
    iLeft = maxIndex - 1U;
    frac = (u0 - bp0[maxIndex - 1U]) / (bp0[maxIndex] - bp0[maxIndex - 1U]);
  }

  /* Column-major Interpolation 1-D
     Interpolation method: 'Linear point-slope'
     Use last breakpoint for index at or above upper limit: 'off'
     Overflow mode: 'wrapping'
   */
  yL_0d0 = table[iLeft];
  return (table[iLeft + 1U] - yL_0d0) * frac + yL_0d0;
}

static real_T PWM_rt_remd_snf(real_T u0, real_T u1)
{
  real_T q;
  real_T y;
  if (rtIsNaN(u0) || rtIsNaN(u1) || rtIsInf(u0)) {
    y = (rtNaN);
  } else if (rtIsInf(u1)) {
    y = u0;
  } else if ((u1 != 0.0) && (u1 != trunc(u1))) {
    q = fabs(u0 / u1);
    if (!(fabs(q - floor(q + 0.5)) > DBL_EPSILON * q)) {
      y = 0.0 * u0;
    } else {
      y = fmod(u0, u1);
    }
  } else {
    y = fmod(u0, u1);
  }

  return y;
}

/* Start for root system: '<Root>' */
#define MDL_START

static void mdlStart(SimStruct *S)
{
  /* instance underlying S-Function data */
#if defined(RT_MALLOC) || defined(MATLAB_MEX_FILE)
#if defined(MATLAB_MEX_FILE)

  /* non-finites */
  rt_InitInfAndNaN(sizeof(real_T));

  /* Check for invalid switching between solver types */
  if (ssIsVariableStepSolver(S)) {
    ssSetErrorStatus(S, "This Simulink Coder generated "
                     "S-Function cannot be used in a simulation with "
                     "a solver type of variable-step "
                     "because this S-Function was created from a model with "
                     "solver type of fixed-step and it has continuous time blocks. "
                     "See the Solver page of the simulation parameters dialog.");
    return;
  }

  if (fabs(ssGetFixedStepSize(S) - 5.0E-7) > mxGetEps()*100*5.0E-7) {
    ssSetErrorStatus(S, "This Simulink Coder generated "
                     "S-Function cannot be used in a simulation with "
                     "the current fixed step size "
                     "because this S-Function was created from a model with "
                     "a fixed step size of 5.0E-7 and had both "
                     "continuous blocks and discrete blocks running at this rate. "
                     "See the Solver page of the simulation parameters dialog.");
    return;
  }

#endif

  PWM_malloc(S);
  if (ssGetErrorStatus(S) != (NULL) ) {
    return;
  }

#endif

  {
    B_PWM_T *_rtB;
    _rtB = ((B_PWM_T *) ssGetLocalBlockIO(S));

    /* Start for TransportDelay: '<S2>/Transport Delay' */
    {
      real_T *pBuffer = &((real_T*) ssGetDWork(S, 0))[1];
      ((int_T*) ssGetDWork(S, 6))[0] = 0;
      ((int_T*) ssGetDWork(S, 6))[1] = 0;
      ((int_T*) ssGetDWork(S, 6))[2] = 0;
      ((int_T*) ssGetDWork(S, 6))[3] = 1024;
      pBuffer[0] = 0.0;
      pBuffer[1024] = ssGetT(S);
      ((void**) ssGetDWork(S, 3))[0] = (void *) &pBuffer[0];
      ((void**) ssGetDWork(S, 3))[1] = (void *) &pBuffer[1024];
    }

    /* Start for TransportDelay: '<S2>/Transport Delay1' */
    {
      real_T *pBuffer = &((real_T*) ssGetDWork(S, 1))[1];
      ((int_T*) ssGetDWork(S, 7))[0] = 0;
      ((int_T*) ssGetDWork(S, 7))[1] = 0;
      ((int_T*) ssGetDWork(S, 7))[2] = 0;
      ((int_T*) ssGetDWork(S, 7))[3] = 1024;
      pBuffer[0] = 0.0;
      pBuffer[1024] = ssGetT(S);
      ((void**) ssGetDWork(S, 4))[0] = (void *) &pBuffer[0];
      ((void**) ssGetDWork(S, 4))[1] = (void *) &pBuffer[1024];
    }

    /* Start for TransportDelay: '<S2>/Transport Delay2' */
    {
      real_T *pBuffer = &((real_T*) ssGetDWork(S, 2))[1];
      ((int_T*) ssGetDWork(S, 8))[0] = 0;
      ((int_T*) ssGetDWork(S, 8))[1] = 0;
      ((int_T*) ssGetDWork(S, 8))[2] = 0;
      ((int_T*) ssGetDWork(S, 8))[3] = 1024;
      pBuffer[0] = 0.0;
      pBuffer[1024] = ssGetT(S);
      ((void**) ssGetDWork(S, 5))[0] = (void *) &pBuffer[0];
      ((void**) ssGetDWork(S, 5))[1] = (void *) &pBuffer[1024];
    }
  }
}

/* Outputs for root system: '<Root>' */
static void mdlOutputs(SimStruct *S, int_T tid)
{
  /* local block i/o variables */
  real_T rtb_TransportDelay1;
  real_T rtb_TransportDelay2;
  real_T rtb_TransportDelay;
  B_PWM_T *_rtB;
  real_T expr_2_0_0;
  real_T rtb_Abs;
  real_T rtb_Abs2;
  boolean_T rtb_RelationalOperator;
  boolean_T rtb_RelationalOperator1;
  boolean_T rtb_RelationalOperator2;
  _rtB = ((B_PWM_T *) ssGetLocalBlockIO(S));
  if (ssIsContinuousTask(S, tid)) {
    /* S-Function (sfun_tstart): '<S3>/startTime' */
    /* S-Function Block (sfun_tstart): <S3>/startTime */
    expr_2_0_0 = ssGetTStart(S);

    /* Lookup_n-D: '<S3>/Look-Up Table1' incorporates:
     *  Clock: '<S3>/Clock'
     *  Constant: '<S3>/Constant'
     *  Math: '<S3>/Math Function'
     *  Sum: '<S3>/Sum'
     */
    expr_2_0_0 = PWM_look1_binlx(PWM_rt_remd_snf(ssGetT(S) - expr_2_0_0, 0.0001),
      PWM_ConstP.LookUpTable1_bp01Data, PWM_ConstP.LookUpTable1_tableData, 2U);

    /* RelationalOperator: '<S2>/Relational Operator' */
    rtb_RelationalOperator = (expr_2_0_0 > *((const real_T **)
      ssGetInputPortSignalPtrs(S, 0))[0]);

    /* TransportDelay: '<S2>/Transport Delay' */
    {
      real_T **uBuffer = (real_T**)&((void**) ssGetDWork(S, 3))[0];
      real_T **tBuffer = (real_T**)&((void**) ssGetDWork(S, 3))[1];
      real_T simTime = ssGetT(S);
      real_T tMinusDelay = simTime - 2.0E-6;
      rtb_TransportDelay = PWM_sf_rt_TDelayInterpolate(
        tMinusDelay,
        0.0,
        *tBuffer,
        *uBuffer,
        ((int_T*) ssGetDWork(S, 6))[3],
        &((int_T*) ssGetDWork(S, 6))[2],
        ((int_T*) ssGetDWork(S, 6))[0],
        ((int_T*) ssGetDWork(S, 6))[1],
        0.0,
        0,
        (boolean_T) (ssIsMinorTimeStep(S) && (ssGetTimeOfLastOutput(S) == ssGetT
        (S))));
    }

    /* DataTypeConversion: '<S2>/Data Type Conversion3' incorporates:
     *  Logic: '<S2>/Logical Operator'
     */
    rtb_Abs2 = !rtb_RelationalOperator;

    /* Abs: '<S2>/Abs' incorporates:
     *  DataTypeConversion: '<S2>/Data Type Conversion3'
     *  Sum: '<S2>/Subtract'
     */
    rtb_Abs = fabs(rtb_Abs2 - rtb_TransportDelay);

    /* Product: '<S2>/Product' */
    _rtB->Product = rtb_Abs2 * rtb_Abs;

    /* Product: '<S2>/Product1' */
    _rtB->Product1 = rtb_Abs * rtb_TransportDelay;

    /* RelationalOperator: '<S2>/Relational Operator1' */
    rtb_RelationalOperator1 = (expr_2_0_0 > *((const real_T **)
      ssGetInputPortSignalPtrs(S, 0))[1]);

    /* TransportDelay: '<S2>/Transport Delay1' */
    {
      real_T **uBuffer = (real_T**)&((void**) ssGetDWork(S, 4))[0];
      real_T **tBuffer = (real_T**)&((void**) ssGetDWork(S, 4))[1];
      real_T simTime = ssGetT(S);
      real_T tMinusDelay = simTime - 2.0E-6;
      rtb_TransportDelay1 = PWM_sf_rt_TDelayInterpolate(
        tMinusDelay,
        0.0,
        *tBuffer,
        *uBuffer,
        ((int_T*) ssGetDWork(S, 7))[3],
        &((int_T*) ssGetDWork(S, 7))[2],
        ((int_T*) ssGetDWork(S, 7))[0],
        ((int_T*) ssGetDWork(S, 7))[1],
        0.0,
        0,
        (boolean_T) (ssIsMinorTimeStep(S) && (ssGetTimeOfLastOutput(S) == ssGetT
        (S))));
    }

    /* RelationalOperator: '<S2>/Relational Operator2' */
    rtb_RelationalOperator2 = (expr_2_0_0 > *((const real_T **)
      ssGetInputPortSignalPtrs(S, 0))[2]);

    /* TransportDelay: '<S2>/Transport Delay2' */
    {
      real_T **uBuffer = (real_T**)&((void**) ssGetDWork(S, 5))[0];
      real_T **tBuffer = (real_T**)&((void**) ssGetDWork(S, 5))[1];
      real_T simTime = ssGetT(S);
      real_T tMinusDelay = simTime - 2.0E-6;
      rtb_TransportDelay2 = PWM_sf_rt_TDelayInterpolate(
        tMinusDelay,
        0.0,
        *tBuffer,
        *uBuffer,
        ((int_T*) ssGetDWork(S, 8))[3],
        &((int_T*) ssGetDWork(S, 8))[2],
        ((int_T*) ssGetDWork(S, 8))[0],
        ((int_T*) ssGetDWork(S, 8))[1],
        0.0,
        0,
        (boolean_T) (ssIsMinorTimeStep(S) && (ssGetTimeOfLastOutput(S) == ssGetT
        (S))));
    }

    /* DataTypeConversion: '<S2>/Data Type Conversion1' incorporates:
     *  Logic: '<S2>/Logical Operator1'
     *  ManualSwitch: '<S1>/Manual Switch'
     */
    rtb_Abs2 = !rtb_RelationalOperator1;

    /* Abs: '<S2>/Abs1' incorporates:
     *  DataTypeConversion: '<S2>/Data Type Conversion1'
     *  ManualSwitch: '<S1>/Manual Switch'
     *  Sum: '<S2>/Subtract1'
     */
    expr_2_0_0 = fabs(rtb_Abs2 - rtb_TransportDelay1);

    /* Outport: '<Root>/PWMb' incorporates:
     *  ManualSwitch: '<S1>/Manual Switch'
     *  Product: '<S2>/Product2'
     *  Product: '<S2>/Product3'
     */
    ((real_T *)ssGetOutputPortSignal(S, 0))[2] = rtb_Abs2 * expr_2_0_0;
    ((real_T *)ssGetOutputPortSignal(S, 0))[3] = expr_2_0_0 *
      rtb_TransportDelay1;

    /* DataTypeConversion: '<S2>/Data Type Conversion5' incorporates:
     *  Logic: '<S2>/Logical Operator2'
     *  ManualSwitch: '<S1>/Manual Switch'
     */
    expr_2_0_0 = !rtb_RelationalOperator2;

    /* Abs: '<S2>/Abs2' incorporates:
     *  ManualSwitch: '<S1>/Manual Switch'
     *  Sum: '<S2>/Subtract2'
     */
    rtb_Abs2 = fabs(expr_2_0_0 - rtb_TransportDelay2);

    /* Outport: '<Root>/PWMb' incorporates:
     *  ManualSwitch: '<S1>/Manual Switch'
     *  Product: '<S2>/Product4'
     *  Product: '<S2>/Product5'
     */
    ((real_T *)ssGetOutputPortSignal(S, 0))[0] = _rtB->Product;
    ((real_T *)ssGetOutputPortSignal(S, 0))[1] = _rtB->Product1;
    ((real_T *)ssGetOutputPortSignal(S, 0))[4] = expr_2_0_0 * rtb_Abs2;
    ((real_T *)ssGetOutputPortSignal(S, 0))[5] = rtb_Abs2 * rtb_TransportDelay2;

    /* DataTypeConversion: '<S2>/Data Type Conversion6' */
    _rtB->DataTypeConversion6 = rtb_RelationalOperator2;

    /* DataTypeConversion: '<S2>/Data Type Conversion2' */
    _rtB->DataTypeConversion2 = rtb_RelationalOperator1;
  }

  if (ssIsSampleHit(S, 1, tid)) {
  }

  if (ssIsContinuousTask(S, tid)) {
    /* DataTypeConversion: '<S2>/Data Type Conversion4' */
    _rtB->DataTypeConversion4 = rtb_RelationalOperator;
  }

  UNUSED_PARAMETER(tid);
}

/* Update for root system: '<Root>' */
#define MDL_UPDATE

static void mdlUpdate(SimStruct *S, int_T tid)
{
  B_PWM_T *_rtB;
  _rtB = ((B_PWM_T *) ssGetLocalBlockIO(S));
  if (ssIsContinuousTask(S, tid)) {
    /* Update for TransportDelay: '<S2>/Transport Delay' */
    {
      real_T **uBuffer = (real_T**)&((void**) ssGetDWork(S, 3))[0];
      real_T **tBuffer = (real_T**)&((void**) ssGetDWork(S, 3))[1];
      real_T simTime = ssGetT(S);
      ((int_T*) ssGetDWork(S, 6))[1] = ((((int_T*) ssGetDWork(S, 6))[1] <
        (((int_T*) ssGetDWork(S, 6))[3]-1)) ? (((int_T*) ssGetDWork(S, 6))[1]+1)
        : 0);
      if (((int_T*) ssGetDWork(S, 6))[1] == ((int_T*) ssGetDWork(S, 6))[0]) {
        ((int_T*) ssGetDWork(S, 6))[0] = ((((int_T*) ssGetDWork(S, 6))[0] <
          (((int_T*) ssGetDWork(S, 6))[3]-1)) ? (((int_T*) ssGetDWork(S, 6))[0]+
          1) : 0);
      }

      (*tBuffer)[((int_T*) ssGetDWork(S, 6))[1]] = simTime;
      (*uBuffer)[((int_T*) ssGetDWork(S, 6))[1]] = _rtB->DataTypeConversion4;
    }

    /* Update for TransportDelay: '<S2>/Transport Delay1' */
    {
      real_T **uBuffer = (real_T**)&((void**) ssGetDWork(S, 4))[0];
      real_T **tBuffer = (real_T**)&((void**) ssGetDWork(S, 4))[1];
      real_T simTime = ssGetT(S);
      ((int_T*) ssGetDWork(S, 7))[1] = ((((int_T*) ssGetDWork(S, 7))[1] <
        (((int_T*) ssGetDWork(S, 7))[3]-1)) ? (((int_T*) ssGetDWork(S, 7))[1]+1)
        : 0);
      if (((int_T*) ssGetDWork(S, 7))[1] == ((int_T*) ssGetDWork(S, 7))[0]) {
        ((int_T*) ssGetDWork(S, 7))[0] = ((((int_T*) ssGetDWork(S, 7))[0] <
          (((int_T*) ssGetDWork(S, 7))[3]-1)) ? (((int_T*) ssGetDWork(S, 7))[0]+
          1) : 0);
      }

      (*tBuffer)[((int_T*) ssGetDWork(S, 7))[1]] = simTime;
      (*uBuffer)[((int_T*) ssGetDWork(S, 7))[1]] = _rtB->DataTypeConversion2;
    }

    /* Update for TransportDelay: '<S2>/Transport Delay2' */
    {
      real_T **uBuffer = (real_T**)&((void**) ssGetDWork(S, 5))[0];
      real_T **tBuffer = (real_T**)&((void**) ssGetDWork(S, 5))[1];
      real_T simTime = ssGetT(S);
      ((int_T*) ssGetDWork(S, 8))[1] = ((((int_T*) ssGetDWork(S, 8))[1] <
        (((int_T*) ssGetDWork(S, 8))[3]-1)) ? (((int_T*) ssGetDWork(S, 8))[1]+1)
        : 0);
      if (((int_T*) ssGetDWork(S, 8))[1] == ((int_T*) ssGetDWork(S, 8))[0]) {
        ((int_T*) ssGetDWork(S, 8))[0] = ((((int_T*) ssGetDWork(S, 8))[0] <
          (((int_T*) ssGetDWork(S, 8))[3]-1)) ? (((int_T*) ssGetDWork(S, 8))[0]+
          1) : 0);
      }

      (*tBuffer)[((int_T*) ssGetDWork(S, 8))[1]] = simTime;
      (*uBuffer)[((int_T*) ssGetDWork(S, 8))[1]] = _rtB->DataTypeConversion6;
    }
  }

  UNUSED_PARAMETER(tid);
}

/* Termination for root system: '<Root>' */
static void mdlTerminate(SimStruct *S)
{
  B_PWM_T *_rtB;
  _rtB = ((B_PWM_T *) ssGetLocalBlockIO(S));

#if defined(RT_MALLOC) || defined(MATLAB_MEX_FILE)

  if (ssGetUserData(S) != (NULL) ) {
    rt_FREE(ssGetLocalBlockIO(S));
  }

  rt_FREE(ssGetUserData(S));

#endif

}

#if defined(RT_MALLOC) || defined(MATLAB_MEX_FILE)
#include "PWM_mid.h"
#endif

/* Function to initialize sizes. */
static void mdlInitializeSizes(SimStruct *S)
{
  ssSetNumSampleTimes(S, 2);           /* Number of sample times */
  ssSetNumContStates(S, 0);            /* Number of continuous states */
  ssSetNumNonsampledZCs(S, 0);         /* Number of nonsampled ZCs */

  /* Number of output ports */
  if (!ssSetNumOutputPorts(S, 1))
    return;

  /* outport number: 0 */
  if (!ssSetOutputPortVectorDimension(S, 0, 6))
    return;
  if (ssGetSimMode(S) != SS_SIMMODE_SIZES_CALL_ONLY) {
    ssSetOutputPortDataType(S, 0, SS_DOUBLE);
  }

  ssSetOutputPortSampleTime(S, 0, 0.0);
  ssSetOutputPortOffsetTime(S, 0, 0.0);
  ssSetOutputPortOptimOpts(S, 0, SS_REUSABLE_AND_LOCAL);

  /* Number of input ports */
  if (!ssSetNumInputPorts(S, 1))
    return;

  /* inport number: 0 */
  {
    if (!ssSetInputPortVectorDimension(S, 0, 3))
      return;
    if (ssGetSimMode(S) != SS_SIMMODE_SIZES_CALL_ONLY) {
      ssSetInputPortDataType(S, 0, SS_DOUBLE);
    }

    ssSetInputPortDirectFeedThrough(S, 0, 1);
    ssSetInputPortSampleTime(S, 0, 5.0E-7);
    ssSetInputPortOffsetTime(S, 0, 0.0);
    ssSetInputPortOverWritable(S, 0, 0);
    ssSetInputPortOptimOpts(S, 0, SS_NOT_REUSABLE_AND_GLOBAL);
  }

  ssSetRTWGeneratedSFcn(S, 1);         /* Generated S-function */

  /* DWork */
  if (!ssSetNumDWork(S, 9)) {
    return;
  }

  /* '<S2>/Transport Delay': RWORK */
  ssSetDWorkName(S, 0, "DWORK0");
  ssSetDWorkWidth(S, 0, 2049);

  /* '<S2>/Transport Delay1': RWORK */
  ssSetDWorkName(S, 1, "DWORK1");
  ssSetDWorkWidth(S, 1, 2049);

  /* '<S2>/Transport Delay2': RWORK */
  ssSetDWorkName(S, 2, "DWORK2");
  ssSetDWorkWidth(S, 2, 2049);

  /* '<S2>/Transport Delay': PWORK */
  ssSetDWorkName(S, 3, "DWORK3");
  ssSetDWorkWidth(S, 3, 2);
  ssSetDWorkDataType(S, 3, SS_POINTER);

  /* '<S2>/Transport Delay1': PWORK */
  ssSetDWorkName(S, 4, "DWORK4");
  ssSetDWorkWidth(S, 4, 2);
  ssSetDWorkDataType(S, 4, SS_POINTER);

  /* '<S2>/Transport Delay2': PWORK */
  ssSetDWorkName(S, 5, "DWORK5");
  ssSetDWorkWidth(S, 5, 2);
  ssSetDWorkDataType(S, 5, SS_POINTER);

  /* '<S2>/Transport Delay': IWORK */
  ssSetDWorkName(S, 6, "DWORK6");
  ssSetDWorkWidth(S, 6, 4);
  ssSetDWorkDataType(S, 6, SS_INTEGER);

  /* '<S2>/Transport Delay1': IWORK */
  ssSetDWorkName(S, 7, "DWORK7");
  ssSetDWorkWidth(S, 7, 4);
  ssSetDWorkDataType(S, 7, SS_INTEGER);

  /* '<S2>/Transport Delay2': IWORK */
  ssSetDWorkName(S, 8, "DWORK8");
  ssSetDWorkWidth(S, 8, 4);
  ssSetDWorkDataType(S, 8, SS_INTEGER);

  /* Tunable Parameters */
  ssSetNumSFcnParams(S, 0);

  /* Number of expected parameters */
#if defined(MATLAB_MEX_FILE)

  if (ssGetNumSFcnParams(S) == ssGetSFcnParamsCount(S)) {

#if defined(MDL_CHECK_PARAMETERS)

    mdlCheckParameters(S);

#endif                                 /* MDL_CHECK_PARAMETERS */

    if (ssGetErrorStatus(S) != (NULL) ) {
      return;
    }
  } else {
    return;                /* Parameter mismatch will be reported by Simulink */
  }

#endif                                 /* MATLAB_MEX_FILE */

  /* Options */
  ssSetOptions(S, (SS_OPTION_RUNTIME_EXCEPTION_FREE_CODE |
                   SS_OPTION_PORT_SAMPLE_TIMES_ASSIGNED ));

#if SS_SFCN_FOR_SIM

  {
    ssSupportsMultipleExecInstances(S, false);
    ssRegisterMsgForNotSupportingMultiExecInst(S,
      "<diag_root><diag id=\"Simulink:blocks:BlockDoesNotSupportMultiExecInstances\" pr=\"d\"><arguments><arg type=\"encoded\">UABXAE0ALwBQAFcATQAvAG0AbwBkAHUAbABhAHQAZQBkACAAdwBhAHYAZQAvAHMAdABhAHIAdABUAGkAbQBlAAAA</arg><arg type=\"encoded\">PABfAF8AaQBpAFMAUwBfAF8APgA8AC8AXwBfAGkAaQBTAFMAXwBfAD4AAAA=</arg><arg type=\"encoded\">PABfAF8AaQB0AGUAcgBCAGwAawBfAF8APgA8AC8AXwBfAGkAdABlAHIAQgBsAGsAXwBfAD4AAAA=</arg></arguments><hs><h>AAAACIDlzUD+</h></hs></diag></diag_root>");
    ssHasStateInsideForEachSS(S, false);
  }

#endif

}

/* Function to initialize sample times. */
static void mdlInitializeSampleTimes(SimStruct *S)
{
  /* task periods */
  ssSetSampleTime(S, 0, 0.0);
  ssSetSampleTime(S, 1, 5.0E-7);

  /* task offsets */
  ssSetOffsetTime(S, 0, 0.0);
  ssSetOffsetTime(S, 1, 0.0);
}

#if defined(MATLAB_MEX_FILE)
#include "fixedpoint.c"
#include "simulink.c"
#else
#undef S_FUNCTION_NAME
#define S_FUNCTION_NAME                PWM_sf
#include "cg_sfun.h"
#endif                                 /* defined(MATLAB_MEX_FILE) */