Project 2 Adaptive Cruise Control

REQUIREMENT Tagging and Tracebility report 

all the requirements are tagged for better understandability, anyone who is reviewing the model or who is trying to update the model can get a clear idea of what logic is used in the system. from the requirement manager, we can see what are all are tagged and the description.

• REQUIREMENT 1 TAG WITH Lead_Vehicle_Mode Subsystem
  

• REQUIREMENT 1 TAG WITH Drive_Vehicle_Mode_Subsystem

• REQUIREMENT 1 TAG WITH ACC_Mode Subsystem
  

DEVELOPING SLDD:

All the inputs, outputs, calibration parameters are saved in SLDD so while simulation the model takes all the values and its parameters from the Simulink Data Dictionary

•  Signal Resolution for inputs and outputs

The inputs and output signals are resolved so the signals will take the values from sldd and pass them to the logical blocks. Otherwise, it may take some junk values if it is unresolved

• Model Update.

The model update is done by Ctrl-D. this is done to check for any static errors. If no errors are coming the model is working fine without any errors.

• Simulation

The model is simulated too for checking for errors and warnings

• Configuration Parameter Update

Various configuration parameters are updated as per the code generation the solver type should be fixed for  code generation 

Model Advisory Report

By running the model advisor tool, we can see commonly made modelling errors.

For this,

Go to model advisor check>by task>ony check modelling standards with MAB>Run selected checks.

Code generation 

For this code generation go to APPS tab then embeded coder then choose c code and generate that code which has been attached to code window.

The c code generated is :

       *  Inport: '/Time_Gap'
       */
      if (((*DriveVehicle_speed < Set_Speed) && (LeadVehicle_Speed >
            *DriveVehicle_speed)) || (Time_Gap >= Set_Gap)) {
        rtDW.is_ACC_ON_MODE = IN_LeadVehicle_Detected_Resume;

        /* ForcingFunction for Outport: '/Acceleration_Mode' */
        rtY.Acceleration_Mode = 3.0;
      } else if ((LeadVehicle_Detected == 0) || (*DriveVehicle_speed <=
                  Set_Speed)) {
        rtDW.is_ACC_ON_MODE = IN_LeadVehicle_Not_Detected_Res;

        /* ForcingFunction for Outport: '/Acceleration_Mode' */
        rtY.Acceleration_Mode = 1.0;
      } else {
        if (((LeadVehicle_Speed < Set_Speed) && (LeadVehicle_Speed <
              *DriveVehicle_speed)) || ((int32_T)rt_roundd_snf(0.75 * (real_T)
              Set_Gap) == Time_Gap)) {
          rtDW.is_ACC_ON_MODE = IN_LeadVehicle_Speed_lessthan_S;

          /* ForcingFunction for Outport: '/Acceleration_Mode' */
          rtY.Acceleration_Mode = 4.0;
        }
      }
      break;

     default:
      /* ForcingFunction for Outport: '/Acceleration_Mode' */
      /* case IN_LeadVehicle_Speed_lessthan_Set_Speed: */
      rtY.Acceleration_Mode = 4.0;

      /* Inport: '/Set_Speed' */
      if ((LeadVehicle_Detected == 0) && (*DriveVehicle_speed == Set_Speed)) {
        rtDW.is_ACC_ON_MODE = IN_LeadVehicle_Not_Detected;

        /* ForcingFunction for Outport: '/Acceleration_Mode' */
        rtY.Acceleration_Mode = 1.0;
      } else {
        tmp = (int32_T)rt_roundd_snf((real_T)LeadVehicle_Speed * 1.25);

        /* Inport: '/Set_Gap' */
        tmp_0 = (int32_T)rt_roundd_snf(1.25 * (real_T)Set_Gap);
        if (tmp < 256) {
          tmp_1 = (uint8_T)tmp;
        } else {
          tmp_1 = MAX_uint8_T;
        }

        if (tmp_0 < 256) {
          tmp_2 = (uint8_T)tmp_0;
        } else {
          tmp_2 = MAX_uint8_T;
        }

        /* Inport: '/Time_Gap' incorporates:
         *  Inport: '/Set_Gap'
         */
        if ((tmp_1 >= *DriveVehicle_speed) && (rt_roundd_snf((real_T)
              LeadVehicle_Speed * 0.75) <= *DriveVehicle_speed) &&
            (*DriveVehicle_speed < Set_Speed) && (Time_Gap <= tmp_2) &&
            (Time_Gap >= (int32_T)rt_roundd_snf(0.75 * (real_T)Set_Gap))) {
          rtDW.is_ACC_ON_MODE = IN_LeadVehicle_Speed_equal_Set_;

          /* ForcingFunction for Outport: '/Acceleration_Mode' */
          rtY.Acceleration_Mode = 5.0;
        }
      }
      break;
    }
  }

  /* End of Inport: '/CruiseSwitch' */
}

/* Model step function */
void Final_Project_step(void)
{
  real_T DriveVehicle_speed;
  if (rtmIsMajorTimeStep(rtM)) {
    /* set solver stop time */
    rtsiSetSolverStopTime(&rtM->solverInfo,((rtM->Timing.clockTick0+1)*
      rtM->Timing.stepSize0));
  }                                    /* end MajorTimeStep */

  /* Update absolute time of base rate at minor time step */
  if (rtmIsMinorTimeStep(rtM)) {
    rtM->Timing.t[0] = rtsiGetT(&rtM->solverInfo);
  }

  /* SignalConversion: '/Signal Conversion' incorporates:
   *  Inport: '/RadarInput_DriveVehicle'
   */
  LeadVehicle_Detected = RadarInput_DriveVehicle;

  /* Sum: '/Add1' incorporates:
   *  Inport: '/CameraInput_DriveVehicle'
   *  Inport: '/RadarInput_DriveVehicle'
   *  Integrator: '/Integrator'
   *  Sum: '/Add'
   */
  DriveVehicle_speed = ((real_T)CameraInput_DriveVehicle + rtX.Integrator_CSTATE)
    + (real_T)RadarInput_DriveVehicle;
  if (rtmIsMajorTimeStep(rtM)) {
    /* Sum: '/Add' incorporates:
     *  Inport: '/CameraInput_LeadVehicle'
     *  Inport: '/RadarInput_LeadVehicle'
     */
    LeadVehicle_Speed = (uint8_T)((uint32_T)CameraInput_LeadVehicle +
      RadarInput_LeadVehicle);

    /* Chart: '/Chart' incorporates:
     *  Inport: '/CruiseSwitch'
     *  Inport: '/SetSwitch'
     */
    if (rtDW.is_active_c3_Final_Project == 0U) {
      rtDW.is_active_c3_Final_Project = 1U;
      rtDW.is_c3_Final_Project = IN_ACC_OFF_MODE;

      /* Outport: '/Acceleration_Mode' */
      rtY.Acceleration_Mode = 0.0;
    } else {
      switch (rtDW.is_c3_Final_Project) {
       case IN_ACC_OFF_MODE:
        /* Outport: '/Acceleration_Mode' */
        rtY.Acceleration_Mode = 0.0;
        if (CruiseSwitch) {
          rtDW.is_c3_Final_Project = IN_ACC_STANDBY_MODE;

          /* Outport: '/Acceleration_Mode' */
          rtY.Acceleration_Mode = 1.0;
        }
        break;

       case IN_ACC_ON_MODE:
        ACC_ON_MODE(&DriveVehicle_speed);
        break;

       default:
        /* Outport: '/Acceleration_Mode' */
        /* case IN_ACC_STANDBY_MODE: */
        rtY.Acceleration_Mode = 1.0;
        if (!CruiseSwitch) {
          rtDW.is_c3_Final_Project = IN_ACC_OFF_MODE;

          /* Outport: '/Acceleration_Mode' */
          rtY.Acceleration_Mode = 0.0;
        } else {
          if (SetSwitch) {
            rtDW.is_c3_Final_Project = IN_ACC_ON_MODE;
            rtDW.is_ACC_ON_MODE = IN_LeadVehicle_Detected_Follow;

            /* Outport: '/Acceleration_Mode' */
            rtY.Acceleration_Mode = 2.0;
          }
        }
        break;
      }
    }

    /* End of Chart: '/Chart' */
  }

  if (rtmIsMajorTimeStep(rtM)) {
    rt_ertODEUpdateContinuousStates(&rtM->solverInfo);

    /* 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.
     */
    ++rtM->Timing.clockTick0;
    rtM->Timing.t[0] = rtsiGetSolverStopTime(&rtM->solverInfo);

    {
      /* 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.
       */
      rtM->Timing.clockTick1++;
    }
  }                                    /* end MajorTimeStep */
}

/* Derivatives for root system: '' */
void Final_Project_derivatives(void)
{
  XDot *_rtXdot;
  _rtXdot = ((XDot *) rtM->derivs);

  /* Derivatives for Integrator: '/Integrator' incorporates:
   *  Outport: '/Acceleration_Mode'
   */
  _rtXdot->Integrator_CSTATE = rtY.Acceleration_Mode;
}

/* Model initialize function */
void Final_Project_initialize(void)
{
  /* Registration code */
  {
    /* Setup solver object */
    rtsiSetSimTimeStepPtr(&rtM->solverInfo, &rtM->Timing.simTimeStep);
    rtsiSetTPtr(&rtM->solverInfo, &rtmGetTPtr(rtM));
    rtsiSetStepSizePtr(&rtM->solverInfo, &rtM->Timing.stepSize0);
    rtsiSetdXPtr(&rtM->solverInfo, &rtM->derivs);
    rtsiSetContStatesPtr(&rtM->solverInfo, (real_T **) &rtM->contStates);
    rtsiSetNumContStatesPtr(&rtM->solverInfo, &rtM->Sizes.numContStates);
    rtsiSetNumPeriodicContStatesPtr(&rtM->solverInfo,
      &rtM->Sizes.numPeriodicContStates);
    rtsiSetPeriodicContStateIndicesPtr(&rtM->solverInfo,
      &rtM->periodicContStateIndices);
    rtsiSetPeriodicContStateRangesPtr(&rtM->solverInfo,
      &rtM->periodicContStateRanges);
    rtsiSetErrorStatusPtr(&rtM->solverInfo, (&rtmGetErrorStatus(rtM)));
    rtsiSetRTModelPtr(&rtM->solverInfo, rtM);
  }

  rtsiSetSimTimeStep(&rtM->solverInfo, MAJOR_TIME_STEP);
  rtM->intgData.y = rtM->odeY;
  rtM->intgData.f[0] = rtM->odeF[0];
  rtM->intgData.f[1] = rtM->odeF[1];
  rtM->intgData.f[2] = rtM->odeF[2];
  rtM
->contStates = ((X *) &rtX);
  rtsiSetSolverData(&rtM->solverInfo, (void *)&rtM->intgData);
  rtsiSetSolverName(&rtM->solverInfo,"ode3");
  rtmSetTPtr(rtM, &rtM->Timing.tArray[0]);
  rtM->Timing.stepSize0 = 0.01;

  /* InitializeConditions for Integrator: '/Integrator' */
  rtX.Integrator_CSTATE = 0.0;
}

/* Model terminate function */
void Final_Project_terminate(void)
{
  /* (no terminate code required) */
}

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

RESULT AND CONCLUSION:

Thus we implementing the Adaptive Cruise Control simulation model will be created as per given requirements, also create a sldd file based on it. All input output signals are resolved and propageted. Then generate the model advisor report and the code is generated successfully.In this way I have done my project and get result satisfactory..

Hence. The Adaptive Cruise Control feature is developed as per the Requirement Document using MATLAB Simulink.