doorlock.c

freescale最新的16位单片机

/******************************************************************************		
*                                                                                   
*       Copyright (C) 2006 Freescale Semiconductor, Inc.                            
*       All Rights Reserved								              				
*														              				
* Filename:     DoorLock.c                										
*														              				
* Functions:    includes compiler predefines for the Master Node			      	
*												                            		
* Description:	routines to open or close the door lock mechanism																	
*																					
* Notes:								
*																					
******************************************************************************/	

/*****************************************************************************/
#include    "9S12XDP512.h"
#include    "main.h"
#include    "DoorLock.h"
#include    "spi.h"
/*****************************************************************************/
/*                       Global Variables                                    */
/*****************************************************************************/
 volatile char stateOfMechanism = 0;
 extern Byte fm_task;			//actual fm window
 
/******************************************************************************
* Module            : void void DoorOverCurent (void);
* Description       : detect overcurrent on ADC and close both aoutputs 
*                   : on H-bridges
* Global Data       : none
* Static Global Data: none
* Returns           : state
* Arguments         : none
* Special Issues    : used constant CRITICALVALUE strongly depends on 
*                   : mounted doorlock mechanism
******************************************************************************/
char DoorOverCurent (void)
{
unsigned int door1 = 0, door2 = 0;
char i;


  //DoorLock nr. 1
  for(i=0; i<4; i++)
  {
    ATD0CTL5 = ATD0CTL5_DJM_MASK | ATD0CTL5_CB_MASK | ATD0CTL5_CA_MASK;      // ATD03 , right justif., ch1 starts
    while(!ATD0STAT0_SCF);                            // wait till conversion is completed + clear scf f}lag when set
    door1 += ATD0DR0;                                 // read data => clear conversion complete flags  
  }
  door1 /= 4;                                       


  //DoorLock nr. 2
  for(i=0; i<4; i++)
  {
    ATD1CTL5 = ATD1CTL5_DJM_MASK | ATD1CTL5_CA_MASK | ATD1CTL5_CB_MASK;      // ATD11 , right justif., ch1 starts
    while(!ATD1STAT0_SCF);                            // wait till conversion is completed + clear scf flag when set
    door2 += ATD1DR0;                                  // read data => clear conversion complete flags
  }
  door2 /= 4;

  if(((door1>CRITICALVALUE)&&(door1!=0))||((door2>CRITICALVALUE)&&(door2!=0))) // if overcurrent value is lower than CRITICALVALUE
  {	
    DISABLE_OUPUTS();
    return(0);
  }
  else return (2);
}
/******************************************************************************
* Module            : void doorOpen(void);
* Description       : Open relevant DoorLock mechanism, checks over-current, 
*                   : if everithing done - end its self (Task)
* Global Data       : none
* Static Global Data: none
* Returns           : state
* Arguments         : char OpenClose
* Special Issues    : none
******************************************************************************/
char DoorOpen(void){
SPI24              temp24;
char                state, i=0;

  if(stateOfMechanism==0)     /* open only once */
  {
    RESET_HBRIDGE();    // RESET_HBRIDGE;
    DOOR1_OPEN();       //DoorLock nr. 1 CLOSE
    DOOR2_OPEN();		    //DoorLock nr. 2 CLOSE
  }
  stateOfMechanism += 1;    /* every time */
              
  CSB_U404 = 0;									            /* find position of DoorLock, on MSDI */
  temp24.comm = U404_SWITCH_STATUS;
  temp24.data.w = U404_ZERO;
  temp24 = ReadWriteSPI24bit(temp24);
  CSB_U404 = 1;
            
  if(temp24.comm & U404_TEST_SP3_SET)	    /*OPEN DoorLock*/
  {
    Delay100Us();//delaytime   
    DISABLE_OUPUTS();
    stateOfMechanism = 0;
    return (state = FALSE);
  }else if(stateOfMechanism == 100)        /* too much times tried (20ms) */
  {
    DISABLE_OUPUTS();
    stateOfMechanism = 0;
    return (state = FALSE); 
  }else 
  {
    state = DoorOverCurent();            /* overcurrent feedback on H-Bridge */
    if(state == 100)
    {
      stateOfMechanism = 0;							 /* door lock "docked" */
      return state; 
    }
  }
  
}

/******************************************************************************
* Module            : void doorClose(void);
* Description       : Close relevant DoorLock mechanism, checks over-current
*                   : if everithing done - end its self (Task)
* Global Data       : none
* Static Global Data: none
* Returns           : state
* Arguments         : char OpenClose
* Special Issues    : none
******************************************************************************/
char DoorClose(void)
{
SPI24              temp24;
char                state, i=0;

  if(stateOfMechanism==0)     /* open only once */
  {																				
    RESET_HBRIDGE();    // RESET_HBRIDGE;
    DOOR1_CLOSE();      //DoorLock nr. 1 CLOSE
    DOOR2_CLOSE();		  //DoorLock nr. 2 CLOSE
  }
  stateOfMechanism += 1;    /* every time */

            
  CSB_U404 = 0;									            /* find position of DoorLock, on MSDI */
  temp24.comm = U404_SWITCH_STATUS;
  temp24.data.w = U404_ZERO;
  temp24 = ReadWriteSPI24bit(temp24);
  CSB_U404 = 1;
            
  if(temp24.comm & U404_TEST_SP2_SET)     /*OPEN DoorLock*/
  {
    Delay100Us();//delaytime      
    DISABLE_OUPUTS();
    stateOfMechanism = 0;
    return (state = FALSE);
  }else if(stateOfMechanism == 100)        /* too much times tried (20ms) */
  {
    DISABLE_OUPUTS();
    stateOfMechanism = 0;
    return (state = FALSE); 
  }else 
  {
    state = DoorOverCurent();            /* Overcurrent feedback on H-Bridge */
    if(state == 100)
    {
      stateOfMechanism = 0;							 /* door lock "docked" */
      return state; 
    }
  }  
}

/******************************************************************************
* Module            : void FollowMasterDoorLock();
* Description       : Open or Close slave DoorLock mechanism
* Global Data       : none
* Static Global Data: none
* Returns           : none
* Arguments         : none
* Special Issues    : not implemented into task control
******************************************************************************/
void FollowMasterDoorLock(void)
{
  SPI24 temp24;
  char temporary;

  if (fm_task==DOOR_LOCK)return;						/*disabled if controlled from second source*/

  CSB_U404 = 0;									            /* find position of DoorLock, on MSDI */
  temp24.comm = U404_SWITCH_STATUS;
  temp24.data.w = U404_ZERO;
  temp24 = ReadWriteSPI24bit(temp24);
  CSB_U404 = 1;
  temporary = DoorOverCurent();

  if((temp24.comm & U404_TEST_SP3_SET)&&(!stateOfMechanism))
  {  /*opened DoorLock*/
    stateOfMechanism = TRUE;  

    DOORLock1_Disable = DISABLE;							/*DoorLock nr. 2 OPEN or CLOSE*/
    DOORLock1_Enable = ENABLE;
    DOORLock1_Input1 = (byte)stateOfMechanism;
    DOORLock1_Input2 =~ (Bool)stateOfMechanism;
    //DoorOverCurent();
  } else if((temp24.comm & U404_TEST_SP2_SET)&&(stateOfMechanism))
  {  /*closed DoorLock*/
    stateOfMechanism = FALSE;

    DOORLock1_Disable = DISABLE;							/*DoorLock nr. 2 OPEN or CLOSE*/
    DOORLock1_Enable = ENABLE;
    DOORLock1_Input1 = (byte)stateOfMechanism;
    DOORLock1_Input2 =~ (Bool)stateOfMechanism;
    //DoorOverCurent();
  } 
}