li3_5_sfun_c1.c

《Matlab仿真技术与应用》习题解的源代码

/*
 *
 * Stateflow code generation for chart:
 *    li3_5/shift_logic
 * 
 * Target Name                          : sfun
 * Model Version                        : 1.188
 * Stateflow Version                    : 4.1.0.12.10.1.000000
 * Date of code generation              : 14-Jan-2003 20:37:37
 *
 */

#include "li3_5_sfun.h"
#include "li3_5_sfun_c1.h"

#define mexPrintf                       sf_mex_printf
#ifdef printf
#undef printf
#endif
#define printf                          sf_mex_printf
#define CHARTINSTANCE_CHARTNUMBER       (chartInstance.chartNumber)
#define CHARTINSTANCE_INSTANCENUMBER    (chartInstance.instanceNumber)
#include "li3_5_sfun_debug_macros.h"
#define IN_NO_ACTIVE_CHILD              (0)
#define IN_c1_s2_first                  1
#define IN_c1_s3_fourth                 2
#define IN_c1_s4_second                 3
#define IN_c1_s5_third                  4
#define IN_c1_s7_downshifting           1
#define IN_c1_s8_steady_state           2
#define IN_c1_s9_upshifting             3
#define c1_d6_TWAIT                     chartInstance.ConstantData.c1_d6_TWAIT
#define event_c1_e8_DOWN                2
#define event_c1_e9_UP                  0
static SFli3_5_sfun_c1InstanceStruct chartInstance;
#define InputData_c1_d1_throttle        (*(real_T *)(ssGetInputPortSignalPtrs(chartInstance.S,0)[0]))
#define InputData_c1_d2_speed           (*(real_T *)(ssGetInputPortSignalPtrs(chartInstance.S,1)[0]))
#define InputData_c1_d3_up_th           (*(real_T *)(ssGetInputPortSignalPtrs(chartInstance.S,2)[0]))
#define InputData_c1_d4_down_th         (*(real_T *)(ssGetInputPortSignalPtrs(chartInstance.S,3)[0]))
#define OutputData_c1_d5_gear           (((real_T *)(ssGetOutputPortSignal(chartInstance.S,1)))[0])
void li3_5_sfun_c1(void);
static void c1_s1_gear_state(void);
static void enter_atomic_c1_s2_first(void);
static void enter_atomic_c1_s4_second(void);
static void exit_atomic_c1_s4_second(void);
static void enter_atomic_c1_s5_third(void);
static void exit_atomic_c1_s5_third(void);
static void exit_atomic_c1_s7_downshifting(void);
static void enter_atomic_c1_s8_steady_state(void);
static void exit_atomic_c1_s8_steady_state(void);
static void exit_atomic_c1_s9_upshifting(void);

void li3_5_sfun_c1(void)
{

  {
    _SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG,0);
    if(_sfEvent_ == CALL_EVENT) {
      if(chartInstance.Counters.i1<0xffU) {
        chartInstance.Counters.i1++;
      }
    }
    if(chartInstance.State.is_active_li3_5_sfun_c1 == 0) {
      _SFD_CC_CALL(CHART_ENTER_ENTRY_FUNCTION_TAG,0);
      chartInstance.State.is_active_li3_5_sfun_c1 = 1;
      _SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG,0);
      _SFD_CS_CALL(STATE_ENTER_ENTRY_FUNCTION_TAG,7);
      _SFD_CCS_CALL(STATE_ENTRY_COVERAGE_TAG,7,0);
      chartInstance.State.is_active_c1_s1_gear_state = 1;
      _SFD_CS_CALL(STATE_ACTIVE_TAG,7);
      _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG,7);
      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG,3);
      _SFD_CT_CALL(TRANSITION_WHEN_VALID_TAG,3);
      _SFD_CT_CALL(TRANSITION_INACTIVE_TAG,3);
      enter_atomic_c1_s2_first();
      _SFD_CS_CALL(STATE_ENTER_ENTRY_FUNCTION_TAG,3);
      _SFD_CCS_CALL(STATE_ENTRY_COVERAGE_TAG,3,0);
      chartInstance.State.is_active_c1_s6_selection_state = 1;
      _SFD_CS_CALL(STATE_ACTIVE_TAG,3);
      _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG,3);
      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG,0);
      _SFD_CT_CALL(TRANSITION_WHEN_VALID_TAG,0);
      _SFD_CT_CALL(TRANSITION_INACTIVE_TAG,0);
      enter_atomic_c1_s8_steady_state();
    } else {
      c1_s1_gear_state();
      {
        _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG,3);
        _SFD_CCS_CALL(STATE_DURING_COVERAGE_TAG,3,0);
        if(chartInstance.State.is_active_c1_s6_selection_state != 0) {
          _SFD_CS_CALL(STATE_BEFORE_DURING_ACTION_TAG,3);
          _SFD_CHART_CALL(EVENT_OBJECT,EVENT_BEFORE_BROADCAST_TAG,1);
          ssCallSystem(chartInstance.S,0);
          if(sf_mex_get_halt_simulation()) sf_mex_long_jump_on_error(2);
          _SFD_CHART_CALL(EVENT_OBJECT,EVENT_AFTER_BROADCAST_TAG,1);
          _SFD_CCS_CALL(STATE_DURING_COVERAGE_TAG,3,0);
          _SFD_CS_CALL(STATE_AFTER_DURING_ACTION_TAG,3);
          switch(chartInstance.State.is_c1_s6_selection_state) {
           case IN_c1_s7_downshifting:
            CV_STATE_EVAL(3,0,1);
            {
              _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG,6);
              _SFD_CCS_CALL(STATE_DURING_COVERAGE_TAG,6,0);
              _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG,4);
              if(CV_TRANSITION_EVAL(4,(_SFD_CCP_CALL(4,0,(_sfEvent_ ==
                   CALL_EVENT))) &&
                (_SFD_CCP_CALL(4,1,(chartInstance.Counters.i1 >=
                   (uint8_T )_SFD_TRANS_TEMPORAL_THRESHOLD(c1_d6_TWAIT,8,4))))
                && (_SFD_CCP_CALL(4,2,(InputData_c1_d2_speed <=
                   InputData_c1_d4_down_th))))) {
                _SFD_CT_CALL(TRANSITION_ACTIVE_TAG,4);
                _SFD_CT_CALL(TRANSITION_WHEN_VALID_TAG,4);
                _SFD_CT_CALL(TRANSITION_BEFORE_COND_ACTION_TAG,4);
                {
                  int8_T previousEvent;
                  previousEvent = _sfEvent_;
                  _sfEvent_ = event_c1_e8_DOWN;
                  _SFD_CE_CALL(EVENT_ENTER_BROADCAST_FUNCTION_TAG,event_c1_e8_DOWN);
                  _SFD_CE_CALL(EVENT_BEFORE_BROADCAST_TAG,event_c1_e8_DOWN);
                  sf_mex_listen_for_ctrl_c();
                  c1_s1_gear_state();
                  _SFD_CE_CALL(EVENT_AFTER_BROADCAST_TAG,event_c1_e8_DOWN);
                  _sfEvent_ = previousEvent;
                }
                _SFD_CCT_CALL(TRANSITION_CONDITION_ACTION_COVERAGE_TAG,4,0);
                _SFD_CT_CALL(TRANSITION_AFTER_COND_ACTION_TAG,4);
                _SFD_CT_CALL(TRANSITION_INACTIVE_TAG,4);
                exit_atomic_c1_s7_downshifting();
                if(chartInstance.State.is_c1_s6_selection_state ==
                 IN_NO_ACTIVE_CHILD) {
                  enter_atomic_c1_s8_steady_state();
                }
              } else {
                _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG,8);
                if(CV_TRANSITION_EVAL(8,_SFD_CCP_CALL(8,0,(InputData_c1_d2_speed
                    > InputData_c1_d4_down_th)))) {
                  _SFD_CT_CALL(TRANSITION_ACTIVE_TAG,8);
                  _SFD_CT_CALL(TRANSITION_WHEN_VALID_TAG,8);
                  _SFD_CT_CALL(TRANSITION_INACTIVE_TAG,8);
                  exit_atomic_c1_s7_downshifting();
                  if(chartInstance.State.is_c1_s6_selection_state ==
                   IN_NO_ACTIVE_CHILD) {
                    enter_atomic_c1_s8_steady_state();
                  }
                }
              }
              _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG,6);
            }
            break;
           case IN_c1_s8_steady_state:
            CV_STATE_EVAL(3,0,2);
            _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG,5);
            _SFD_CCS_CALL(STATE_DURING_COVERAGE_TAG,5,0);
            _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG,1);
            if(CV_TRANSITION_EVAL(1,_SFD_CCP_CALL(1,0,(InputData_c1_d2_speed >
                InputData_c1_d3_up_th)))) {
              if(sf_debug_transition_conflict_check_enabled()) {
                unsigned int transitionList[2];
                unsigned int numTransitions=1;
                transitionList[0] = 1;
                sf_debug_transition_conflict_check_begin();
                if(InputData_c1_d2_speed < InputData_c1_d4_down_th) {
                  transitionList[numTransitions] = 13;
                  numTransitions++;
                }
                sf_debug_transition_conflict_check_end();
                if(numTransitions>1) {
                  _SFD_TRANSITION_CONFLICT(&(transitionList[0]),numTransitions);
                }
              }
              _SFD_CT_CALL(TRANSITION_ACTIVE_TAG,1);
              _SFD_CT_CALL(TRANSITION_WHEN_VALID_TAG,1);
              _SFD_CT_CALL(TRANSITION_INACTIVE_TAG,1);
              exit_atomic_c1_s8_steady_state();
              if(chartInstance.State.is_c1_s6_selection_state ==
               IN_NO_ACTIVE_CHILD) {
                _SFD_CS_CALL(STATE_ENTER_ENTRY_FUNCTION_TAG,8);
                _SFD_CCS_CALL(STATE_ENTRY_COVERAGE_TAG,8,0);
                chartInstance.State.is_c1_s6_selection_state =
                  IN_c1_s9_upshifting;
                _SFD_CS_CALL(STATE_ACTIVE_TAG,8);
                chartInstance.Counters.i1=0;
                _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG,8);
              }
            } else {
              _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG,13);
              if(CV_TRANSITION_EVAL(13,_SFD_CCP_CALL(13,0,(InputData_c1_d2_speed
                  < InputData_c1_d4_down_th)))) {
                _SFD_CT_CALL(TRANSITION_ACTIVE_TAG,13);
                _SFD_CT_CALL(TRANSITION_WHEN_VALID_TAG,13);
                _SFD_CT_CALL(TRANSITION_INACTIVE_TAG,13);
                exit_atomic_c1_s8_steady_state();
                if(chartInstance.State.is_c1_s6_selection_state ==
                 IN_NO_ACTIVE_CHILD) {
                  _SFD_CS_CALL(STATE_ENTER_ENTRY_FUNCTION_TAG,6);
                  _SFD_CCS_CALL(STATE_ENTRY_COVERAGE_TAG,6,0);
                  chartInstance.State.is_c1_s6_selection_state =
                    IN_c1_s7_downshifting;
                  _SFD_CS_CALL(STATE_ACTIVE_TAG,6);
                  chartInstance.Counters.i1=0;
                  _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG,6);
                }
              }
            }
            _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG,5);
            break;
           case IN_c1_s9_upshifting:
            CV_STATE_EVAL(3,0,3);
            {
              _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG,8);
              _SFD_CCS_CALL(STATE_DURING_COVERAGE_TAG,8,0);
              _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG,12);
              if(CV_TRANSITION_EVAL(12,(_SFD_CCP_CALL(12,0,(_sfEvent_ ==
                   CALL_EVENT))) &&
                (_SFD_CCP_CALL(12,1,(chartInstance.Counters.i1 >=
                   (uint8_T )_SFD_TRANS_TEMPORAL_THRESHOLD(c1_d6_TWAIT,8,12))))
                && (_SFD_CCP_CALL(12,2,(InputData_c1_d2_speed >=
                   InputData_c1_d3_up_th))))) {
                _SFD_CT_CALL(TRANSITION_ACTIVE_TAG,12);
                _SFD_CT_CALL(TRANSITION_WHEN_VALID_TAG,12);
                _SFD_CT_CALL(TRANSITION_BEFORE_COND_ACTION_TAG,12);
                {
                  int8_T previousEvent;
                  previousEvent = _sfEvent_;
                  _sfEvent_ = event_c1_e9_UP;
                  _SFD_CE_CALL(EVENT_ENTER_BROADCAST_FUNCTION_TAG,event_c1_e9_UP);
                  _SFD_CE_CALL(EVENT_BEFORE_BROADCAST_TAG,event_c1_e9_UP);
                  sf_mex_listen_for_ctrl_c();
                  c1_s1_gear_state();
                  _SFD_CE_CALL(EVENT_AFTER_BROADCAST_TAG,event_c1_e9_UP);
                  _sfEvent_ = previousEvent;
                }
                _SFD_CCT_CALL(TRANSITION_CONDITION_ACTION_COVERAGE_TAG,12,0);
                _SFD_CT_CALL(TRANSITION_AFTER_COND_ACTION_TAG,12);
                _SFD_CT_CALL(TRANSITION_INACTIVE_TAG,12);
                exit_atomic_c1_s9_upshifting();
                if(chartInstance.State.is_c1_s6_selection_state ==
                 IN_NO_ACTIVE_CHILD) {
                  enter_atomic_c1_s8_steady_state();
                }
              } else {
                _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG,6);
                if(CV_TRANSITION_EVAL(6,_SFD_CCP_CALL(6,0,(InputData_c1_d2_speed
                    < InputData_c1_d3_up_th)))) {
                  _SFD_CT_CALL(TRANSITION_ACTIVE_TAG,6);
                  _SFD_CT_CALL(TRANSITION_WHEN_VALID_TAG,6);
                  _SFD_CT_CALL(TRANSITION_INACTIVE_TAG,6);
                  exit_atomic_c1_s9_upshifting();
                  if(chartInstance.State.is_c1_s6_selection_state ==
                   IN_NO_ACTIVE_CHILD) {
                    enter_atomic_c1_s8_steady_state();
                  }
                }
              }
              _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG,8);
            }
            break;
            default:;
            CV_STATE_EVAL(3,0,0);
          }
        }
        _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG,3);
      }
    }
    _SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG,0);
  }
}

static void c1_s1_gear_state(void)
{

  {
    _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG,7);
    _SFD_CCS_CALL(STATE_DURING_COVERAGE_TAG,7,0);
    if(chartInstance.State.is_active_c1_s1_gear_state != 0) {
      switch(chartInstance.State.is_c1_s1_gear_state) {
       case IN_c1_s2_first:
        CV_STATE_EVAL(7,0,1);
        _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG,0);
        _SFD_CCS_CALL(STATE_DURING_COVERAGE_TAG,0,0);
        _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG,2);
        if(CV_TRANSITION_EVAL(2,_SFD_CCP_CALL(2,0,(_sfEvent_ ==
            event_c1_e9_UP)))) {
          _SFD_CT_CALL(TRANSITION_ACTIVE_TAG,2);
          _SFD_CT_CALL(TRANSITION_WHEN_VALID_TAG,2);
          _SFD_CT_CALL(TRANSITION_INACTIVE_TAG,2);
          _SFD_CS_CALL(STATE_ENTER_EXIT_FUNCTION_TAG,0);
          _SFD_CCS_CALL(STATE_EXIT_COVERAGE_TAG,0,0);
          chartInstance.State.is_c1_s1_gear_state = IN_NO_ACTIVE_CHILD;
          _SFD_CS_CALL(STATE_INACTIVE_TAG,0);
          _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG,0);
          enter_atomic_c1_s4_second();
        }
        _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG,0);
        break;
       case IN_c1_s3_fourth:
        CV_STATE_EVAL(7,0,2);
        _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG,1);
        _SFD_CCS_CALL(STATE_DURING_COVERAGE_TAG,1,0);
        _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG,9);
        if(CV_TRANSITION_EVAL(9,_SFD_CCP_CALL(9,0,(_sfEvent_ ==
            event_c1_e8_DOWN)))) {
          _SFD_CT_CALL(TRANSITION_ACTIVE_TAG,9);
          _SFD_CT_CALL(TRANSITION_WHEN_VALID_TAG,9);
          _SFD_CT_CALL(TRANSITION_INACTIVE_TAG,9);
          _SFD_CS_CALL(STATE_ENTER_EXIT_FUNCTION_TAG,1);
          _SFD_CCS_CALL(STATE_EXIT_COVERAGE_TAG,1,0);
          chartInstance.State.is_c1_s1_gear_state = IN_NO_ACTIVE_CHILD;
          _SFD_CS_CALL(STATE_INACTIVE_TAG,1);
          _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG,1);
          enter_atomic_c1_s5_third();
        }
        _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG,1);
        break;
       case IN_c1_s4_second:
        CV_STATE_EVAL(7,0,3);
        _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG,2);
        _SFD_CCS_CALL(STATE_DURING_COVERAGE_TAG,2,0);
        _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG,10);
        if(CV_TRANSITION_EVAL(10,_SFD_CCP_CALL(10,0,(_sfEvent_ ==
            event_c1_e9_UP)))) {
          if(sf_debug_transition_conflict_check_enabled()) {
            unsigned int transitionList[2];
            unsigned int numTransitions=1;
            transitionList[0] = 10;
            sf_debug_transition_conflict_check_begin();
            if(_sfEvent_ == event_c1_e8_DOWN) {
              transitionList[numTransitions] = 11;
              numTransitions++;
            }
            sf_debug_transition_conflict_check_end();
            if(numTransitions>1) {
              _SFD_TRANSITION_CONFLICT(&(transitionList[0]),numTransitions);
            }
          }
          _SFD_CT_CALL(TRANSITION_ACTIVE_TAG,10);
          _SFD_CT_CALL(TRANSITION_WHEN_VALID_TAG,10);
          _SFD_CT_CALL(TRANSITION_INACTIVE_TAG,10);
          exit_atomic_c1_s4_second();
          if(chartInstance.State.is_c1_s1_gear_state == IN_NO_ACTIVE_CHILD) {
            enter_atomic_c1_s5_third();
          }
        } else {
          _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG,11);
          if(CV_TRANSITION_EVAL(11,_SFD_CCP_CALL(11,0,(_sfEvent_ ==
              event_c1_e8_DOWN)))) {
            _SFD_CT_CALL(TRANSITION_ACTIVE_TAG,11);
            _SFD_CT_CALL(TRANSITION_WHEN_VALID_TAG,11);
            _SFD_CT_CALL(TRANSITION_INACTIVE_TAG,11);
            exit_atomic_c1_s4_second();
            if(chartInstance.State.is_c1_s1_gear_state == IN_NO_ACTIVE_CHILD) {
              enter_atomic_c1_s2_first();
            }
          }
        }
        _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG,2);
        break;
       case IN_c1_s5_third:
        CV_STATE_EVAL(7,0,4);
        _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG,4);
        _SFD_CCS_CALL(STATE_DURING_COVERAGE_TAG,4,0);
        _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG,5);
        if(CV_TRANSITION_EVAL(5,_SFD_CCP_CALL(5,0,(_sfEvent_ ==
            event_c1_e9_UP)))) {
          if(sf_debug_transition_conflict_check_enabled()) {
            unsigned int transitionList[2];
            unsigned int numTransitions=1;
            transitionList[0] = 5;
            sf_debug_transition_conflict_check_begin();
            if(_sfEvent_ == event_c1_e8_DOWN) {
              transitionList[numTransitions] = 7;
              numTransitions++;
            }
            sf_debug_transition_conflict_check_end();