loader.c

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

    {
      IdleMode(READY, LOADER_S_EJECT_POSITION);
    }
    break;

  case LOADER_S_EJECT_POSITION:
    if (SW_S_100_TRANSITION == SW_VALUE(ldr_switch_state))
    {
      StartInsertTo(LOADER_S_INSERT_4, T3s5);
      ldrSendEvent(LOADER_INSERT_BY_PUSHBACK);
    }
    else if (SW_S_000_STOP == SW_VALUE(ldr_switch_state))
    {
      StartInsertTo(LOADER_S_INSERT_3, T3s5);
      ldrSendEvent(LOADER_INSERT_BY_PUSHBACK);
    }
    else if ((SW_S_111_8CM == SW_VALUE(ldr_switch_state))
          || ((SW_S_011_NOCD == SW_VALUE(ldr_switch_state))
           && (SW_S_110_EJECT == SW_VALUE(previous_ldr_switch_state))))
    {
      StartEjectTo(LOADER_S_EJECT_8CM_1, T1s);
      ldrSendEvent(LOADER_INSERT_BY_PUSHBACK_8CM);
    }
    else if (SW_S_011_NOCD == SW_VALUE(ldr_switch_state))
    {
      if ((0 != CONSERVATIVE_BEHAVIOR_SHINWA_CDC02)
       && (DISC_SIZE_12CM != disc_size))
      {
        StartEjectTo(LOADER_S_EJECT_8CM_SUSPICIOUS, T1s);
        ldrSendEvent(LOADER_INSERT_BY_PUSHBACK_8CM);
      }
      else
      {
        IdleMode(LOADER_ERROR_NO_DISC, LOADER_S_NO_CD_POSITION);
      }
    }
    break;

  case LOADER_S_EJECT_REPOSITIONING:
    if (!timer_in_progress(LOADER_TIMER))
    {
      ldrPrepareError(LOADER_ERROR_EJECT_REPOSITIONING);
    }
    else if ((SW_S_100_TRANSITION == SW_VALUE(ldr_switch_state))
          || (SW_S_000_STOP == SW_VALUE(ldr_switch_state)))
    {
      StartEjectTo(LOADER_S_EJECT_12CM_1, T1s);
    }
    else if (SW_S_111_8CM == SW_VALUE(ldr_switch_state))
    {
      StartEjectTo(LOADER_S_EJECT_8CM_1, T1s);
    }
    else if (SW_S_011_NOCD == SW_VALUE(ldr_switch_state))
    {
      if ((0 != CONSERVATIVE_BEHAVIOR_SHINWA_CDC02)
       && (DISC_SIZE_12CM != disc_size))
      {
        ldrSendEvent(LOADER_ERROR_8CM);
        StartEjectTo(LOADER_S_EJECT_8CM_SUSPICIOUS, T1s);
      }
      else
      {
        IdleMode(LOADER_ERROR_NO_DISC, LOADER_S_NO_CD_POSITION);
      }
    }
    break;

  case LOADER_S_EMERGENCY_EJECT:
    if (!timer_in_progress(LOADER_TIMER))
    {
      if (SW_S_011_NOCD == SW_VALUE(ldr_switch_state))
      {
        IdleMode(LOADER_ERROR_NO_DISC, LOADER_S_NO_CD_POSITION);
      }
      else
      {
        if ((SW_S_100_TRANSITION == SW_VALUE(ldr_switch_state))
         || (SW_S_000_STOP == SW_VALUE(ldr_switch_state)))
        {
          disc_size = DISC_SIZE_12CM;
        }
        else if (SW_S_111_8CM == SW_VALUE(ldr_switch_state))
        {
          disc_size = DISC_SIZE_8CM;
        }
        else
        {
          disc_size = DISC_SIZE_UNKNOWN;
        }
        ldrPrepareError(LOADER_ERROR_EJECT_BLOCKED);
      }
    }
    break;

  case LOADER_S_NOCD_INSERTING:
  case LOADER_S_NOCD_EJECTING:
    if (SW_S_010_INSERT == SW_VALUE(ldr_switch_state))
    {
      StartInsertTo(LOADER_S_INSERT_1, T5s);
      ldrSendEvent(LOADER_INSERT_BY_USER);
    }
    else if (!timer_in_progress(LOADER_TIMER))
    {
      IdleMode(LOADER_ERROR_NO_DISC, LOADER_S_NO_CD_POSITION);
    }
    break;

  //case LOADER_S_ERROR:
  default:
    if ((SW_S_011_NOCD == SW_VALUE(ldr_switch_state))
     && (SW_S_010_INSERT == SW_VALUE(previous_ldr_switch_state)))
    {
      if ((0 != CONSERVATIVE_BEHAVIOR_SHINWA_CDC02)
       && (DISC_SIZE_12CM != disc_size))
      {
        StartEjectTo(LOADER_S_EJECT_8CM_SUSPICIOUS, T1s);
        ldrSendEvent(LOADER_INSERT_BY_PUSHBACK_8CM);
      }
      else
      {
        IdleMode(LOADER_ERROR_NO_DISC, LOADER_S_NO_CD_POSITION);
      }
    }
    break;
  }
  previous_ldr_switch_state = ldr_switch_state;
}

/******************************************************************************/
/******************************************************************************/




/*****************************************************************************/
/*                                                                           */
/*                              M1_SHINWA_CLC01                              */
/*                                                                           */
/*****************************************************************************/


/******************************************************************************/
/* Function:  StartInsert_Shinwa_CLC01                                        */
/*                                                                            */
/*! \brief    Start disc insertion according to current position
 *            (implementation for mechanism: M1_SHINWA_CLC01)
 *  \param    void
 *  \return   void
 *  \remark
 */
/******************************************************************************/

void StartInsert_Shinwa_CLC01(void)
{
  switch (SW_VALUE(ldr_switch_state))
  {
  case SW_S_101_INSERT_EJECT:
    StartInsertTo(LOADER_S_INSERT_1, T5s);
    break;

  case SW_S_011_STOP:
    StartEjectTo(LOADER_S_INSERT_REPOSITIONING, T1s);
    break;

  case SW_S_111_TRANSITION:
    StartInsertTo(LOADER_S_INSERT_2, T3s5);
    break;

  case SW_S_110_8CM:
    StartEjectTo(LOADER_S_EJECT_8CM_1, T1s);
    ldrSendEvent(LOADER_ERROR_8CM);
    break;
       
  case SW_S_100_NOCD:
    break;

  //SW_S_000_ILLEGAL:
  //SW_S_001_ILLEGAL:
  //SW_S_010_ILLEGAL:
  default:
    ldrSendEvent(LOADER_ERROR_SW_ILLEGAL);
    StartEjectTo(LOADER_S_EMERGENCY_EJECT, T5s);
    break;
  }
}


/******************************************************************************/
/* Function:  StartEject_Shinwa_CLC01                                         */
/*                                                                            */
/*! \brief    Start disc ejection according to current position
 *            (implementation for mechanism: M1_SHINWA_CLC01)
 *  \param    void
 *  \return   void
 *  \remark
 */
/******************************************************************************/

void StartEject_Shinwa_CLC01(void)
{
  switch (SW_VALUE(ldr_switch_state))
  {
  case SW_S_011_STOP:
    StartEjectTo(LOADER_S_EJECT_12CM_1, T2s);
    break;

  case SW_S_111_TRANSITION:
    if (DISC_SIZE_8CM == disc_size)
    {
      StartEjectTo(LOADER_S_EJECT_8CM_1, T1s);
    }
    else
    {
      StartEjectTo(LOADER_S_EJECT_12CM_1, T1s);
    }
    break;

  case SW_S_110_8CM:
    StartEjectTo(LOADER_S_EJECT_8CM_1, T1s);
    break;

  case SW_S_101_INSERT_EJECT:
    StartInsertTo(LOADER_S_EJECT_REPOSITIONING, T1s);
    break;

  case SW_S_100_NOCD:
    break;
 
  //SW_S_000_ILLEGAL:
  //SW_S_001_ILLEGAL:
  //SW_S_010_ILLEGAL:
  default:
    ldrSendEvent(LOADER_ERROR_SW_ILLEGAL);
    StartEjectTo(LOADER_S_EMERGENCY_EJECT, T5s);
    break;
  }
}


/******************************************************************************/
/* Function:  ldrCommandEval_Shinwa_CLC01                                     */
/*                                                                            */
/*! \brief    Start actions for a new Loader Command
 *            (implementation for mechanism: M1_SHINWA_CLC01)
 *  \param    void
 *  \return   void
 *  \remarks
 */
/******************************************************************************/

void ldrCommandEval_Shinwa_CLC01(void)
{
  t_bool illegal_switch_detected = b_FALSE;

  if ((SW_VALUE(ldr_switch_state) != SW_VALUE(previous_ldr_switch_state))
   && (LOADER_S_STOP_POSITION != ldr_state)
   && (LOADER_S_EMERGENCY_EJECT != ldr_state))
  {
    if ((SW_INVALID_VAL != SW_VALUE(previous_ldr_switch_state))
     && ((SW_S_000_ILLEGAL == SW_VALUE(ldr_switch_state))
      || (SW_S_001_ILLEGAL == SW_VALUE(ldr_switch_state))
      || (SW_S_010_ILLEGAL == SW_VALUE(ldr_switch_state))
      || ((DISC_SIZE_12CM == disc_size)
       && (SW_S_110_8CM == SW_VALUE(ldr_switch_state)))
      || ((DISC_SIZE_8CM == disc_size)
       && (SW_S_011_STOP == SW_VALUE(ldr_switch_state)))
      || ((SW_S_100_NOCD == SW_VALUE(ldr_switch_state))
       && ((SW_S_111_TRANSITION == SW_VALUE(previous_ldr_switch_state))
        || (SW_S_011_STOP == SW_VALUE(previous_ldr_switch_state))
        || (SW_S_110_8CM == SW_VALUE(previous_ldr_switch_state))))
      || ((SW_S_101_INSERT_EJECT == SW_VALUE(ldr_switch_state))
       && ((SW_S_011_STOP == SW_VALUE(previous_ldr_switch_state))
        || (SW_S_110_8CM == SW_VALUE(previous_ldr_switch_state))))
      || ((SW_S_111_TRANSITION == SW_VALUE(ldr_switch_state))
       && (SW_S_100_NOCD == SW_VALUE(previous_ldr_switch_state)))
      || (((SW_S_011_STOP == SW_VALUE(ldr_switch_state))
        || (SW_S_110_8CM == SW_VALUE(ldr_switch_state)))
       && ((SW_S_100_NOCD == SW_VALUE(previous_ldr_switch_state))
        || (SW_S_101_INSERT_EJECT == SW_VALUE(previous_ldr_switch_state))))))
    {
      // on illegal SW state
      illegal_switch_detected = b_TRUE;
    }
    else if ((DISC_SIZE_UNKNOWN == disc_size)
          && (SW_S_011_STOP == SW_VALUE(ldr_switch_state)))
    {
      disc_size = DISC_SIZE_12CM;
    }
    else if ((DISC_SIZE_UNKNOWN == disc_size)
           && (SW_S_110_8CM == SW_VALUE(ldr_switch_state)))
    {
      disc_size = DISC_SIZE_8CM;
    }
  }

  if (illegal_switch_detected == b_TRUE)
  {
    ldrSendEvent(LOADER_ERROR_SW_ILLEGAL);
    StartEjectTo(LOADER_S_EMERGENCY_EJECT, T5s);
  }
  else if (LOADER_S_INIT == LOADER_GSTATE(ldr_state))   // on init
  {
    // do nothing
  }
  else if (ldr_command == LC_INIT)
  {
    // on init command
    ldr_command = LC_NONE;
    ldrSetMotor(LOADER_DIR_IDLE);
    loader_switch_init();
    start_timer(LOADER_TIMER, T1s);
    ldr_state = LOADER_S_INIT;
  }
  else if (ldr_command == LC_EM_EJECT)
  {
    // on emergency eject command
    ldr_command = LC_NONE;
    StartEjectTo(LOADER_S_EMERGENCY_EJECT, T5s);
  }
  else if ((LC_INSERT == ldr_command)   // on insert command
        && ((0 != ALLOW_REVERSE_DIRECTION)
         || (LOADER_DIR_EJECT != ldr_motor_dir)))
  {
    if (LOADER_S_EMERGENCY_EJECT != ldr_state)
    {
      /* if em eject execute command when em eject is finished */
      ldr_command = LC_NONE;

      if ((LOADER_S_NO_CD_POSITION == ldr_state)
       || (LOADER_S_NOCD_INSERTING == ldr_state)
       || (LOADER_S_NOCD_EJECTING == ldr_state))
      {
        if (0 != START_INSERT_ACTION_IN_NO_CD_POSITION)
        {
          if (LOADER_S_NOCD_INSERTING != ldr_state)
          {
            StartInsertTo(LOADER_S_NOCD_INSERTING, T2s);
          }  
        }
        else
        {
          IdleMode(LOADER_ERROR_NO_DISC, LOADER_S_NO_CD_POSITION);
        }
      }
      else if (LOADER_S_STOP_POSITION != LOADER_GSTATE(ldr_state))
      {
        StartInsert_Shinwa_CLC01();
      }
    }
  }
  else if ((LC_EJECT == ldr_command)   // on eject command
        && ((0 != ALLOW_REVERSE_DIRECTION)
         || ((LOADER_DIR_INSERT != ldr_motor_dir)
          && (LOADER_S_INSERT_REPOSITIONING != ldr_state))))
  {
    if (LOADER_S_EMERGENCY_EJECT != ldr_state)
    {
      /* if em eject execute command when em eject is finished */
      ldr_command = LC_NONE;

      if ((LOADER_S_NO_CD_POSITION == ldr_state)
       || (LOADER_S_NOCD_INSERTING == ldr_state)
       || (LOADER_S_NOCD_EJECTING == ldr_state))
      {
        if (0 != START_EJECT_ACTION_IN_NO_CD_POSITION)
        {
          if (LOADER_S_NOCD_EJECTING != ldr_state)
          {
            StartEjectTo(LOADER_S_NOCD_EJECTING, T2s);
          }  
        }
        else
        {
          IdleMode(LOADER_ERROR_NO_DISC, LOADER_S_NO_CD_POSITION);
        }
      }  
      else if (LOADER_S_EJECT_POSITION == LOADER_GSTATE(ldr_state))
      {
        if ((LOADER_S_EJECT_POSITION == ldr_state)
         && (0 != HAVE_EJECT_REPOSITIONING))
        {
          StartInsertTo(LOADER_S_EJECT_REPOSITIONING, T1s);
        }
      }
      else
      {
        StartEject_Shinwa_CLC01();
      }
    }
  }
}


/******************************************************************************/
/* Function:  ldrFSM_Shinwa_CLC01                                             */
/*                                                                            */
/*! \brief    Finite State Machine of Loader
 *            (implementation for mechanism: M1_SHINWA_CLC01)
 *  \param    void
 *  \return   void
 *  \remarks
 */
/******************************************************************************/

void ldrFSM_Shinwa_CLC01(void)
{
  switch (ldr_state)
  {
  case LOADER_S_IDLE:
    break;

  case LOADER_S_INIT:
    if (SW_S_100_NOCD == SW_VALUE(ldr_switch_state))
    {
      ldrSendEvent(LOADER_ERROR_NO_DISC);
      ldr_state = LOADER_S_NO_CD_POSITION;
    }
    else if (SW_S_011_STOP == SW_VALUE(ldr_switch_state))
    {
      ldrSendEvent(LOADER_INIT_STOP);
      ldr_state = LOADER_S_STOP_POSITION;
    }
    else if (SW_S_111_TRANSITION == SW_VALUE(ldr_switch_state))
    {
      ldrSendEvent(LOADER_INIT_TRANSITION);
      ldr_state = LOADER_S_ERROR;
    }
    else if (SW_S_101_INSERT_EJECT == SW_VALUE(ldr_switch_state))
    {
      ldrSendEvent(LOADER_INIT_EJECT);
      ldr_state = LOADER_S_EJECT_POSITION;
    }
    else if (SW_S_110_8CM == SW_VALUE(ldr_switch_state))
    {
      StartEjectTo(LOADER_S_EJECT_8CM_1, T1s);
      ldrSendEvent(LOADER_INIT_8CM);
    }
    break;

  case LOADER_S_NO_CD_POSITION:
    if (SW_S_101_INSERT_EJECT == SW_VALUE(ldr_switch_state))
    {
      StartInsertTo(LOADER_S_INSERT_1, T5s);
      ldrSendEvent(LOADER_INSERT_BY_USER);
    }
    break;

  case LOADER_S_INSERT_1:
  case LOADER_S_INSERT_5:
    if (!timer_in_progress(LOADER_TIMER))
    {