/*
 * Real-Time Workshop code generation for Simulink model "Chirp0.mdl".
 *
 * Model Version                        : 1.0
 * Real-Time Workshop file version      : 5.0 $Date: 2002/05/30 19:21:33 $
 * Real-Time Workshop file generated on : Tue Dec 05 16:37:42 2006
 * TLC version                          : 5.0 (Jun 18 2002)
 * C source code generated on           : Tue Dec 05 16:37:42 2006
 */

#include <math.h>
#include <string.h>
#include "Chirp0.h"
#include "Chirp0_private.h"

/* Block signals (auto storage) */
BlockIO rtB;

/* External output (root outports fed by signals with auto storage) */
ExternalOutputs rtY;

/* Parent Simstruct */
static rtModel_Chirp0 model_S;
rtModel_Chirp0 *const rtM_Chirp0 = &model_S;

/* Start for root system: '<Root>' */
void MdlStart(void)
{
}

/* Outputs for root system: '<Root>' */
void MdlOutputs(int_T tid)
{
  /* local block i/o variables */
  real_T rtb_Clock1;

  /* tid is required for a uniform function interface. This system
   * is single rate, and in this case, tid is not accessed. */
  UNUSED_PARAMETER(tid);

  /* Clock: '<S1>/Clock1' */
  rtb_Clock1 = rtmGetT(rtM_Chirp0);

  /* Gain: '<S1>/Gain' incorporates:
   *   Product: '<S1>/Product'
   *   Constant: '<S1>/deltaFreq'
   *   Constant: '<S1>/targetTime'
   *
   * Regarding '<S1>/Gain':
   *   Gain value: rtP.Gain_Gain
   */
  rtB.Gain = (rtP.deltaFreq_Value / rtP.targetTime_Value) * rtP.Gain_Gain;

  /* Outport: '<Root>/Out2' incorporates:
   *   Trigonometry: '<S1>/Trigonometric Function'
   *   Product: '<S1>/Product2'
   *   Sum: '<S1>/Sum'
   *   Product: '<S1>/Product1'
   *   Constant: '<S1>/initialFreq'
   */
  rtY.Out2 = (sin((rtb_Clock1 * ((rtb_Clock1 * rtB.Gain) +
    rtP.initialFreq_Value))));
}

/* Update for root system: '<Root>' */
void MdlUpdate(int_T tid)
{

  /* tid is required for a uniform function interface. This system
   * is single rate, and in this case, tid is not accessed. */
  UNUSED_PARAMETER(tid);
}

/* Terminate for root system: '<Root>' */
void MdlTerminate(void)
{
  if(rtM_Chirp0 != NULL) {
  }
}

/* Function to initialize sizes */
void MdlInitializeSizes(void)
{
  rtM_Chirp0->Sizes.numContStates = (0); /* Number of continuous states */
  rtM_Chirp0->Sizes.numY = (1);         /* Number of model outputs */
  rtM_Chirp0->Sizes.numU = (0);         /* Number of model inputs */
  rtM_Chirp0->Sizes.sysDirFeedThru = (0); /* The model is not direct feedthrough */
  rtM_Chirp0->Sizes.numSampTimes = (2); /* Number of sample times */
  rtM_Chirp0->Sizes.numBlocks = (11);   /* Number of blocks */
  rtM_Chirp0->Sizes.numBlockIO = (1);   /* Number of block outputs */
  rtM_Chirp0->Sizes.numBlockPrms = (4); /* Sum of parameter "widths" */
}

/* Function to initialize sample times */
void MdlInitializeSampleTimes(void)
{
  /* task periods */
  rtM_Chirp0->Timing.sampleTimes[0] = (0.0);
  rtM_Chirp0->Timing.sampleTimes[1] = (0.2);

  /* task offsets */
  rtM_Chirp0->Timing.offsetTimes[0] = (0.0);
  rtM_Chirp0->Timing.offsetTimes[1] = (0.0);
}

/* Function to register the model */
rtModel_Chirp0 *Chirp0(void)
{
  (void)memset((char *)rtM_Chirp0, 0, sizeof(rtModel_Chirp0));

  {
    /* Setup solver object */
    static RTWSolverInfo rt_SolverInfo;
    rtM_Chirp0->solverInfo = (&rt_SolverInfo);

    rtsiSetSimTimeStepPtr(rtM_Chirp0->solverInfo,
     &rtM_Chirp0->Timing.simTimeStep);
    rtsiSetTPtr(rtM_Chirp0->solverInfo, &rtmGetTPtr(rtM_Chirp0));
    rtsiSetStepSizePtr(rtM_Chirp0->solverInfo, &rtM_Chirp0->Timing.stepSize);
    rtsiSetdXPtr(rtM_Chirp0->solverInfo, &rtM_Chirp0->ModelData.derivs);
    rtsiSetContStatesPtr(rtM_Chirp0->solverInfo,
     &rtM_Chirp0->ModelData.contStates);
    rtsiSetNumContStatesPtr(rtM_Chirp0->solverInfo,
     &rtM_Chirp0->Sizes.numContStates);
    rtsiSetErrorStatusPtr(rtM_Chirp0->solverInfo,
     &rtmGetErrorStatus(rtM_Chirp0));

    rtsiSetRTModelPtr(rtM_Chirp0->solverInfo, rtM_Chirp0);
  }

  /* timing info */
  {
    static time_T mdlPeriod[NSAMPLE_TIMES];
    static time_T mdlOffset[NSAMPLE_TIMES];
    static time_T mdlTaskTimes[NSAMPLE_TIMES];
    static int_T mdlTsMap[NSAMPLE_TIMES];
    static int_T mdlSampleHits[NSAMPLE_TIMES];

    {
      int_T i;

      for(i = 0; i < NSAMPLE_TIMES; i++) {
        mdlPeriod[i] = 0.0;
        mdlOffset[i] = 0.0;
        mdlTaskTimes[i] = 0.0;
      }
    }
    (void)memset((char_T *)&mdlTsMap[0], 0, 2 * sizeof(int_T));
    (void)memset((char_T *)&mdlSampleHits[0], 0, 2 * sizeof(int_T));

    rtM_Chirp0->Timing.sampleTimes = (&mdlPeriod[0]);
    rtM_Chirp0->Timing.offsetTimes = (&mdlOffset[0]);
    rtM_Chirp0->Timing.sampleTimeTaskIDPtr = (&mdlTsMap[0]);
    rtmSetTPtr(rtM_Chirp0, &mdlTaskTimes[0]);
    rtM_Chirp0->Timing.sampleHits = (&mdlSampleHits[0]);
  }
  rtsiSetSolverMode(rtM_Chirp0->solverInfo, SOLVER_MODE_SINGLETASKING);

  /*
   * initialize model vectors and cache them in SimStruct
   */

  /* block I/O */
  {
    void *b = (void *) &rtB;
    rtM_Chirp0->ModelData.blockIO = (b);

    {
      int_T i;

      b =&rtB.Gain;
      for (i = 0; i < 1; i++) {
        ((real_T*)b)[i] = 0.0;
      }
    }
  }

  /* external outputs */
  {
    rtM_Chirp0->ModelData.outputs = (&rtY);

    rtY.Out2 = 0.0;
  }

  /* parameters */
  rtM_Chirp0->ModelData.defaultParam = ((real_T *) &rtP);

  /* Model specific registration */

  rtM_Chirp0->modelName = ("Chirp0");
  rtM_Chirp0->path = ("Chirp0");

  rtmSetTStart(rtM_Chirp0, 0.0);
  rtM_Chirp0->Timing.tFinal = (10.0);
  rtM_Chirp0->Timing.stepSize = (0.2);
  rtsiSetFixedStepSize(rtM_Chirp0->solverInfo, 0.2);
  /* Setup for data logging */
  {
    static RTWLogInfo rt_DataLoggingInfo;

    rtM_Chirp0->rtwLogInfo = (&rt_DataLoggingInfo);

    rtliSetLogFormat(rtM_Chirp0->rtwLogInfo, 0);

    rtliSetLogMaxRows(rtM_Chirp0->rtwLogInfo, 1000);

    rtliSetLogDecimation(rtM_Chirp0->rtwLogInfo, 1);

    rtliSetLogVarNameModifier(rtM_Chirp0->rtwLogInfo, "rt_");

    rtliSetLogT(rtM_Chirp0->rtwLogInfo, "tout");

    rtliSetLogX(rtM_Chirp0->rtwLogInfo, "");

    rtliSetLogXFinal(rtM_Chirp0->rtwLogInfo, "");

    rtliSetLogXSignalInfo(rtM_Chirp0->rtwLogInfo, NULL);

    rtliSetLogXSignalPtrs(rtM_Chirp0->rtwLogInfo, NULL);

    rtliSetLogY(rtM_Chirp0->rtwLogInfo, "yout");

    /*
     * Set pointers to the data and signal info for each output
     */
    {
      static void * rt_LoggedOutputSignalPtrs[] = {
        &rtY.Out2
      };

      rtliSetLogYSignalPtrs(rtM_Chirp0->rtwLogInfo,
       ((LogSignalPtrsType)rt_LoggedOutputSignalPtrs));
    }
    {
      static const int_T rt_LoggedOutputWidths[] = {
        1
      };

      static const int_T rt_LoggedOutputNumDimensions[] = {
        2
      };

      static const int_T rt_LoggedOutputDimensions[] = {
        1,1
      };

      static const BuiltInDTypeId rt_LoggedOutputDataTypeIds[] = {
        SS_DOUBLE
      };

      static const int_T rt_LoggedOutputComplexSignals[] = {
        0
      };

      static const char_T rt_LoggedOutputLabels[] = "";

      static const int_T rt_LoggedOutputLabelLengths[] = {
        0
      };

      static const char_T rt_LoggedOutputBlockNames[] = "Chirp0/Out2";

      static const int_T rt_LoggedOutputBlockNameLengths[] = {
        11
      };

      static const RTWLogSignalInfo rt_LoggedOutputSignalInfo = {
        1,
        rt_LoggedOutputWidths,
        rt_LoggedOutputNumDimensions,
        rt_LoggedOutputDimensions,
        rt_LoggedOutputDataTypeIds,
        rt_LoggedOutputComplexSignals,
        NULL,
        rt_LoggedOutputLabels,
        rt_LoggedOutputLabelLengths,
        NULL,
        NULL,
        NULL,
        rt_LoggedOutputBlockNames,
        rt_LoggedOutputBlockNameLengths
      };

      rtliSetLogYSignalInfo(rtM_Chirp0->rtwLogInfo, &rt_LoggedOutputSignalInfo);
    }
  }

  rtM_Chirp0->Sizes.checksums[0] = (4205404016U);
  rtM_Chirp0->Sizes.checksums[1] = (938116397U);
  rtM_Chirp0->Sizes.checksums[2] = (598915818U);
  rtM_Chirp0->Sizes.checksums[3] = (875891496U);

  return rtM_Chirp0;
}