/*
 *
 * Stateflow code generation for chart:
 *    tpc9/Base Station/Base Station Controller
 * 
 * Target Name                          : sfun
 * Model Version                        : 1.188
 * Stateflow Version                    : 5.0.0.13.00.1.000001
 * Date of code generation              : 16-May-2006 19:18:56
 *
 */

#include "tpc9_sfun.h"
#include "tpc9_sfun_c2.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 "tpc9_sfun_debug_macros.h"
#define IN_NO_ACTIVE_CHILD              (0)
#define IN_m0_c2_s1_Idle                1
#define IN_m0_c2_s2_Traffic_Channel     2
#define event_m0_c2_e4_Start_Chart      1
#define event_m0_c2_e5_Access_Detect    5
#define event_m0_c2_e6_BS_Timed_Out     0
#define event_m0_c2_e7_PCG_Clock        4
static SFtpc9_sfun_c2InstanceStruct chartInstance;
#define InputData_m0_c2_d1_EbNo         (((real_T *)(ssGetInputPortSignal(chartInstance.S,0)))[0])
#define InputData_m0_c2_d2_Target_EbNo  (((real_T *)(ssGetInputPortSignal(chartInstance.S,1)))[0])
#define m0_c2_e4_Start_Chart            (*(real_T *)(ssGetInputPortSignalPtrs(chartInstance.S,2)[0]))
#define m0_c2_e5_Access_Detect          (*(real_T *)(ssGetInputPortSignalPtrs(chartInstance.S,2)[1]))
#define m0_c2_e6_BS_Timed_Out           (*(real_T *)(ssGetInputPortSignalPtrs(chartInstance.S,2)[2]))
#define m0_c2_e7_PCG_Clock              (*(real_T *)(ssGetInputPortSignalPtrs(chartInstance.S,2)[3]))
#define OutputData_m0_c2_d3_Power_Bit   (((real_T *)(ssGetOutputPortSignal(chartInstance.S,1)))[0])
#define m0_c2_e8_Start_BS_Timer         (((real_T *)(ssGetOutputPortSignal(chartInstance.S,2)))[0])
#define m0_c2_e9_Page                   (((real_T *)(ssGetOutputPortSignal(chartInstance.S,3)))[0])

static void exit_atomic_m0_c2_s1_Idle(void);
static void enter_atomic_m0_c2_s2_Traffic_Channel(void);
static void exit_atomic_m0_c2_s2_Traffic_Channel(void);
static void broadcast_m0_c2_e4_Start_Chart(void);
static void broadcast_m0_c2_e5_Access_Detect(void);
static void broadcast_m0_c2_e6_BS_Timed_Out(void);
static void broadcast_m0_c2_e7_PCG_Clock(void);
void tpc9_sfun_c2(void)
{
  _SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG,1);
  if(chartInstance.State.is_active_tpc9_sfun_c2 == 0) {
    _SFD_CC_CALL(CHART_ENTER_ENTRY_FUNCTION_TAG,1);
    chartInstance.State.is_active_tpc9_sfun_c2 = 1;
    _SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG,1);
    _SFD_CT_CALL(TRANSITION_ACTIVE_TAG,4);
    _SFD_CT_CALL(TRANSITION_WHEN_VALID_TAG,4);
    _SFD_CT_CALL(TRANSITION_INACTIVE_TAG,4);
    _SFD_CS_CALL(STATE_ENTER_ENTRY_FUNCTION_TAG,0);
    _SFD_CCS_CALL(STATE_ENTRY_COVERAGE_TAG,0,0);
    chartInstance.State.is_tpc9_sfun_c2 = IN_m0_c2_s1_Idle;
    _SFD_CS_CALL(STATE_ACTIVE_TAG,0);
    _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG,0);
  } else {
    switch(chartInstance.State.is_tpc9_sfun_c2) {
     case IN_m0_c2_s1_Idle:
      CV_CHART_EVAL(1,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_m0_c2_e5_Access_Detect)))) {
        _SFD_CT_CALL(TRANSITION_ACTIVE_TAG,2);
        _SFD_CT_CALL(TRANSITION_WHEN_VALID_TAG,2);
        _SFD_CT_CALL(TRANSITION_INACTIVE_TAG,2);
        exit_atomic_m0_c2_s1_Idle();
        _SFD_CT_CALL(TRANSITION_BEFORE_TRANS_ACTION_TAG,2);
        _SFD_CHART_CALL(EVENT_OBJECT,EVENT_BEFORE_BROADCAST_TAG,2);
        chartInstance.m0_c2_e9_PageEventCounter++;
        _SFD_CHART_CALL(EVENT_OBJECT,EVENT_AFTER_BROADCAST_TAG,2);
        _SFD_CCT_CALL(TRANSITION_TRANSITION_ACTION_COVERAGE_TAG,2,0);
        _SFD_CT_CALL(TRANSITION_AFTER_TRANS_ACTION_TAG,2);
        _SFD_CT_CALL(TRANSITION_INACTIVE_TAG,2);
        enter_atomic_m0_c2_s2_Traffic_Channel();
      }
      _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG,0);
      break;
     case IN_m0_c2_s2_Traffic_Channel:
      CV_CHART_EVAL(1,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,1);
      if(CV_TRANSITION_EVAL(1, _SFD_CCP_CALL(1,0,(_sfEvent_ ==
          event_m0_c2_e7_PCG_Clock)))) {
        _SFD_CT_CALL(TRANSITION_ACTIVE_TAG,1);
        _SFD_CT_CALL(TRANSITION_WHEN_VALID_TAG,1);
        _SFD_CT_CALL(TRANSITION_INACTIVE_TAG,1);
        _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG,0);
        if(CV_TRANSITION_EVAL(0, _SFD_CCP_CALL(0,0,(InputData_m0_c2_d1_EbNo <=
            InputData_m0_c2_d2_Target_EbNo)))) {
          if(sf_debug_transition_conflict_check_enabled()) {
            unsigned int transitionList[2];
            unsigned int numTransitions=1;
            transitionList[0] = 0;
            sf_debug_transition_conflict_check_begin();
            if(InputData_m0_c2_d1_EbNo > InputData_m0_c2_d2_Target_EbNo) {
              transitionList[numTransitions] = 3;
              numTransitions++;
            }
            sf_debug_transition_conflict_check_end();
            if(numTransitions>1) {
              _SFD_TRANSITION_CONFLICT(&(transitionList[0]),numTransitions);
            }
          }
          _SFD_CT_CALL(TRANSITION_ACTIVE_TAG,0);
          _SFD_CT_CALL(TRANSITION_WHEN_VALID_TAG,0);
          _SFD_CT_CALL(TRANSITION_INACTIVE_TAG,0);
          exit_atomic_m0_c2_s2_Traffic_Channel();
          _SFD_CT_CALL(TRANSITION_BEFORE_TRANS_ACTION_TAG,0);
          OutputData_m0_c2_d3_Power_Bit = 0.0;
          _SFD_CCT_CALL(TRANSITION_TRANSITION_ACTION_COVERAGE_TAG,0,0);
          _SFD_CT_CALL(TRANSITION_AFTER_TRANS_ACTION_TAG,0);
          _SFD_CT_CALL(TRANSITION_INACTIVE_TAG,0);
          enter_atomic_m0_c2_s2_Traffic_Channel();
        } else {
          _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG,3);
          if(CV_TRANSITION_EVAL(3, _SFD_CCP_CALL(3,0,(InputData_m0_c2_d1_EbNo >
              InputData_m0_c2_d2_Target_EbNo)))) {
            _SFD_CT_CALL(TRANSITION_ACTIVE_TAG,3);
            _SFD_CT_CALL(TRANSITION_WHEN_VALID_TAG,3);
            _SFD_CT_CALL(TRANSITION_INACTIVE_TAG,3);
            exit_atomic_m0_c2_s2_Traffic_Channel();
            _SFD_CT_CALL(TRANSITION_BEFORE_TRANS_ACTION_TAG,3);
            OutputData_m0_c2_d3_Power_Bit = 1.0;
            _SFD_CCT_CALL(TRANSITION_TRANSITION_ACTION_COVERAGE_TAG,3,0);
            _SFD_CT_CALL(TRANSITION_AFTER_TRANS_ACTION_TAG,3);
            _SFD_CT_CALL(TRANSITION_INACTIVE_TAG,3);
            enter_atomic_m0_c2_s2_Traffic_Channel();
          }
        }
      }
      _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG,1);
      break;
     default:
      CV_CHART_EVAL(1,0,0);
      break;
    }
  }
  _SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG,1);
}

static void exit_atomic_m0_c2_s1_Idle(void)
{
  _SFD_CS_CALL(STATE_ENTER_EXIT_FUNCTION_TAG,0);
  _SFD_CCS_CALL(STATE_EXIT_COVERAGE_TAG,0,0);
  chartInstance.State.is_tpc9_sfun_c2 = IN_NO_ACTIVE_CHILD;
  _SFD_CS_CALL(STATE_INACTIVE_TAG,0);
  _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG,0);
}

static void enter_atomic_m0_c2_s2_Traffic_Channel(void)
{
  _SFD_CS_CALL(STATE_ENTER_ENTRY_FUNCTION_TAG,1);
  _SFD_CCS_CALL(STATE_ENTRY_COVERAGE_TAG,1,0);
  chartInstance.State.is_tpc9_sfun_c2 = IN_m0_c2_s2_Traffic_Channel;
  _SFD_CS_CALL(STATE_ACTIVE_TAG,1);
  _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG,1);
}

static void exit_atomic_m0_c2_s2_Traffic_Channel(void)
{
  _SFD_CS_CALL(STATE_ENTER_EXIT_FUNCTION_TAG,1);
  _SFD_CCS_CALL(STATE_EXIT_COVERAGE_TAG,1,0);
  chartInstance.State.is_tpc9_sfun_c2 = IN_NO_ACTIVE_CHILD;
  _SFD_CS_CALL(STATE_INACTIVE_TAG,1);
  _SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG,1);
}

static void broadcast_m0_c2_e4_Start_Chart(void)
{
  uint8_T previousEvent;
  previousEvent = _sfEvent_;
  _sfEvent_ = event_m0_c2_e4_Start_Chart;
  _SFD_CE_CALL(EVENT_ENTER_BROADCAST_FUNCTION_TAG,event_m0_c2_e4_Start_Chart);
  _SFD_CE_CALL(EVENT_BEFORE_BROADCAST_TAG,event_m0_c2_e4_Start_Chart);
  sf_mex_listen_for_ctrl_c(chartInstance.S);
  tpc9_sfun_c2();
  _SFD_CE_CALL(EVENT_AFTER_BROADCAST_TAG,event_m0_c2_e4_Start_Chart);
  _sfEvent_ = previousEvent;
}

static void broadcast_m0_c2_e5_Access_Detect(void)
{
  uint8_T previousEvent;
  previousEvent = _sfEvent_;
  _sfEvent_ = event_m0_c2_e5_Access_Detect;
  _SFD_CE_CALL(EVENT_ENTER_BROADCAST_FUNCTION_TAG,event_m0_c2_e5_Access_Detect);
  _SFD_CE_CALL(EVENT_BEFORE_BROADCAST_TAG,event_m0_c2_e5_Access_Detect);
  sf_mex_listen_for_ctrl_c(chartInstance.S);
  tpc9_sfun_c2();
  _SFD_CE_CALL(EVENT_AFTER_BROADCAST_TAG,event_m0_c2_e5_Access_Detect);
  _sfEvent_ = previousEvent;
}

static void broadcast_m0_c2_e6_BS_Timed_Out(void)
{
  uint8_T previousEvent;
  previousEvent = _sfEvent_;
  _sfEvent_ = event_m0_c2_e6_BS_Timed_Out;
  _SFD_CE_CALL(EVENT_ENTER_BROADCAST_FUNCTION_TAG,event_m0_c2_e6_BS_Timed_Out);
  _SFD_CE_CALL(EVENT_BEFORE_BROADCAST_TAG,event_m0_c2_e6_BS_Timed_Out);
  sf_mex_listen_for_ctrl_c(chartInstance.S);
  tpc9_sfun_c2();
  _SFD_CE_CALL(EVENT_AFTER_BROADCAST_TAG,event_m0_c2_e6_BS_Timed_Out);
  _sfEvent_ = previousEvent;
}

static void broadcast_m0_c2_e7_PCG_Clock(void)
{
  uint8_T previousEvent;
  previousEvent = _sfEvent_;
  _sfEvent_ = event_m0_c2_e7_PCG_Clock;
  _SFD_CE_CALL(EVENT_ENTER_BROADCAST_FUNCTION_TAG,event_m0_c2_e7_PCG_Clock);
  _SFD_CE_CALL(EVENT_BEFORE_BROADCAST_TAG,event_m0_c2_e7_PCG_Clock);
  sf_mex_listen_for_ctrl_c(chartInstance.S);
  tpc9_sfun_c2();
  _SFD_CE_CALL(EVENT_AFTER_BROADCAST_TAG,event_m0_c2_e7_PCG_Clock);
  _sfEvent_ = previousEvent;
}

void sf_tpc9_sfun_c2_get_check_sum(mxArray *plhs[])
{
  ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(409336012U);
  ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(3452808985U);
  ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(2185658609U);
  ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(4253493883U);
}
/*
 * Chart initialization function
 */
/* work around the buggy macro in simstruc.h until it is fixed */
#define cdrGetOutputPortReusable(S,port) \
  ( (S)->portInfo.outputs[(port)].attributes.optimOpts != \
   SS_NOT_REUSABLE_AND_GLOBAL )

static void initialize_tpc9_sfun_c2( SimStruct *S)
{

  {
    if(!cdrGetOutputPortReusable(S,1)) {
      OutputData_m0_c2_d3_Power_Bit = 0.0;
    }
  }

  /* Initialize chart's state configuration */
  memset((void*)&(chartInstance.State),0,sizeof(chartInstance.State));

  /* Initialize all chart output event variables to zero */
  chartInstance.m0_c2_e8_Start_BS_TimerEventData = 0;
  chartInstance.m0_c2_e8_Start_BS_TimerEventCounter = 0;

  chartInstance.m0_c2_e9_PageEventData = 0;
  chartInstance.m0_c2_e9_PageEventCounter = 0;

  {
    if(ssIsFirstInitCond(S)) {
      /* do this only if simulation is starting */
      if(!sim_mode_is_rtw_gen(S)) {
        {
          unsigned int chartAlreadyPresent;
          chartAlreadyPresent = sf_debug_initialize_chart(_tpc9MachineNumber_,
            2,
            2,
            5,
            3,
            6,
            0,
            0,
            0,
            &(chartInstance.chartNumber),
            &(chartInstance.instanceNumber),
            ssGetPath((SimStruct *)S),
            (void *)S);
          if(chartAlreadyPresent==0) {
            /* this is the first instance */
            sf_debug_set_chart_disable_implicit_casting(_tpc9MachineNumber_,chartInstance.chartNumber,0);
            sf_debug_set_chart_event_thresholds(_tpc9MachineNumber_,
             chartInstance.chartNumber,
             6,
             6,
             6);

            _SFD_SET_DATA_PROPS(1,
             1,
             1,
             0,
             SF_DOUBLE,
             0,
             NULL,
             0,