m9s12db128.c

ucos2 应用

  
  for (i=0; i++; i<4) {       // clear pulse counter
    HSCTmp[i]=0;
    HSC100ms[i]=0;
  }
  HSCTick = 0;
  LSCTmp  = 0;
  MDCounter = 0;
  return;  
}

/****************************** MDC interrupt ************************************/
// MDCU IRQ routine, used as high speed pulse counter
// Pulse counter sampled at interval of 10ms, so input frequency should less than 25.5KHz.
// Modulus Down Counter underflow automatic latch PAC0~PAC3 to PA0H~PA3H,and reset PAC0~PAC3
void interrupt VEC_MDCU MDCU_ISR() {

  
  MCCNT = TIMER_MDC_COUNT;
  fMDC10ms  = 1; 
  MDCounter++;
  HSCTick++;
  
  
  MCFLG   |= 0x80;    // clear underflow flag 

  if (HSCTick >= 10) {
   HSCTick = 0;
   HSC100ms[0] = HSCTmp[0]+ PA0H;
   HSC100ms[1] = HSCTmp[1]+ PA1H;
   HSC100ms[2] = HSCTmp[2]+ PA2H;
   HSC100ms[3] = HSCTmp[3]+ PA3H;  
   LSC100ms    = LSCTmp;
   HSCTmp[0]  = 0;
   HSCTmp[1]  = 0;
   HSCTmp[2]  = 0;
   HSCTmp[3]  = 0;
   LSCTmp     = 0;
  } else {
    HSCTmp[0] += PA0H;
    HSCTmp[1] += PA1H;
    HSCTmp[2] += PA2H;
    HSCTmp[4] += PA3H;
  }
  
  
  return;
}

/****************************** Get HSCounter ************************************/

void GetHSCounter(uint * pHSCounter) {
  
  uchar i;
  for (i=0; i<PUMP_NUM; i++)
    *pHSCounter++ = HSC100ms[i]  ;
   return;
}


/****************************** Get LSCounter ************************************/

void GetLSCounter(uint * pLSCounter){
 
  *pLSCounter = LSC100ms;
  return; 
}


/***************************** LSCounter interrupt ************************************/

// IRQ routine, used as low speed pulse counter, 
// input frequency should less than 5KHz to reduce CPU overhead.

void interrupt VEC_IRQ IRQ_ISR(){
  LSCTmp++;
  return;  
}

/************************** Initialize A/D  hardware ********************************/
// interface function:
// void InitATD()
// void GetAD0Result(uint * pADResult);

void InitATD() {

  // AN3 ~AN6 used for sampling pressure 
  // AN12~AN15 used for sampling displacement 
  // 10bit resolution
  // samples rate is 100Hz, do averaging every 4 samples
  // using MDC interrupt to trigger a sequence conversion
  uchar i,j;
  ATD0CTL2  = (BM_ADPU + BM_AFFC + BM_AWAI  );// Disable external trigger, Disable interrupt
  ATD1CTL2  = (BM_ADPU + BM_AFFC + BM_AWAI  );  
  
  ATD0CTL3  = (BM_S4C + BM_FIN_FRZ);          // 4 channel, FIFO disabled, freeze after finishing current conversion 
  ATD1CTL3  = (BM_S4C + BM_FIN_FRZ);

  ATD0CTL4  = (BM_4ST + BM_PRS(11) );         // SRE8= 0, 4 clock periods for sampling, AD clock= S12_ECLK/2/(n+1)= 1MHz
  ATD1CTL4  = (BM_4ST + BM_PRS(11) );
  
  START_AD0;
  START_AD1;
  
  for (i=0; i< PUMP_NUM; i++){
    for (j=0; j< AD_QUE_LEN; j++)
    AD0Que[i][j] = 0;
    AD1Que[i][j] = 0;
  }
  ADQueIndex  = 0;
  

  return;  
}

/************************** Get ATD0 result ********************************/
void  GetAD0Result(int * pADResult) {

  // output 12 bit resolution if AD_QUE_LEN = 4
  uchar i,j;
  int   tmp;
  for (i=0; i<PUMP_NUM; i++) {
    
    tmp = 0;
    for (j=0; j< AD_QUE_LEN; j++)
      tmp += AD0Que[i][j];
    
    *pADResult = tmp;
    pADResult++; 
  }
  return;
}


/************************** Get ATD1 result ********************************/
void  GetAD1Result(int * pADResult) {

  // output 12 bit resolution if AD_QUE_LEN = 4
  uchar i,j;
  int   tmp;
  for (i=0; i<PUMP_NUM; i++) {
    
    tmp = 0;
    for (j=0; j< AD_QUE_LEN; j++)
      tmp += AD1Que[i][j];
    
    *pADResult = tmp;
    pADResult++; 
  }
  return;
}



/************************** SCI Routines  ********************************/
// interface function:
// void  InitSCI(uchar Port, uint BaudRate)
// uchar PrintString(uchar Port, char * pBuf)
// uchar GetChar(uchar Port,uchar BufLen, char *pBuf)

#define SCI_BUF_LEN 128
#define REC_BUF_LEN 16

typedef struct  SCI_BUF{
  uchar top;
  uchar bot;
  char  Msg[SCI_BUF_LEN];
}; 
struct SCI_BUF SCIBuf[2];

typedef struct REC_BUF{
  uchar top;
  char  Msg[REC_BUF_LEN] ;
} ;

struct REC_BUF RecBuf[2];

  
void InitSCI(uchar Port, uint BaudRate) {
  if ( Port>1 )
    return;
  if (Port ==0) {
    SCI0BD  = BaudRate;
    SCI0CR1 = 0x0;         
    SCI0CR2 = ( BM_RIE + BM_TE + BM_RE); 
  }
  else {
    SCI1BD  = BaudRate;
    SCI1CR1 = 0x0;
    SCI1CR2 = ( BM_RIE + BM_TE + BM_RE); 
  }
  SCIBuf[Port].top = 0;
  SCIBuf[Port].bot = SCI_BUF_LEN-1;
  RecBuf[Port].top = 0;
  
}            


void PrintString(uchar Port, char * pBuf) {
 
  if (Port>1)
    return ;
  while(*pBuf != '\0'){
    SCIBuf[Port].Msg[SCIBuf[Port].top]= *pBuf++;
    SCIBuf[Port].top++;
    
    if (SCIBuf[Port].top >= SCI_BUF_LEN)
      SCIBuf[Port].top  = 0;
    
    if (SCIBuf[Port].top  == SCIBuf[Port].bot) {
      SCIBuf[Port].top--;
      if (SCIBuf[Port].top > SCI_BUF_LEN) 
        SCIBuf[Port].top = SCI_BUF_LEN -1;    // underflow
      
    }
  }                  
  if (Port ==0 )
    SCI0CR2 |= BM_TIE;
  else
    SCI1CR2 |= BM_TIE;
  return ;
}


uchar   GetChar(uchar Port,uchar BufLen, char *pBuf) {

  uchar Rt;
  uchar i;
  if (Port > 1)
    return 0;
  if (Port == 0 )
    SCI0CR2 &= (~BM_RIE) ;  // disable receive interrupt temporary
  else
    SCI1CR2 &= (~BM_RIE) ;
  
  if (BufLen < RecBuf[Port].top)
     RecBuf[Port].top = BufLen;
  Rt  = RecBuf[Port].top;
  
  for (i=0; i<RecBuf[Port].top; i++)
    *(pBuf++) = RecBuf[Port].Msg[i] ;
 
  RecBuf[Port].top = 0;
  if (Port == 0)
    SCI0CR2 |= BM_RIE;
  else
    SCI1CR2 |= BM_RIE;
  return Rt;
  
}


uchar TransIrq(uchar Port) {

  SCIBuf[Port].bot++;
  
  if (SCIBuf[Port].bot >= SCI_BUF_LEN){
      SCIBuf[Port].bot = 0; 
  }
  
  if (SCIBuf[Port].bot == SCIBuf[Port].top) {
      SCIBuf[Port].bot--;
      if (SCIBuf[Port].bot >= SCI_BUF_LEN)
        SCIBuf[Port].bot == SCI_BUF_LEN-1 ;
      return FALSE;
  } 
  else {
    if (Port ==0)
      SCI0DRL = SCIBuf[Port].Msg[SCIBuf[Port].bot];
    else
      SCI1DRL = SCIBuf[Port].Msg[SCIBuf[Port].bot];
    return TRUE;
  }
}

void  ReceiveIrq(uchar Port) {

  char c[2];
  if (Port == 0)
    RecBuf[Port].Msg[RecBuf[Port].top] = SCI0DRL;
  else
    RecBuf[Port].Msg[RecBuf[Port].top] = SCI1DRL;
  
  c[0]  = RecBuf[Port].Msg[RecBuf[Port].top];
  c[1]  = 0;
  PrintString(0,c);
  if (c[0] == '\r'){
    c[0]  = '\n';
    PrintString(0,c);
  }
    
  
  RecBuf[Port].top++;
  if (RecBuf[Port].top >= REC_BUF_LEN)
    RecBuf[Port].top = REC_BUF_LEN - 1 ;
}


void interrupt VEC_SCI1 SCI1_ISR() {
  uchar St;
  St  = SCI1SR1;
  if (St & BM_TDRE){ // transmission interrupt
    if (TransIrq(1) == FALSE)
      SCI1CR2 &= (~BM_TIE) ;    // No data waiting for transmission
  }
  if ((St & BM_RDRF) != 0){
    ReceiveIrq(1);
  }
  return;
  
}

void interrupt VEC_SCI0 SCI0_ISR(){
  
  uchar St;
  St  = SCI0SR1;
  SCI0SR1 &= 0xf0;    // clear error flags
  if (St & BM_TDRE){ // transmission interrupt
    if (TransIrq(0) == FALSE)
      SCI0CR2 &= (~BM_TIE) ;    // No data waiting for transmission, disable interrupt
  }
  if (St & BM_RDRF){
    ReceiveIrq(0);
  }
  return;
}