motor.c

我个人编写的车载dvd上的程序

#include "public.h"
//#include "motor.h"

void MotorMain(void)
{
    ProcTFTMotor();
    ProTrayMotor();
    MotorCommand();
}

void ProcTFTMotor(void)
{
    switch(ucTFTMotorDriverStatus)
    {

        case TFTMOTOR_STATUS_REQ_INIT90_TO_STEP60:
            ucTFTMotorDriverStatus = TFTMOTOR_STATUS_STEP60;
            ucTFTMotorDriverTime = TFTMOTOR_RUNLENGTH_INIT90_AND_STEP60_TIMEOUT;
            TFT_Motor_Driver(MOTOR_OPEN);
        break;

        case TFTMOTOR_STATUS_REQ_INIT90_TO_STEP30:
            ucTFTMotorDriverStatus = TFTMOTOR_STATUS_STEP30;
            ucTFTMotorDriverTime = TFTMOTOR_RUNLENGTH_INIT90_AND_STEP30_TIMEOUT;
            TFT_Motor_Driver(MOTOR_OPEN);
        break; 	 

        case TFTMOTOR_STATUS_REQ_INIT90_TO_STEP0:
            ucTFTMotorDriverStatus = TFTMOTOR_STATUS_STEP0;
            ucTFTMotorDriverTime = TFTMOTOR_RUNLENGTH_INIT90_AND_STEP0_TIMEOUT;
            TFT_Motor_Driver(MOTOR_OPEN);
        break; 	  	 

        case TFTMOTOR_STATUS_REQ_STEP60_TO_INIT90:
            ucTFTMotorDriverStatus = TFTMOTOR_STATUS_INIT90;
            ucTFTMotorDriverTime = TFTMOTOR_RUNLENGTH_STEP60_AND_INIT90_TIMEOUT;
            TFT_Motor_Driver(MOTOR_CLOSE);
        break; 	  	 

        case TFTMOTOR_STATUS_REQ_STEP30_TO_INIT90:
            ucTFTMotorDriverStatus = TFTMOTOR_STATUS_INIT90;
            ucTFTMotorDriverTime = TFTMOTOR_RUNLENGTH_INIT90_AND_STEP30_TIMEOUT;
            TFT_Motor_Driver(MOTOR_CLOSE);
        break; 	  	 

        case TFTMOTOR_STATUS_REQ_STEP0_TO_INIT90:
            ucTFTMotorDriverStatus = TFTMOTOR_STATUS_INIT90;
            ucTFTMotorDriverTime = TFTMOTOR_RUNLENGTH_STEP0_AND_INIT90_TIMEOUT;
            TFT_Motor_Driver(MOTOR_CLOSE);
        break; 	  	

        case TFTMOTOR_STATUS_REQ_STEP60_TO_STEP30:
            ucTFTMotorDriverStatus = TFTMOTOR_STATUS_STEP30;
            ucTFTMotorDriverTime = TFTMOTOR_RUNLENGTH_STEP60_AND_STEP30_TIMEOUT;
            TFT_Motor_Driver(MOTOR_OPEN);
        break; 	  

        case TFTMOTOR_STATUS_REQ_STEP60_TO_STEP0:
            ucTFTMotorDriverStatus = TFTMOTOR_STATUS_STEP0;
            ucTFTMotorDriverTime = TFTMOTOR_RUNLENGTH_STEP60_AND_STEP0_TIMEOUT;
            TFT_Motor_Driver(MOTOR_OPEN);
        break; 	

        case TFTMOTOR_STATUS_REQ_STEP30_TO_STEP60:
            ucTFTMotorDriverStatus = TFTMOTOR_STATUS_STEP60;
            ucTFTMotorDriverTime = TFTMOTOR_RUNLENGTH_STEP60_AND_STEP30_TIMEOUT;
            TFT_Motor_Driver(MOTOR_CLOSE);
        break; 	  

        case TFTMOTOR_STATUS_REQ_STEP0_TO_STEP60:
            ucTFTMotorDriverStatus = TFTMOTOR_STATUS_STEP60;
            ucTFTMotorDriverTime = TFTMOTOR_RUNLENGTH_STEP60_AND_STEP0_TIMEOUT;
            TFT_Motor_Driver(MOTOR_CLOSE);
        break; 	  

        case TFTMOTOR_STATUS_REQ_STEP30_TO_STEP0:
            ucTFTMotorDriverStatus = TFTMOTOR_STATUS_STEP0;
            ucTFTMotorDriverTime = TFTMOTOR_RUNLENGTH_STEP30_AND_STEP0_TIMEOUT;
            TFT_Motor_Driver(MOTOR_OPEN);
        break; 	  

        case TFTMOTOR_STATUS_REQ_STEP0_TO_STEP30:
            ucTFTMotorDriverStatus = TFTMOTOR_STATUS_STEP30;
            ucTFTMotorDriverTime = TFTMOTOR_RUNLENGTH_STEP30_AND_STEP0_TIMEOUT;
            TFT_Motor_Driver(MOTOR_CLOSE);
        break; 	

      //  case TFTMOTOR_STATUS_INIT90:	 
        case TFTMOTOR_STATUS_STEP60:
        case TFTMOTOR_STATUS_STEP30:
       // case TFTMOTOR_STATUS_STEP0:	
            if(ucTFTMotorDriverTime > 0)
                break;

            TFT_Motor_Driver(MOTOR_STOP);
            ucMotorCurPos = ucTFTMotorDriverStatus;
        break;
        case TFTMOTOR_STATUS_INIT90:
        case TFTMOTOR_STATUS_STEP0:
                if(ucTFTMotorDriverStatus == TFTMOTOR_STATUS_INIT90){
                	  if(PinIN_CHECKP){
                	  	debug("N HIGH");
                	  	break;
                	  	}
                }else{ 
                    if(PinIN_CHECKN)
                	       break;
                	}
        	  TFT_Motor_Driver(MOTOR_STOP);
        	  ucMotorCurPos  = ucTFTMotorDriverStatus;
        	break;
         	
    }
}

void TFTMotorCommand(unsigned char objPos)
{

    switch(ucMotorCurPos)
    {
        case TFTMOTOR_STATUS_INIT90:
            switch(objPos)
            {
                case OBJECT_TFTMOTOR_TO_STATUS_INIT90:

                    break;
                case OBJECT_TFTMOTOR_TO_STATUS_STEP60:
                    ucTFTMotorDriverStatus = TFTMOTOR_STATUS_REQ_INIT90_TO_STEP60;
                    break;
                case OBJECT_TFTMOTOR_TO_STATUS_STEP30:
                    ucTFTMotorDriverStatus = TFTMOTOR_STATUS_REQ_INIT90_TO_STEP30;
                    break;
                case OBJECT_TFTMOTOR_TO_STATUS_STEP0:
                    ucTFTMotorDriverStatus = TFTMOTOR_STATUS_REQ_INIT90_TO_STEP0;
                    break;
            }
        break;
        
        case TFTMOTOR_STATUS_STEP60:
            switch(objPos)
            {
                case OBJECT_TFTMOTOR_TO_STATUS_INIT90:
                    ucTFTMotorDriverStatus = TFTMOTOR_STATUS_REQ_STEP60_TO_INIT90;
                    break;
                case OBJECT_TFTMOTOR_TO_STATUS_STEP60:

                    break;
                case OBJECT_TFTMOTOR_TO_STATUS_STEP30:
                    ucTFTMotorDriverStatus = TFTMOTOR_STATUS_REQ_STEP60_TO_STEP30;
                    break;
                case OBJECT_TFTMOTOR_TO_STATUS_STEP0:
                    ucTFTMotorDriverStatus = TFTMOTOR_STATUS_REQ_STEP60_TO_STEP0;
                    break;
            }
        break;
        
        case TFTMOTOR_STATUS_STEP30:
            switch(objPos)
            {
                case OBJECT_TFTMOTOR_TO_STATUS_INIT90:
                    ucTFTMotorDriverStatus = TFTMOTOR_STATUS_REQ_STEP30_TO_INIT90;
                    break;
                case OBJECT_TFTMOTOR_TO_STATUS_STEP60:
                    ucTFTMotorDriverStatus = TFTMOTOR_STATUS_REQ_STEP30_TO_STEP60;
                    break;
                case OBJECT_TFTMOTOR_TO_STATUS_STEP30:

                    break;
                case OBJECT_TFTMOTOR_TO_STATUS_STEP0:
                    ucTFTMotorDriverStatus = TFTMOTOR_STATUS_REQ_STEP30_TO_STEP0;
                    break;
            }
        break;
        
        case TFTMOTOR_STATUS_STEP0:
            switch(objPos)
            {
                case OBJECT_TFTMOTOR_TO_STATUS_INIT90:
                    ucTFTMotorDriverStatus = TFTMOTOR_STATUS_REQ_STEP0_TO_INIT90;
                    break;
                case OBJECT_TFTMOTOR_TO_STATUS_STEP60:
                    ucTFTMotorDriverStatus = TFTMOTOR_STATUS_REQ_STEP0_TO_STEP60;
                    break;
                case OBJECT_TFTMOTOR_TO_STATUS_STEP30:
                    ucTFTMotorDriverStatus = TFTMOTOR_STATUS_REQ_STEP0_TO_STEP30;
                    break;
                case OBJECT_TFTMOTOR_TO_STATUS_STEP0:
                    break;
            }
        break;
    }
}

void TFT_Motor_Driver(unsigned char in)
{
    if(in == MOTOR_OPEN)
    {
        PIN_MOTORN = 0;
        PIN_MOTORP = 1;
    }
    else if(in == MOTOR_CLOSE)
    {
        PIN_MOTORN  = 1;
        PIN_MOTORP  = 0;
    }
    else if(in == MOTOR_STOP)
    {
        PIN_MOTORN  = 0;
        PIN_MOTORP  = 0;
    }
}

void ProTrayMotor(void)
{
    switch(TrayModeState)
    {
        case TRAYMOTOR_IDLE:
            //TrayAction(TRAY_STOP);
            break;

        case TRAYMOTOR_CLOSE_REQ:
            TrayAction(MOTOR_CLOSE);
            TrayModeState = TRAYMOTOR_CLOSING;

            break;

        case TRAYMOTOR_CLOSING:
            if(PINin_TRAYIN)//"H" 
                return;
            TrayModeState = TRAYMOTOR_CLOSED;
            
            break;

        case TRAYMOTOR_CLOSED:
            TrayAction(MOTOR_STOP);
            TrayModeState = TRAYMOTOR_IDLE;
            TFTMotorCommand(OBJECT_TFTMOTOR_TO_STATUS_INIT90);//then need call reset tft_motor function.
            
            break;

        case TRAYMOTOR_OPEN_REQ:
            //befor need call open tft_motor function.
            TFTMotorCommand(OBJECT_TFTMOTOR_TO_STATUS_STEP60);
            if(ucMotorCurPos != TFTMOTOR_STATUS_STEP60)
            {
                return;
            }
            TrayAction(MOTOR_OPEN);
            TrayModeState = TRAYMOTOR_OPENING;
            break;

        case TRAYMOTOR_OPENING:
            if(PINin_TRAYOUT)
                return;

            TrayModeState = TRAYMOTOR_OPENED;      
            break;

        case TRAYMOTOR_OPENED:
            TrayAction(MOTOR_STOP);
            TrayModeState = TRAYMOTOR_IDLE;
            break;

    }
}


void TrayAction(unsigned char traymode)
{
    switch(traymode)
    {
        case MOTOR_CLOSE:
            PIN_TRAYP = 0;
            PIN_TRAYN= 1;
            
            break;

        case MOTOR_OPEN:
            PIN_TRAYP = 1;
            PIN_TRAYN = 0;
            
            break;

        case MOTOR_STOP:
            PIN_TRAYP= 0;
            PIN_TRAYN = 0;
            
            break;

        
    }

}

void MotorCommand(void)//will define one key to set tft panel situation.
{
    unsigned char pos;
   
        switch(SysCommand)
        {
            case SYSTEM_COMMAND_MOTOR_0:
            //	debug("90");
                pos  = OBJECT_TFTMOTOR_TO_STATUS_STEP0;
            break;
            
            case SYSTEM_COMMAND_MOTOR_30:
            	//debug("60");
                pos  = OBJECT_TFTMOTOR_TO_STATUS_STEP30;
            break;
            
            case SYSTEM_COMMAND_MOTOR_60:
            	//debug("30");
                pos  = OBJECT_TFTMOTOR_TO_STATUS_STEP60;
            break;
            
            case SYSTEM_COMMAND_MOTOR_INIT:
            	//debug("0");
                pos = OBJECT_TFTMOTOR_TO_STATUS_INIT90;
            break;
        }
        TFTMotorCommand(pos);
    
}

void Motor_Init(void)
{
    PD_MOTORP = 1;
    PCR1_MOTORP = 1;
    PCR2_MOTORP  = 0;
    PIN_MOTORP = 0;

    PD_MOTORN = 1;
    PCR1_MOTORN  = 1;
    PCR2_MOTORN  = 0;
    PIN_MOTORN = 0;

    PD_TRAYP= 1;
    PCR1_TRAYP= 1;
    PCR1_TRAYP =1;
    PIN_TRAYP  = 0;

    PD_TRAYN = 1;
    PCR1_TRAYN  = 1;
    PCR2_TRAYN  = 1;
    PIN_TRAYN = 0;

    PD_TRAYOUT = 0;
    PCR1_TRAYOUT = 1;
    PCR2_TRAYOUT = 0;

    PD_TRAYIN = 0;
    PCR1_TRAYIN = 1;
    PCR2_TRAYIN = 0;

    PD_LOADSW = 0;
    PCR1_LOADSW = 1;
    PCR2_LOADSW  = 0;

    PD_CHECKN = 0;
    PCR1_CHECKN  = 1;
    PCR2_CHECKN  = 0;

    PD_CHECKP  = 0;
    PCR1_CHECKP  = 1;
    PCR2_CHECKP  = 0;
    
    TrayModeState = TRAYMOTOR_IDLE;
    ucMotorCurPos = TFTMOTOR_STATUS_INIT90;
}

void TFTMotorDriverTimer100ms(void)
{
       if(ucTFTMotorDriverTime > 0) ucTFTMotorDriverTime --;
}