srvfsm.c

本程序为ST公司开发的源代码

  /* else not needed */
  return transition_reason;
}




////////////////////////////////////////////////////////////////////////////////
//                   Servo Controller State Functions
////////////////////////////////////////////////////////////////////////////////


/******************************************************************************/
/* Function:  init_servo_stf                                                  */
/*                                                                            */
/*! \brief    State function for SERVO_INIT
 *  \param    void
 *  \return   void
 *  \remark
 */
/******************************************************************************/

void init_servo_stf(void)
{
  if (OK == servo_fsm_transition_handling(init_servo()))
  {
    DEBUG_SERVO(("init_sservo state OK", 4, 0));
    servo_fsm_state = IDLE;
  }
}


/******************************************************************************/
/* Function:  init_servo_for_new_disc_stf                                     */
/*                                                                            */
/*! \brief    State handler for SERVO_INIT_FOR_NEW_DISc
 *  \param    void
 *  \return   void
 *  \remark
 */
/******************************************************************************/

void init_servo_for_new_disc_stf(void)
{
  if (OK == servo_fsm_transition_handling(init_servo_for_new_disc()))
  {
    DEBUG_SERVO(("init_servo_for_new_disc state OK", 4, 0));
    servo_fsm_state = IDLE;
  }
}


/******************************************************************************/
/* Function:  idle_stf                                                        */
/*                                                                            */
/*! \brief    State handler for SERVO_IDLE
 *  \param    void
 *  \return   uint8
 *  \remark   Stable state, FSM leaves state only with external command
 */
/******************************************************************************/

RETVAL idle_stf(void)
{
  if (error_reason == NO_ERROR_REASON)
  {
    return (READY);
  }
  else   /* (error_reason == XXXX_ERROR) */
  {
    return (error_reason);
  }
}


/******************************************************************************/
/* Function:  init_start_stf                                                  */
/*                                                                            */
/*! \brief    State function for SERVO_START
 *  \param    void
 *  \return   void
 *  \remark
 */
/******************************************************************************/

void init_start_stf(void)
{
  if (OK == servo_fsm_transition_handling(init_start()))
  {
    DEBUG_SERVO(("init_start state OK", 4, 0));
    servo_fsm_state = FE_ADJUST;
  }
}


/******************************************************************************/
/* Function:  fe_adjust_stf                                                   */
/*                                                                            */
/*! \brief    State function for FE_ADJUST
 *  \param    void
 *  \return   void
 *  \remark
 */
/******************************************************************************/

void fe_adjust_stf(void)
{
  if (OK == servo_fsm_transition_handling(fe_adjust()))
  {
    DEBUG_SERVO(("fe_adjust state OK", 4, 0));
#ifdef APM_PICKUP
    servo_fsm_state = START_TTM;
#else   /* (not) APM_PICKUP */
    servo_fsm_state = FOCUS_CLOSING;
#endif   /* APM_PICKUP */
  }
}


/******************************************************************************/
/* Function:  start_ttm_stf                                                   */
/*                                                                            */
/*! \brief    State function for START_TTM
 *  \param    void
 *  \return   void
 *  \remark
 */
/******************************************************************************/

void start_ttm_stf(void)
{
  if (OK == servo_fsm_transition_handling(start_ttm()))
  {
    DEBUG_SERVO(("start_ttm state OK", 4, 0));
#ifdef APM_PICKUP
    servo_fsm_state = FOCUS_CLOSING;
#else   /* (not) APM_PICKUP */
    servo_fsm_state = TE_ADJUST;
#endif   /* APM_PICKUP */
  }
}


/******************************************************************************/
/* Function:  focus_on_stf                                                    */
/*                                                                            */
/*! \brief    State function for FOCUS_ON
 *  \param    void
 *  \return   void
 *  \remark
 */
/******************************************************************************/

void focus_closing_stf(void)
{
  if (OK == servo_fsm_transition_handling(focus_closing()))
  {
    DEBUG_SERVO(("focus_on state OK", 4, 0));
#ifdef APM_PICKUP
    servo_fsm_state = TE_ADJUST;
#else   /* (not) APM_PICKUP */
    servo_fsm_state = START_TTM;
#endif   /* APM_PICKUP */
  }
}


/******************************************************************************/
/* Function:  te_adjust_stf                                                   */
/*                                                                            */
/*! \brief    State function for TE_ADJUST
 *  \param    void
 *  \return   void
 *  \remark
 */
/******************************************************************************/

void te_adjust_stf(void)
{
  if (OK == servo_fsm_transition_handling(te_adjust()))
  {
    DEBUG_SERVO(("te_adjust state OK", 4, 0));
    servo_fsm_state = TRACK_CLOSING;
  }
}


/******************************************************************************/
/* Function:  track_on_stf                                                    */
/*                                                                            */
/*! \brief    State function for TRACK_ON
 *  \param    void
 *  \return   void
 *  \remark
 */
/******************************************************************************/

void track_closing_stf(void)
{
  if (OK == servo_fsm_transition_handling(track_closing()))
  {
    DEBUG_SERVO(("track_on state OK", 4, 0));
    servo_fsm_state = AGC_FOCUS;
  }
}


/******************************************************************************/
/* Function:  agc_focus_stf                                                   */
/*                                                                            */
/*! \brief    State function for AGC_FOCUS
 *  \param    void
 *  \return   void
 *  \remark
 */
/******************************************************************************/

void agc_focus_stf(void)
{
  if (OK == servo_fsm_transition_handling(agc(AGC_FOCUS_LOOP)))
  {
    DEBUG_SERVO(("agc_focus state OK", 4, 0));
    servo_fsm_state = AGC_TRACKING;
  }
}


/******************************************************************************/
/* Function:  agc_tracking_stf                                                */
/*                                                                            */
/*! \brief    State function for AGC_TRACKING
 *  \param    void
 *  \return   void
 *  \remark
 */
/******************************************************************************/

void agc_tracking_stf(void)
{
  if (OK == servo_fsm_transition_handling(agc(AGC_TRACKING_LOOP)))
  {
    DEBUG_SERVO(("agc_tracking state OK", 4, 0));
    servo_fsm_state = JUMP_TTM_CHECK;
  }
}


/******************************************************************************/
/* Function:  jump_ttm_check_stf                                              */
/*                                                                            */
/*! \brief    State function for JUMP_TTM_CHECK
 *  \param    void
 *  \return   void
 *  \remark
 */
/******************************************************************************/

void jump_ttm_check_stf(void)
{
  if (OK == servo_fsm_transition_handling(jump_ttm_check()))
  {
    DEBUG_SERVO(("jump_ttm_check state OK", 4, 0));
    servo_fsm_state = ACCESS_CHECK;
  }
}


/******************************************************************************/
/* Function:  access_check_stf                                                */
/*                                                                            */
/*! \brief    State function for ACCESS_CHECK
 *  \param    void
 *  \return   void
 *  \remark
 */
/******************************************************************************/

void access_check_stf(void)
{
  if (OK == servo_fsm_transition_handling(access_check()))
  {
    //previous_T = 0;    // BB041110a
    DEBUG_SERVO(("access_check state OK", 4, 0));
    servo_fsm_state = ACTIVE_CHECK;
  }
}


/******************************************************************************/
/* Function:  active_check_stf                                                */
/*                                                                            */
/*! \brief    State function for ACTIVE_CHECK
 *  \param    void
 *  \return   uint8, BUSY or READY
 *  \remark
 */
/******************************************************************************/

RETVAL active_check_stf(void)
{
  RETVAL active_check_result;

  active_check_result = active_check();

#ifdef APM_PICKUP
  if (OK != active_check_result)
  {
    /* Make sure ECC measurements are rejected when not
    ** in continues playmode. */
    service_clr_flag(SVCF_ACCEPT_ECC_MEASUREMENT);
  }
#endif

  switch (active_check_result)
  {
  case IN_PROGRESS:
    return (BUSY);

  case OK:
    return (READY);

  case FOCUS_LOST:
  case HF_LOST:
  case TRACKING_LOST:
  case PLL_UNLOCKED:
    servo_fsm_transition_handling(active_check_result);
    return (SERVO_RECOVER);

  //case JUMP_REQUEST:
  //case SET_SPEED_REQUEST:
  default:
    servo_fsm_transition_handling(active_check_result);
    return (servo_fsm_result);
  }
}

/******************************************************************************/
/* Function:  servo_stop_stf                                                  */
/*                                                                            */
/*! \brief    State function for SERVO_STOP
 *  \param    void
 *  \return   void
 *  \remark
 */
/******************************************************************************/

void servo_stop_stf(void)
{
  if (OK == servo_fsm_transition_handling(stop_servo()))
  {
    DEBUG_SERVO(("stop_servo state OK", 4, 0));
    servo_fsm_state = IDLE;
  }
}


/******************************************************************************/
/* Function:  start_jump_stf                                                  */
/*                                                                            */
/*! \brief    State function for START_JUMP
 *  \param    void
 *  \return   void
 *  \remark
 */
/******************************************************************************/

void start_jump_stf(void)
{
  if (OK == servo_fsm_transition_handling(start_jump()))
  {
    DEBUG_SERVO(("start_jump state OK", 4, 0));
    servo_fsm_state = JUMP_CHECK;
  }
}


/******************************************************************************/
/* Function:  jump_check_stf                                                  */
/*                                                                            */
/*! \brief    State function for JUMP_CHECK
 *  \param    void
 *  \return   void
 *  \remark
 */
/******************************************************************************/

void jump_check_stf(void)
{
  if (OK == servo_fsm_transition_handling(jump_check()))
  {
    DEBUG_SERVO(("jump_check state OK", 4, 0));
    servo_fsm_state = JUMP_TTM_CHECK;
  }
}


/******************************************************************************/
/* Function:  error_stf                                                       */
/*                                                                            */
/*! \brief    State function for ERROR_STATE
 *  \param    void
 *  \return   void
 *  \remark
 */
/******************************************************************************/

void error_stf(void)
{
  DEBUG_SERVO(("error_state state OK", 4, 0));
  servo_misc_flags.field.sledge_home_request = 1;
  //BFTODO   event_set_servo(error_reason);

#ifndef APM_PICKUP
  if (!servo_startup_flags.field.first_startup_sequence_completed)
  {
    store_hostif_servo_parameters(HSP_STORING_MODE_STARTUP_ERROR);
  }
#ifndef EXECUTE_AGC_ONLY_ONCE
  else if (!servo_startup_flags.field.agc_tracking_done)
  {
    store_hostif_servo_parameters(HSP_STORING_MODE_RESTART_ERROR);
  }
#endif
#endif

  servo_fsm_state = SERVO_STOP;
}


/******************************************************************************/
/* Function:  fatal_error_stf                                                 */
/*                                                                            */
/*! \brief    State function for FATAL_ERROR_STATE
 *  \param    void
 *  \return   uint8 error_reason
 *  \remark
 */
/******************************************************************************/

 RETVAL fatal_error_stf(void)
{
#if 0
 /* TODO this is against ST philosophy of state handling if problem fix it */
  switch (sm_state[FATAL_ERROR_LEVEL])
  {
  case STATE_1:
    servo_misc_flags.field.sledge_home_request = 1;
    event_set_servo(SERVO_EVENT_SERVO_ERROR);
    sm_state[FATAL_ERROR_LEVEL] = STATE_2;
    /* fall through */

  case STATE_2:
  default:
    break;
  }
#endif
  DEBUG_SERVO(("fatal_error state OK", 4, 0));
  servo_misc_flags.field.sledge_home_request = 1;
  return (error_reason);
}