/*
 * File: external_test.c
 *
 * Code generated for Simulink model 'external_test'.
 *
 * Model version                  : 1.5
 * Simulink Coder version         : 8.0 (R2011a) 09-Mar-2011
 * TLC version                    : 8.0 (Feb  3 2011)
 * C/C++ source code generated on : Sat Mar 24 19:12:40 2012
 *
 * Target selection: ert.tlc
 * Embedded hardware selection: 32-bit Generic
 * Code generation objectives: Unspecified
 * Validation result: Not run
 */

#include "external_test.h"
#include "external_test_private.h"
#include <stdio.h>
#include "external_test_dt.h"

/* Block signals (auto storage) */
BlockIO_external_test external_test_B;

/* Block states (auto storage) */
D_Work_external_test external_test_DWork;

/* Real-time model */
RT_MODEL_external_test external_test_M_;
RT_MODEL_external_test *const external_test_M = &external_test_M_;

/* Model step function */
void external_test_step(void)
{
  real_T rtb_SineWave;

  {
    boolean_T rtmStopReq = FALSE;
    rtExtModePauseIfNeeded(external_test_M->extModeInfo, 2, &rtmStopReq);
    if (rtmStopReq) {
      rtmSetStopRequested(external_test_M, TRUE);
    }

    if (rtmGetStopRequested(external_test_M) == TRUE) {
      rtmSetErrorStatus(external_test_M, "Simulation finished");
      return;
    }
  }

  /* Sin: '<Root>/Sine Wave' */
  rtb_SineWave = sin(external_test_P.SineWave_Freq * external_test_M->Timing.t[0]
                     + external_test_P.SineWave_Phase) *
    external_test_P.SineWave_Amp + external_test_P.SineWave_Bias;

  /* Gain: '<Root>/Gain A' */
  external_test_B.GainA = external_test_P.GainA_Gain * rtb_SineWave;

  /* Gain: '<Root>/Gain B' */
  external_test_B.GainB = external_test_P.GainB_Gain * rtb_SineWave;

  /* external mode */
  {
    boolean_T rtmStopReq = FALSE;
    rtExtModeOneStep(external_test_M->extModeInfo, 2, &rtmStopReq);
    if (rtmStopReq) {
      rtmSetStopRequested(external_test_M, TRUE);
    }
  }

  rtExtModeUploadCheckTrigger(2);

  {                                    /* Sample time: [0.0s, 0.0s] */
    rtExtModeUpload(0, external_test_M->Timing.t[0]);
  }

  {                                    /* Sample time: [0.01s, 0.0s] */
    rtExtModeUpload(1, ((external_test_M->Timing.clockTick1) * 0.01));
  }

  /* signal main to stop simulation */
  {                                    /* Sample time: [0.0s, 0.0s] */
    if ((rtmGetTFinal(external_test_M)!=-1) &&
        !((rtmGetTFinal(external_test_M)-external_test_M->Timing.t[0]) >
          external_test_M->Timing.t[0] * (DBL_EPSILON))) {
      rtmSetErrorStatus(external_test_M, "Simulation finished");
    }

    if (rtmGetStopRequested(external_test_M)) {
      rtmSetErrorStatus(external_test_M, "Simulation finished");
    }
  }

  /* Update absolute time for base rate */
  /* The "clockTick0" counts the number of times the code of this task has
   * been executed. The absolute time is the multiplication of "clockTick0"
   * and "Timing.stepSize0". Size of "clockTick0" ensures timer will not
   * overflow during the application lifespan selected.
   */
  external_test_M->Timing.t[0] =
    (++external_test_M->Timing.clockTick0) * external_test_M->Timing.stepSize0;

  {
    /* Update absolute timer for sample time: [0.01s, 0.0s] */
    /* The "clockTick1" counts the number of times the code of this task has
     * been executed. The resolution of this integer timer is 0.01, which is the step size
     * of the task. Size of "clockTick1" ensures timer will not overflow during the
     * application lifespan selected.
     */
    external_test_M->Timing.clockTick1++;
  }
}

/* Model initialize function */
void external_test_initialize(void)
{
  /* Registration code */

  /* initialize real-time model */
  (void) memset((void *)external_test_M, 0,
                sizeof(RT_MODEL_external_test));

  {
    /* Setup solver object */
    rtsiSetSimTimeStepPtr(&external_test_M->solverInfo,
                          &external_test_M->Timing.simTimeStep);
    rtsiSetTPtr(&external_test_M->solverInfo, &rtmGetTPtr(external_test_M));
    rtsiSetStepSizePtr(&external_test_M->solverInfo,
                       &external_test_M->Timing.stepSize0);
    rtsiSetErrorStatusPtr(&external_test_M->solverInfo, (&rtmGetErrorStatus
      (external_test_M)));
    rtsiSetRTModelPtr(&external_test_M->solverInfo, external_test_M);
  }

  rtsiSetSimTimeStep(&external_test_M->solverInfo, MAJOR_TIME_STEP);
  rtsiSetSolverName(&external_test_M->solverInfo,"FixedStepDiscrete");
  rtmSetTPtr(external_test_M, &external_test_M->Timing.tArray[0]);
  rtmSetTFinal(external_test_M, 10.0);
  external_test_M->Timing.stepSize0 = 0.01;

  /* external mode info */
  external_test_M->Sizes.checksums[0] = (2723025871U);
  external_test_M->Sizes.checksums[1] = (2876169446U);
  external_test_M->Sizes.checksums[2] = (4234945662U);
  external_test_M->Sizes.checksums[3] = (132669146U);

  {
    static const sysRanDType rtAlwaysEnabled = SUBSYS_RAN_BC_ENABLE;
    static RTWExtModeInfo rt_ExtModeInfo;
    static const sysRanDType *systemRan[1];
    external_test_M->extModeInfo = (&rt_ExtModeInfo);
    rteiSetSubSystemActiveVectorAddresses(&rt_ExtModeInfo, systemRan);
    systemRan[0] = &rtAlwaysEnabled;
    rteiSetModelMappingInfoPtr(external_test_M->extModeInfo,
      &external_test_M->SpecialInfo.mappingInfo);
    rteiSetChecksumsPtr(external_test_M->extModeInfo,
                        external_test_M->Sizes.checksums);
    rteiSetTPtr(external_test_M->extModeInfo, rtmGetTPtr(external_test_M));
  }

  /* block I/O */
  (void) memset(((void *) &external_test_B), 0,
                sizeof(BlockIO_external_test));

  /* states (dwork) */
  (void) memset((void *)&external_test_DWork, 0,
                sizeof(D_Work_external_test));

  /* data type transition information */
  {
    static DataTypeTransInfo dtInfo;
    (void) memset((char_T *) &dtInfo, 0,
                  sizeof(dtInfo));
    external_test_M->SpecialInfo.mappingInfo = (&dtInfo);
    dtInfo.numDataTypes = 14;
    dtInfo.dataTypeSizes = &rtDataTypeSizes[0];
    dtInfo.dataTypeNames = &rtDataTypeNames[0];

    /* Block I/O transition table */
    dtInfo.B = &rtBTransTable;

    /* Parameters transition table */
    dtInfo.P = &rtPTransTable;
  }

  /* External mode */
  rtERTExtModeSetTFinal(&rtmGetTFinal(external_test_M));
  rtExtModeCheckInit(2);

  {
    boolean_T rtmStopReq = FALSE;
    rtExtModeWaitForStartPkt(external_test_M->extModeInfo, 2, &rtmStopReq);
    if (rtmStopReq) {
      rtmSetStopRequested(external_test_M, TRUE);
    }
  }

  (void)printf("\n** starting the model **\n");
}

/* Model terminate function */
void external_test_terminate(void)
{
}

/*
 * File trailer for generated code.
 *
 * [EOF]
 */