sle44064.c

2106卡的程序

#include <reg52.h>
#include <intrins.h>
#include <string.h>

#define _SRC
#include "SLE4406.h"
#undef _SRC

BYTE Check_ICSW();
/****************************************************************************
* Function:     isr_ext0                                                    *
****************************************************************************/
void isr_ex0(void) interrupt 0
{
}
/****************************************************************************
* Function:     isr_timer0                                                  *
****************************************************************************/
void isr_timer0(void) interrupt 1
{
  TOGGLE_WD();
  if (Timer0Cnt)
  {
    --Timer0Cnt;
  }else{
    STOP_T0();
    RecvState=RECV_STX;
  }
}
/****************************************************************************
* Function:     isr_ext1                                                    *
****************************************************************************/
void isr_ext1(void) interrupt 2
{
}
/****************************************************************************
* Function:     isr_timer1                                                  *
****************************************************************************/
void isr_timer1(void) interrupt 3
{
  BitCnt--;
  if(RxFlag)		//RxBit
  {
    if(BitCnt==0)
    {
      if(!ICIO)
        RxErr=1;        //not valid stopbit
      ICIO=1;
      RxFlag=0;
      RcvRdy=1;         //Receive finish
      TR1=FALSE;        //Close TR1
    }else if(BitCnt==1)
    {
      ACC=RcvDat;
      if(ICIO!=_testbit_(P))  //not valid Parity bit
      { 
        ICIO=0;
        RxErr=1;
      }
    }else if(BitCnt==10)
    {
      if(ICIO)
        RxErr=1;      //not valid startbit
    }else{
      RcvDat=RcvDat>>1;
      if(ICIO)
        RcvDat=RcvDat|0x80;
    }
  }
  if(TxFlag)        //TxBit
  {
    if(BitCnt==0)
    {
      TxFlag=0;     //Send finish
      TR1=FALSE;
    }else if(BitCnt==1)
    {
      ICIO=1;       //Stopbit
    }else if(BitCnt==2)
    {
      ICIO=Parity;
    }else{
      XmtDat=XmtDat>>1;
      ICIO=CY;
    }
  }
}
/****************************************************************************
* Function:     isr_UART                                                    *
****************************************************************************/
void isr_UART(void) interrupt 4
{
  BYTE c, i, len,chk;

  TOGGLE_WD();

  if (RI)
  {
    STOP_T0();	  
    c  = SBUF;
    RI = FALSE;
    switch (RecvState)
    {                           // Receive Command
      case RECV_STX:
        if (c == STX)
        {
          if (LLfReady)
          {
            SBUF = DLE;
            Index = 0;
            DataDleReceived = FALSE;
            RecvState = RECV_DATA_DLE_ETX;

            while (!TI);
            TI = FALSE;
            START_T0(T_533_ms);
          }else
          {
            CmdReceived = TRUE;
            RecvState = RECV_STX;
          }
        }else{
          RecvState = RECV_STX;
        }
        break;
      case RECV_DATA_DLE_ETX:
        if (c == DLE)
        {
          if (!DataDleReceived)
          {
            DataDleReceived = TRUE;
            RecvState = RECV_DATA_DLE_ETX;
            START_T0(T_533_ms);
            break;
          }else{
            DataDleReceived = FALSE;
          }
        }else if (c == ETX)
        {
          if (DataDleReceived)
          {
            DataDleReceived = FALSE;
            len = SerBuffer[LENGTH];
            chk = 0;
            for (i = 0; i < Index; i++)
              chk ^= SerBuffer[i];
            if (chk == 0)
            {
              SBUF = DLE;
              while (!TI);
              TI = FALSE;
              SendReady=FALSE;
              LLfReady=FALSE;
              CmdValid = 0xa5;
              SeqNr = SerBuffer[SEQNR];
              break;
            }else
            {
              SBUF = NAK;
              Quit =FALSE;
              while (!TI);
              TI = FALSE;
              RecvState = RECV_STX;
              break;
            }
          } //end DATADLERECEIVED
        }   //END ETX
        if (Index < SERBUFLEN)
          SerBuffer[Index++] = c;
        RecvState = RECV_DATA_DLE_ETX;
        START_T0(T_533_ms);
        break;
                            // Handshake for sending Response
      case RECV_DLE:
        if (c == DLE)
        {
          for (c = 0; c < (HEADER + SerBuffer[LENGTH] + 1); c++)
          {
            SBUF = SerBuffer[c];
            while (!TI);
            TI = FALSE;
            if (SerBuffer[c] == DLE)
            {
              SBUF = DLE;
              while (!TI);
              TI = FALSE;
            }
          }
          SBUF = DLE;
          while (!TI);
          TI = FALSE;
          SBUF = ETX;
          while (!TI);
          TI = FALSE;
          RecvState = RECV_DLE_OR_NAK;
   
           START_T0(T_533_ms);
        }else if (c == STX)
        {
          CmdReceived = TRUE;
          CmdValid = 0x00;
          CALL_isr_UART();
          RecvState = RECV_STX;          
        }else{
          CALL_isr_T0();
          RecvState = RECV_STX;          
        }
        break;
      case RECV_DLE_OR_NAK:
        RecvState = RECV_STX;      
        if (c == DLE)
        {
          RepCnt = 0;
          Quit = FALSE;
          SendReady = TRUE;
        }else if (c == STX)
        {
          CmdReceived = TRUE;
          CmdValid = 0x00;
          CALL_isr_UART();
        }else{
//          CALL_isr_T0();
        }
        break;
      default:
//        CALL_isr_T0();
        RecvState = RECV_STX;        
        break;
    }
  } // end if (RI)

  if (TI && !RI)
  {
    TI = FALSE;
    LLfReady = TRUE;
    if (!CmdReceived)           // Send Response
    {
      if (Quit)
      {
        if(QuitStatus != OK)
        {
          SerBuffer[SEQNR] = SeqNr;
        }
        SerBuffer[STATUS] = QUIT;
        SerBuffer[LENGTH] = 0;
      }
      len = HEADER + SerBuffer[LENGTH];
      chk = 0;
      for (i = 0; i < len; i++)
      chk ^= SerBuffer[i];
      SerBuffer[len] =chk;
      SBUF = STX;
      RecvState = RECV_DLE;
    }else                        // Handshake for receiving Command
    {
      SBUF = DLE;
      CmdReceived = FALSE;
      Quit = TRUE;
      QuitStatus = SerBuffer[STATUS];
      Index = 0;
      DataDleReceived = FALSE;
      RecvState = RECV_DATA_DLE_ETX;
    }
    while (!TI);
    TI = FALSE;
    START_T0(T_533_ms);
  } // end if (TI)
}
/****************************************************************************
* Function:     isr_timer2                                                  *
****************************************************************************/
void isr_timer2(void) interrupt 5
{
}
/****************************************************************************
* Function:     delay_50us_NOP                                              *
****************************************************************************/
void delay_50us_NOP(BYTE _50us)
{
  BYTE i;
  
  for (i=0;i<_50us;i++)
  {
    _nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();
    _nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();
    _nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();
    _nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();
    _nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();
  }
}
/****************************************************************************
* Function:     delay_10ms                                                  *
****************************************************************************/
void delay_10ms(WORD _10ms)
{
  BYTE i;
  TOGGLE_WD();  

  while(_10ms--)
  {
    for(i=0;i<200;i++)
      delay_50us_NOP(1);
  }
}
/****************************************************************************
* Function:     qry_ext1                                                    *
****************************************************************************/
void qry_ext1(BYTE bytenr,BYTE *Buffer)
{
  ptr=0;
  do{
    do{
    }while(ICIO);
    BitCnt=11;
    TL1=StrtVal;
    TH1=BaudVal;          //96
    RcvDat=0;
    RxErr=0;
    TR1=TRUE;
    RxFlag=1;
    do{
    }while(RxFlag);
    Buffer[ptr]=RcvDat;
    ptr++;
  }while(ptr<bytenr);
}
/****************************************************************************
* Function:     RSXmt                                                       *
****************************************************************************/
void RSXmt(void)
{
  do{}while(RxFlag);    //wait rcv finish
  BitCnt=11;
  TL1=BaudVal;          //96
  TH1=BaudVal;
  TR1=1;
  ICIO=0;
  TxFlag=1;             //SETB TxFlag
  ACC=XmtDat;
  Parity=P;
  do{}while(TxFlag);    //wait send finish
}
/****************************************************************************
* Function:     Power_off                                                   *
****************************************************************************/
void Power_off(void)
{
  ICRST=0;
  ICCLK=0;         //Disable
  ECPU =FALSE;
  ICIO =0;
  ICVCC=0;
  LED(RED,OFF);
}
/****************************************************************************
* Function:     Reset                                                       *
****************************************************************************/
void Reset(BYTE *len, BYTE *resp)
{
  Index=ADR;                    
  LED(RED,ON);    
  if(!ECPU)
  { 
    ICVCC=1;
    delay_10ms(1);
    ICIO =1;          //Receive State
    ICCLK=1;
    ECPU =TRUE;
  }else{
    ICRST=0;
  }
  TMOD=0x22;        //Timer1, mode2, Timer0, mode2
  TH1=-52;          
  TL1=-52;
  ET1=FALSE;
  TR1=TRUE;
  do{}while(!TF1);  //Delay 200 period  200/3.57Mhz=56us,
                    //56us/1.085us=51.6Cyl
  TF1=FALSE;
  ET0=FALSE;
  ET1=TRUE;
  TR1=FALSE;
  ICRST=1;
  qry_ext1(2,resp);         
  *len=(resp[1]&0x0f)+2;
  qry_ext1(*len,&(resp[2]));
  *len+=2;
}  

WORD CPUC_Cmd(BYTE len,BYTE* comm, BYTE *lenr, BYTE* resp)
{
  BYTE Lc, Le, sw1, sw2, i;
  BYTE BPrc,INS;

Begin:
  INS=comm[1];
  if(len>5)
  {
    Lc=comm[4];
    Le=comm[5+Lc];
  }else{
    Le=comm[4];
    Lc=0;
  }
  for(i=0;i<5;i++)      //Send CLA, INS, P1, P2, 0/Le/Lc
  {
    XmtDat=comm[i];
    RSXmt();
  }
A:  
  qry_ext1(1,&BPrc);

  if(BPrc==0x6c)	//wait
  {
    goto A;
  }else if(BPrc==INS)
  {
    if(Lc==0)