ALPS-004/WZYXPCR_NO1.20250726.X/WZYXPCR_NO1.20250726.X/file/Uart.c

#define  __UART_DEF
#include "ABIS_User.h"


#include <stdarg.h>
#include <stdio.h>
#include <string.h>
	
unsigned int  gloublePrintLevel = 4;


/****************************************************************
* 函数名:    Van_Device_Printf
* 创建时间:  2021/04/22
* 创建人:    范义东
* 函数说明：调试打印接口函数
* 输入参数:   dev  传 NULL 采用本地定义
						devNum   数码
* 输出参数:   *name
* 返回值 :   void
****************************************************************/
void Van_Device_Printf(unsigned int printLevel, const char *cmd, ...)
{
	char buf[128] = {};
	int	 buflen			 = 0;

	if (gloublePrintLevel >= printLevel)
	{
		va_list args; //定义一个va_list类型的变量，用来储存单个参数
		va_start(args, cmd);	  //使args指向可变参数的第一个参数
		vsprintf(buf, cmd, args); //必须用vprintf等带V的
		va_end(args);			  //结束可变参数的获取
		buflen = strlen((const char *)buf);
		for(unsigned int i=0; i<buflen; i++){
			g_ucU3TX_Data[i] = buf[i];
		} 
	    if(buflen==0)return;
		while(DMA2CONbits.CHEN);		
		DMA2CNT=(buflen-1);
		DMA2CONbits.CHEN  = 1;		
		DMA2REQbits.FORCE = 1;		
	}
	return;
}

/*******************************************************************************
 * 函数名称：InitUart1
 *******************************************************************************/
void InitUart(void) {

    U1MODEbits.STSEL = 0;  
    U1MODEbits.PDSEL = 0;   
    U1MODEbits.BRGH = 0;    
    U1MODEbits.ABAUD = 0;  
    U1MODEbits.LPBACK = 0;  

    //    U1BRG = 31;       
    U1BRG = 389;           

    U1STAbits.UTXISEL0 = 1;
    U1STAbits.UTXISEL1 = 0;
    U1STAbits.URXISEL = 0;

    IEC0bits.U1TXIE = 0;
    IEC0bits.U1RXIE = 1;
    U1MODEbits.UARTEN = 1;
    U1STAbits.UTXEN = 1;
    IPC2bits.U1RXIP = 7;
    IPC3bits.U1TXIP = 7;
}


/*******************************************************************************
 * 函数名称：InitUart2
 *******************************************************************************/
void InitUart2(void) {

    U2MODEbits.STSEL = 0;  
    U2MODEbits.PDSEL = 0;   
    U2MODEbits.BRGH = 0;    
    U2MODEbits.ABAUD = 0;   
    U2MODEbits.LPBACK = 0;  

    //    U1BRG = 31;      
    U2BRG = 389;           

    U2STAbits.UTXISEL0 = 1;
    U2STAbits.UTXISEL1 = 0;
    U2STAbits.URXISEL = 0;

    IEC1bits.U2TXIE = 0;
    IEC1bits.U2RXIE = 1;
    U2MODEbits.UARTEN = 1;
    U2STAbits.UTXEN = 1;
    IPC7bits.U2RXIP = 7;
    IPC7bits.U2TXIP = 7;
}

/*******************************************************************************
 * 函数名称：InitUart3
 *******************************************************************************/
void InitUart3(void) {

    U3MODEbits.STSEL = 0;   
    U3MODEbits.PDSEL = 0;   
    U3MODEbits.BRGH = 0;    
    U3MODEbits.ABAUD = 0;  
    U3MODEbits.LPBACK = 0;  

    //    U1BRG = 31;       
    U3BRG = 31;            

    U3STAbits.UTXISEL0 = 1;
    U3STAbits.UTXISEL1 = 0;
    U3STAbits.URXISEL = 0;

    IEC5bits.U3TXIE = 0;
    IEC5bits.U3RXIE = 1;
    U3MODEbits.UARTEN = 1;
    U3STAbits.UTXEN = 1;
    IPC20bits.U3RXIP = 7;
    IPC20bits.U3TXIP = 7;
}
/*******************************************************************************
 * 函数名称：Uart1Send
 *******************************************************************************/
void UART1SEND(char data)
{
     U1TXREG = data;   
     while(!IFS0bits.U1TXIF);
     IFS0bits.U1TXIF=0;       		
}
/*******************************************************************************
 * 函数名称：_U1RXInterrupt
 *******************************************************************************/
void  __attribute__((__interrupt__,no_auto_psv)) _U1RXInterrupt(void)
{
	IFS0bits.U1RXIF = 0;                                                     
	g_ucU1RX_Data[g_uiUart1_No] = U1RXREG;                                 
    if(g_BUSY1 == 1) return;
    if(g_ucHeaderFlag1 == 0){                                             
		if(g_ucU1RX_Data[g_uiUart1_No] == FRAME_HEAD){                    
            g_ucHeaderFlag1 = 1;                                    
            g_ucU1RX_Data[0] = FRAME_HEAD;                                 
            g_uiUart1_No = 1;                                            
		}else{
            g_BUSY1 = 0;                                                  
        }
	}else if(g_ucHeaderFlag1 == 1){                                      
		g_uiUart1_No++;
    } 
    if(g_uiUart1_No > (FRAME_LTHH_INDEX+1)){                                                          
        g_uiLth1 = g_ucU1RX_Data[FRAME_LTHH_INDEX]; 
        if(g_uiUart1_No == g_uiLth1){                                       
            g_ulRSUM1 = Check(g_ucU1RX_Data,g_uiLth1-1);                     
            g_ucCRC1 = (unsigned char)g_ulRSUM1;                                //
            if(g_ucCRC1 == g_ucU1RX_Data[g_uiLth1-1]){                   
                g_ucCMD1 = g_ucU1RX_Data[FRAME_CMD_INDEX];                 
                g_ucUART1_flag  = 1;                                           
                g_ulRSUM1       = 0;                                       
                g_uiUart1_No    = 0;                                         
                g_ucHeaderFlag1 = 0;                                        
                g_BUSY1         = 1;                                       
            }else{
                memset(g_ucU1RX_Data,0,g_uiLth1*sizeof(unsigned char));        
                g_BUSY1 = 0;                                                 
            }        
        }else if(g_uiUart1_No > g_uiLth1){                                  
            g_uiUart1_No    = 0;                                          
            g_ucHeaderFlag1 = 0;                                          
            g_BUSY1         = 0;                                           
        }
    }
//    if(g_ucUART1_flag == 1)
//    {  
//        Uart1_Ack();                       
//    }
}
/*******************************************************************************
 * 函数名称：_U2RXInterrupt
 *******************************************************************************/
void  __attribute__((__interrupt__,no_auto_psv)) _U2RXInterrupt(void)
{
	IFS1bits.U2RXIF = 0;                                                  
	g_ucU1RX_Data[g_uiUart1_No] = U2RXREG;                                
    if(g_BUSY1 == 1) return;
    if(g_ucHeaderFlag1 == 0){                                          
		if(g_ucU1RX_Data[g_uiUart1_No] == FRAME_HEAD){                      
            g_ucHeaderFlag1 = 1;                                           
            g_ucU1RX_Data[0] = FRAME_HEAD;                            
            g_uiUart1_No = 1;                                              
		}else{
            g_BUSY1 = 0;                                                      
        }
	}else if(g_ucHeaderFlag1 == 1){                                   
		g_uiUart1_No++;
    } 
    if(g_uiUart1_No > (FRAME_LTHH_INDEX+1)){                                                        
        g_uiLth1 = g_ucU1RX_Data[FRAME_LTHH_INDEX]; 
        if(g_uiUart1_No == g_uiLth1){                                       
            g_ulRSUM1 = Check(g_ucU1RX_Data,g_uiLth1-1);                   
            g_ucCRC1 = (unsigned char)g_ulRSUM1;                            
            if(g_ucCRC1 == g_ucU1RX_Data[g_uiLth1-1]){                
                g_ucCMD1 = g_ucU1RX_Data[FRAME_CMD_INDEX];                  
                g_ucUART1_flag  = 1;                                        
                g_ulRSUM1       = 0;                                       
                g_uiUart1_No    = 0;                                        
                g_ucHeaderFlag1 = 0;                                   
                g_BUSY1         = 1;                                  
            }else{
                memset(g_ucU1RX_Data,0,g_uiLth1*sizeof(unsigned char));       
                g_BUSY1 = 0;                                                  
            }        
        }else if(g_uiUart1_No > g_uiLth1){                                 
            g_uiUart1_No    = 0;                                         
            g_ucHeaderFlag1 = 0;                                   
            g_BUSY1         = 0;                                   
        }
    }
}

/*******************************************************************************
 * 函数名称：_U3RXInterrupt
 *******************************************************************************/
void  __attribute__((__interrupt__,no_auto_psv)) _U3RXInterrupt(void)
{
	IFS5bits.U3RXIF = 0;                                                
	g_ucU1RX_Data[g_uiUart1_No] = U3RXREG;                               
    if(g_BUSY1 == 1) return;
    if(g_ucHeaderFlag1 == 0){                                             
		if(g_ucU1RX_Data[g_uiUart1_No] == FRAME_HEAD){                  
            g_ucHeaderFlag1 = 1;                                 
            g_ucU1RX_Data[0] = FRAME_HEAD;                             
            g_uiUart1_No = 1;                                        
		}else{
            g_BUSY1 = 0;                                                     
        }
	}else if(g_ucHeaderFlag1 == 1){                                          
		g_uiUart1_No++;
    } 
    if(g_uiUart1_No > (FRAME_LTHH_INDEX+1)){                                                           
        g_uiLth1 = g_ucU1RX_Data[FRAME_LTHH_INDEX]; 
        if(g_uiUart1_No == g_uiLth1){                                     
            g_ulRSUM1 = Check(g_ucU1RX_Data,g_uiLth1-1);                  
            g_ucCRC1 = (unsigned char)g_ulRSUM1;                                //
            if(g_ucCRC1 == g_ucU1RX_Data[g_uiLth1-1]){                 
                g_ucCMD1 = g_ucU1RX_Data[FRAME_CMD_INDEX];                    
                g_ucUART1_flag  = 1;                                 
                g_ulRSUM1       = 0;                             
                g_uiUart1_No    = 0;                             
                g_ucHeaderFlag1 = 0;                                
                g_BUSY1         = 1;                                    
            }else{
                memset(g_ucU1RX_Data,0,g_uiLth1*sizeof(unsigned char));      
                g_BUSY1 = 0;                                                 
            }        
        }else if(g_uiUart1_No > g_uiLth1){                                  
            g_uiUart1_No    = 0;                                             
            g_ucHeaderFlag1 = 0;                                        
            g_BUSY1         = 0;                                       
        }
    }
}

/*******************************************************************************
 * 函数名称：Check
 *******************************************************************************/
unsigned int Check(unsigned char *p,unsigned char num)
{
	unsigned char i=0;
    unsigned int uiCheckSum=0;
	for(i=0;i<num;i++){
		uiCheckSum += *p;
		p++;
	}
    return uiCheckSum;
}
/*******************************************************************************
 * 函数名称：RS1_Ack
 *******************************************************************************/
void RS1_Ack(unsigned int sendnum)
{
    unsigned int i;
	for(i=0;i<sendnum;i++){
        UART1SEND(g_ucU1TX_Data[i]);
	}
    memset(g_ucU1TX_Data,0,sendnum*sizeof(unsigned char));
}




/****************************************************************
* 函数名:    Van_Device_Printf
* 创建时间:  2021/04/22
* 创建人:    范义东
* 函数说明：调试打印接口函数
* 输入参数:   dev  传 NULL 采用本地定义
						devNum   数码
* 输出参数:   *name
* 返回值 :   void
****************************************************************/
void Van_Device_Printf_uart1(unsigned int printLevel, const char *cmd, ...)
{
	char buf[128] = {};
	int	 buflen			 = 0;

	if (gloublePrintLevel >= printLevel)
	{
		va_list args; //定义一个va_list类型的变量，用来储存单个参数
		va_start(args, cmd);	  //使args指向可变参数的第一个参数
		vsprintf(buf, cmd, args); //必须用vprintf等带V的
		va_end(args);			  //结束可变参数的获取
		buflen = strlen((const char *)buf);
		for(unsigned int i=0; i<buflen; i++){
			g_ucU1TX_Data[i] = buf[i];
		} 
	    if(buflen==0)return;
            while(DMA3CONbits.CHEN);        
            DMA3CNT=(buflen-1);
            DMA3CONbits.CHEN  = 1;		
            DMA3REQbits.FORCE = 1;		
	}
	return;
}

/*******************************************************************************
 * 函数名称：Uart1_Ack
 *******************************************************************************/
void Uart1_Ack(void)
{
    unsigned int g_uiFrmLth;               
    unsigned int i=0;                     
    unsigned int j=0;                  
    unsigned int n=0;            
    unsigned long sum;          
    unsigned char Flag_STATUS=0;          
    unsigned char Sensor,ucPWMindex,ucCtrlMode;  
    unsigned int ADC;
    long lMPPCtemp = 0;
    long lPWMstate=0;
    switch(g_ucCMD1){      
        /***********************(0x01)****************************/ 
        case HELLO:
            
            g_uiFrmLth = 6;                                        
            g_ucU1TX_Data[0] = FRAME_HEAD;
            g_ucU1TX_Data[1] = g_ucCMD1|0X80;
            g_ucU1TX_Data[2] = 0;
            g_ucU1TX_Data[3] = g_uiFrmLth & 0xff;                          
            g_ucU1TX_Data[4] = Flag_STATUS;                            
            g_ucU1TX_Data[5] = (unsigned char)Check(g_ucU1TX_Data,g_uiFrmLth-1);    
            while(DMA3CONbits.CHEN);        
            DMA3CNT=(g_uiFrmLth-1);
            DMA3CONbits.CHEN  = 1;		
            DMA3REQbits.FORCE = 1;	
            break;
        /*************************(0x02)***************************/   
        case PCR_SYSRST:
            
            g_uiFrmLth = 6;                                        
            g_ucU1TX_Data[0] = FRAME_HEAD;
            g_ucU1TX_Data[1] = g_ucCMD1|0X80;
            g_ucU1TX_Data[2] = 0;
            g_ucU1TX_Data[3] = g_uiFrmLth & 0xff;          
            g_ucU1TX_Data[4] = Flag_STATUS;  
            g_ucU1TX_Data[5] = (unsigned char)Check(g_ucU1TX_Data,g_uiFrmLth-1);         
            while(DMA3CONbits.CHEN);        
            DMA3CNT=(g_uiFrmLth-1);
            DMA3CONbits.CHEN  = 1;		
            DMA3REQbits.FORCE = 1;	
            break;
        /**********************(0x03)*****************************/    
        case PCR_SELFTEST:
   
            g_uiFrmLth = 6;
            g_ucU1TX_Data[0] = FRAME_HEAD;
            g_ucU1TX_Data[1] = g_ucCMD1 | 0X80;
            g_ucU1TX_Data[2] = 0;
            g_ucU1TX_Data[3] = g_uiFrmLth & 0xff;
            g_ucU1TX_Data[4] = 0x00; //
            g_ucU1TX_Data[5] = (unsigned char)Check(g_ucU1TX_Data,g_uiFrmLth-1);
            while(DMA3CONbits.CHEN);        
            DMA3CNT=(g_uiFrmLth-1);
            DMA3CONbits.CHEN  = 1;		
            DMA3REQbits.FORCE = 1;	
            break;
            
        /**************************(0x04)***************************/                    
        case PCR_DEV:       
            
            g_uiFrmLth = 6;
            g_ucU1TX_Data[0] = FRAME_HEAD;
            g_ucU1TX_Data[1] = g_ucCMD1|0X80;
            g_ucU1TX_Data[2] = 0;
            g_ucU1TX_Data[3] = g_uiFrmLth & 0xff;
            g_ucU1TX_Data[4] = Flag_STATUS;
            g_ucU1TX_Data[5] = (unsigned char)Check(g_ucU1TX_Data,g_uiFrmLth-1);     
            while(DMA3CONbits.CHEN);        
            DMA3CNT=(g_uiFrmLth-1);
            DMA3CONbits.CHEN  = 1;		
            DMA3REQbits.FORCE = 1;	
            break;
        /*************************(0x05)**************************/    
        case PCR_STATUS:
            
            g_uiFrmLth = 6;
            g_ucU1TX_Data[0] = FRAME_HEAD;
            g_ucU1TX_Data[1] = g_ucCMD1|0X80;
            g_ucU1TX_Data[2] = 0;
            g_ucU1TX_Data[3] = g_uiFrmLth & 0xff;
            g_ucU1TX_Data[4] = Flag_STATUS;
            g_ucU1TX_Data[5] = (unsigned char)Check(g_ucU1TX_Data,g_uiFrmLth-1);
            
            while(DMA3CONbits.CHEN);        
            DMA3CNT=(g_uiFrmLth-1);
            DMA3CONbits.CHEN  = 1;		
            DMA3REQbits.FORCE = 1;	
            break;
            
        /*************************(0x06)**************************/ 
        case SET_Temperature:             
            if(g_ucU1RX_Data[4] != 0xFF){                                 
                ucCtrlMode = 0;                                           
                ucCtrlMode = g_ucU1RX_Data[12];                       
                if(ucCtrlMode == 1){                               
                    g_ucENABLE = 0;                                 
                    TempChn[0].cPeltierRun = TempChn[1].cPeltierRun = TempChn[2].cPeltierRun = 0; 
                    TempChn[3].cPeltierRun = 0;                      
                }else{                                                     
                    g_ucENABLE = 1; 
                    Target_temp = g_ucU1RX_Data[4]; 
                    Target_temp = (Target_temp<<8) + g_ucU1RX_Data[5];        
                    g_dTarget_temp = (double)Target_temp /100.0;
                    if(g_dTarget_temp >= 130.0) g_dTarget_temp = 130.0;
                    if(g_dTarget_temp < 0)  g_dTarget_temp = 0;
                    for (i = 0; i < 4; i++) {
                        TempChn[i].cBlockTempAriv = 0;
                        TempChn[i].cPeltierRun = 1;
                        TempChn[i].fBlockTargetTemp = g_dTarget_temp;
                        if (fabs(TempChn[i].fCurrentTemperature - g_dTarget_temp) >= 0.3){                            
                            ScheduleOperate(i);                            
                        }
                    }   
                }
            }else{
                    for (i = 0; i < 4; i++) {
                        TempChn[i].cPeltierRun = 0;
                    }
            } 
            g_uiFrmLth = 6;
            g_ucU1TX_Data[0] = FRAME_HEAD;
            g_ucU1TX_Data[1] = g_ucCMD1|0X80;
            g_ucU1TX_Data[2] = 0;
            g_ucU1TX_Data[3] = g_uiFrmLth & 0xff;    
            g_ucU1TX_Data[4] = Flag_STATUS; 
            g_ucU1TX_Data[5] = (unsigned char)Check(g_ucU1TX_Data,g_uiFrmLth-1);
            while(DMA3CONbits.CHEN);        
            DMA3CNT=(g_uiFrmLth-1);
            DMA3CONbits.CHEN  = 1;		
            DMA3REQbits.FORCE = 1;	
            break;
        /***************************(0x78)**************************/ 
        case SET_ZLTemperature:             
            if(g_ucU1RX_Data[4] != 0xFF){                             
                ucCtrlMode = 0;                                        
                ucCtrlMode = g_ucU1RX_Data[12];                 
                if(ucCtrlMode == 1){                                       
                    g_ucENABLE = 0;                                      
                    TempChn[4].cPeltierRun = TempChn[5].cPeltierRun = 0;                    
                }else{                                                        
                    g_ucENABLE = 1; 
                    Target_temp = g_ucU1RX_Data[4]; 
                    Target_temp = (Target_temp<<8) + g_ucU1RX_Data[5];      
                    g_dTarget_temp = (double)Target_temp /100.0;
                    if(g_dTarget_temp >= 130.0) g_dTarget_temp = 130.0;
                    if(g_dTarget_temp < 0)  g_dTarget_temp = 0;
                    for (i = 4; i < 6; i++) {
                        TempChn[i].cBlockTempAriv = 0;
                        TempChn[i].cPeltierRun = 1;
                        TempChn[i].fBlockTargetTemp = g_dTarget_temp;
                        if (fabs(TempChn[i].fCurrentTemperature - g_dTarget_temp) >= 0.3){                            
                            ScheduleOperate(i);                            
                        }
                    }   
                }
            }else{
                    for (i = 4; i < 6; i++) {
                        TempChn[i].cPeltierRun = 0;
                    }
            } 
            g_uiFrmLth = 6;
            g_ucU1TX_Data[0] = FRAME_HEAD;
            g_ucU1TX_Data[1] = g_ucCMD1|0X80;
            g_ucU1TX_Data[2] = 0;
            g_ucU1TX_Data[3] = g_uiFrmLth & 0xff;    
            g_ucU1TX_Data[4] = Flag_STATUS; 
            g_ucU1TX_Data[5] = (unsigned char)Check(g_ucU1TX_Data,g_uiFrmLth-1);
            while(DMA3CONbits.CHEN);        
            DMA3CNT=(g_uiFrmLth-1);
            DMA3CONbits.CHEN  = 1;		
            DMA3REQbits.FORCE = 1;	
            break;            
        /****************************(0x07)*************************/  
        case PCR_MOTOR:
            PCR_MOTOR1 =  (g_ucU1RX_Data[4]&0xf0);                           
            PCR_MOTOR2 =  g_ucU1RX_Data[4]&0x0f;                                   
            if(PCR_MOTOR1 == 0x10 ){   
                switch(PCR_MOTOR2){                                             
                    case 6:g_lPulse = g_ucU1RX_Data[5];
                           g_lPulse = (g_lPulse<<8) + g_ucU1RX_Data[6];
                           g_lPulse = g_lPulse * 2;
                           ucMOTOR_DIR = g_ucU1RX_Data[7];             
                           uiSpeed = g_ucU1RX_Data[8];
                           uiSpeed = (uiSpeed<<8) + g_ucU1RX_Data[9];                     
                           MotorXMove(g_lPulse,ucMOTOR_DIR,uiSpeed);
                           break;       
                    case 7:g_lPulse = g_ucU1RX_Data[5];
                           g_lPulse = (g_lPulse<<8) + g_ucU1RX_Data[6];
                           g_lPulse = g_lPulse * 2;                           
                           ucMOTOR_DIR = g_ucU1RX_Data[7];             
                           uiSpeed = g_ucU1RX_Data[8];
                           uiSpeed = (uiSpeed<<8) + g_ucU1RX_Data[9];           
                           MotorXMove(g_lPulse,ucMOTOR_DIR,uiSpeed);
                           break;
                    case 3:
                           MotorXHome(g_tEE.uiXPulseHome,g_tEE.uiXSpeedHome,g_tEE.uiXSpeedLeave);                
                           HangHao=0;
                           break;              
                    case 10:g_lPulse = g_ucU1RX_Data[5];
                        g_lPulse = (g_lPulse << 8) + g_ucU1RX_Data[6];
                        g_lPulse = g_lPulse * 2;                        
                        uiSpeed = g_ucU1RX_Data[7];
                        uiSpeed = (uiSpeed << 8) + g_ucU1RX_Data[8];
                        MotorXMoveTo(g_lPulse, uiSpeed);
                        break;                 
                    case 5:    
                        g_lPulse = g_ucU1RX_Data[5];
                        g_lPulse = (g_lPulse << 8) + g_ucU1RX_Data[6];
                        g_lPulse = g_lPulse * 2;                        
                        ucMOTOR_DIR = g_ucU1RX_Data[7];
                        uiSpeed = g_ucU1RX_Data[8];
                        uiSpeed = (uiSpeed << 8) + g_ucU1RX_Data[9];
                        Alldata = 1;

                        MotorXScan(g_lPulse, ucMOTOR_DIR, uiSpeed);
                        MotorXMoveTo(0, uiSpeed);
                        MotorXHome(g_tEE.uiXPulseHome,g_tEE.uiXSpeedHome,g_tEE.uiXSpeedLeave);
//                        g_uiScanPulseX = 0;  
//                        Alldata = 0;
//                        IEC1bits.INT2IE = 0; 
//                        //数据处理
//                        
//                        for(i=0;i<17;i++){
//                            ulFAMAD_All = 0;
//                            ulVICAD_All = 0;
//                            ulROXAD_All = 0;
//                            ulCY5AD_All = 0;                    
//                            for(j=0;j<SUM1;j++){
//                                ulFAMAD_All += FAMData[i][j];
//                                ulVICAD_All += VICData[i][j];
//                                ulROXAD_All += ROXData[i][j];
//                                ulCY5AD_All += CY5Data[i][j];
//                            }
//                            g_fFAMAD_Max[i] = (float)(ulFAMAD_All/SUM1);
//                            g_fVICAD_Max[i] = (float)(ulVICAD_All/SUM1);
//                            g_fROXAD_Max[i] = (float)(ulROXAD_All/SUM1);
//                            g_fCY5AD_Max[i] = (float)(ulCY5AD_All/SUM1);
//                        }
//                            g_fQCFAM_Current = g_fFAMAD_Max[8];
//                            g_fQCVIC_Current = g_fVICAD_Max[8];
//                            g_fQCROX_Current = g_fROXAD_Max[8];
//                            g_fQCCY5_Current = g_fCY5AD_Max[8];
                         
                        for(i=0;i<17;i++){
                            ulFAMAD_All = 0;
                            ulVICAD_All = 0;
                            ulROXAD_All = 0;
                            ulCY5AD_All = 0; 
                                Bubble_Sort( &FAMData[i][15], 50);
                                Bubble_Sort( &VICData[i][15], 50);
                                Bubble_Sort( &ROXData[i][15], 50);
                                Bubble_Sort( &CY5Data[i][15], 50);
                                Bubble_Sort( &CY6Data[i][0], 50);
                                Bubble_Sort(&_390Data[i][0], 50);                            
                            for(j=18;j<(SUM1-18);j++){
                                ulFAMAD_All += FAMData[i][j];
                                ulVICAD_All += VICData[i][j];
                                ulROXAD_All += ROXData[i][j];
                                ulCY5AD_All += CY5Data[i][j];
                            }
                            g_fFAMAD_Max[i] = (float)(ulFAMAD_All/3);
                            g_fVICAD_Max[i] = (float)(ulVICAD_All/3);
                            g_fROXAD_Max[i] = (float)(ulROXAD_All/3);
                            g_fCY5AD_Max[i] = (float)(ulCY5AD_All/3);
                        }
                            g_fQCFAM_Current = g_fFAMAD_Max[8];
                            g_fQCVIC_Current = g_fVICAD_Max[8];
                            g_fQCROX_Current = g_fROXAD_Max[8];
                            g_fQCCY5_Current = g_fCY5AD_Max[8];                      
                            MotorXMoveTo(0, uiSpeed);
                            Alldata = 2;     
                            g_uiScanPulseX = 0;  

                        
                        break; 
                    case 11:
                           Alldata = 0;
                           DglLedbuf = 0;
                           FAMLED = 1;
                           g_lPulse = g_ucU1RX_Data[5];
                           g_lPulse = (g_lPulse<<8) + g_ucU1RX_Data[6];
                           g_lPulse = g_lPulse * 2;                           
                           ucMOTOR_DIR = g_ucU1RX_Data[7];            
                           uiSpeed = g_ucU1RX_Data[8];
                           uiSpeed = (uiSpeed<<8) + g_ucU1RX_Data[9];   
                           
                           MotorXScan(g_lPulse,ucMOTOR_DIR,uiSpeed);
                           Alldata = 2;  
                           FAMLED = 0;
                           break;
                           
                    case 12:
                           DglLedbuf = 0; 
                           Alldata = 0; 
                           VICLED = 1;
                           
                           g_lPulse = g_ucU1RX_Data[5];
                           g_lPulse = (g_lPulse<<8) + g_ucU1RX_Data[6]; 
                           g_lPulse = g_lPulse * 2;
                           ucMOTOR_DIR = g_ucU1RX_Data[7];           
                           uiSpeed = g_ucU1RX_Data[8];
                           uiSpeed = (uiSpeed<<8) + g_ucU1RX_Data[9];   
                           
                           MotorXScan(g_lPulse,ucMOTOR_DIR,uiSpeed);
                           Alldata = 2;   
                           VICLED = 0;
                           break;
                    case 13:
                           DglLedbuf = 0; 
                           Alldata = 0; 
                           ROXLED = 1;
                           g_lPulse = g_ucU1RX_Data[5];
                           g_lPulse = (g_lPulse<<8) + g_ucU1RX_Data[6]; 
                           g_lPulse = g_lPulse * 6;
                           ucMOTOR_DIR = g_ucU1RX_Data[7];             
                           uiSpeed = g_ucU1RX_Data[8];
                           uiSpeed = (uiSpeed<<8) + g_ucU1RX_Data[9];   
                           
                           MotorXScan(g_lPulse,ucMOTOR_DIR,uiSpeed);
                           Alldata = 2;   
                           ROXLED = 0;
                           break; 
                    case 14:
                           DglLedbuf = 0;
                           Alldata = 0; 
                           CY5LED = 1;
                           g_lPulse = g_ucU1RX_Data[5];
                           g_lPulse = (g_lPulse<<8) + g_ucU1RX_Data[6]; 
                           g_lPulse = g_lPulse * 2;
                           ucMOTOR_DIR = g_ucU1RX_Data[7];            
                           uiSpeed = g_ucU1RX_Data[8];
                           uiSpeed = (uiSpeed<<8) + g_ucU1RX_Data[9];   
                           
                           MotorXScan(g_lPulse,ucMOTOR_DIR,uiSpeed);
                           Alldata = 2;  
                           CY5LED = 0;
                           break;
                    case 15:
                           DglLedbuf = 0;  
                           Alldata = 0; 
                           CY6LED = 1;
                           g_lPulse = g_ucU1RX_Data[5];
                           g_lPulse = (g_lPulse<<8) + g_ucU1RX_Data[6];
                           g_lPulse = g_lPulse * 2;
                           ucMOTOR_DIR = g_ucU1RX_Data[7];             
                           uiSpeed = g_ucU1RX_Data[8];
                           uiSpeed = (uiSpeed<<8) + g_ucU1RX_Data[9];   
                           
                           MotorXScan(g_lPulse,ucMOTOR_DIR,uiSpeed);
                           Alldata = 2;  
                           CY6LED = 0;                           
                           break;     
                    case 9:
                           DglLedbuf = 0;  
                           Alldata = 0; 
                           _390LED = 1;
                           g_lPulse = g_ucU1RX_Data[5];
                           g_lPulse = (g_lPulse<<8) + g_ucU1RX_Data[6];
                           g_lPulse = g_lPulse * 2;
                           ucMOTOR_DIR = g_ucU1RX_Data[7];             
                           uiSpeed = g_ucU1RX_Data[8];
                           uiSpeed = (uiSpeed<<8) + g_ucU1RX_Data[9];   
                           
                           MotorXScan(g_lPulse,ucMOTOR_DIR,uiSpeed);
                           Alldata = 2;  
                           _390LED = 0;  
                           break;        
                    default:
                           break;
                }   
            }
            g_uiFrmLth = 6;
            g_ucU1TX_Data[0] = FRAME_HEAD;
            g_ucU1TX_Data[1] = g_ucCMD1|0X80;
            g_ucU1TX_Data[2] = 0x00;       
            g_ucU1TX_Data[3] = g_uiFrmLth;
            g_ucU1TX_Data[4] = Flag_STATUS; 
            g_ucU1TX_Data[5] = (unsigned char)Check(g_ucU1TX_Data,g_uiFrmLth-1);
            
            while(DMA3CONbits.CHEN);        
            DMA3CNT=(g_uiFrmLth-1);
            DMA3CONbits.CHEN  = 1;		
            DMA3REQbits.FORCE = 1;	
            break;
            
        /**************************(0x08)*****************************/   
        case PCR_LEDCTRL:          
            switch(g_ucU1RX_Data[4]){                                      
                case 1:                                                        
                    CTRLLED1=(g_ucU1RX_Data[5]&0x01)? 1:0; 
                    CTRLLED2=(g_ucU1RX_Data[5]&0x02)? 1:0; 
                    CTRLLED3=(g_ucU1RX_Data[5]&0x04)? 1:0; 
                    CTRLLED4=(g_ucU1RX_Data[5]&0x08)? 1:0;                   
                    CTRLLED5=(g_ucU1RX_Data[5]&0x10)? 1:0; 
                    CTRLLED6=(g_ucU1RX_Data[5]&0x20)? 1:0;
                    break;
                case 2:                                                   
                    DglLedbuf=g_ucU1RX_Data[5]&0x3f;
                    break;
                default:
                    break;
            }        
            g_uiFrmLth = 6;
            g_ucU1TX_Data[0] = FRAME_HEAD;
            g_ucU1TX_Data[1] = g_ucCMD1|0X80;
            g_ucU1TX_Data[2] = 0;
            g_ucU1TX_Data[3] = g_uiFrmLth & 0xff;
            g_ucU1TX_Data[4] = Flag_STATUS;
            g_ucU1TX_Data[5] = (unsigned char)Check(g_ucU1TX_Data,g_uiFrmLth-1);
            
            while(DMA3CONbits.CHEN);        
            DMA3CNT=(g_uiFrmLth-1);
            DMA3CONbits.CHEN  = 1;		
            DMA3REQbits.FORCE = 1;	
            break;
            /*********************(0x09)*************************/      
        case PCR_RDTEMP:

            g_ucRealTemp_Chanel = g_ucU1RX_Data[4];                   
            switch(g_ucRealTemp_Chanel){
                case 0:
//                    Real_temp[0] = (unsigned int)(TempChn[0].fCurrentTemperature*100.0);   
//                    g_ucRealTemp_Chanel = 0;
                    break;                   
                case 1:Real_temp[0] = (unsigned int)(TempChn[0].fCurrentTemperature*100.0);   
                       g_ucRealTemp_Chanel = 0;
                       break;
                case 2:Real_temp[1] = (unsigned int)(CAPReal_temp[0]*100.0);  
                       g_ucRealTemp_Chanel = 1;
                       break;
                case 3:Real_temp[2] = (unsigned int)(CAPReal_temp[1]*100.0);  
                       g_ucRealTemp_Chanel = 2;
                       break;
                case 4:Real_temp[3] = (unsigned int)(CAPReal_temp[0] * 100.0); 
                       g_ucRealTemp_Chanel = 3;
                       break;
                case 5:Real_temp[4] = (unsigned int)(g_fFINReal_Temp*100.0); 
                       g_ucRealTemp_Chanel = 4;
                       break;
                case 6:Real_temp[0] = (unsigned int)(TempChn[0].fCurrentTemperature*100.0);   
                       g_ucRealTemp_Chanel = 0;
                       break;
                case 7:Real_temp[0] = (unsigned int)(TempChn[0].fCurrentTemperature*100.0);   
                       g_ucRealTemp_Chanel = 0;
                       break;
                case 8:Real_temp[0] = (unsigned int)(TempChn[0].fCurrentTemperature*100.0);   
                       g_ucRealTemp_Chanel = 0;
                       break;
                default :
                    break;
            }        
            g_uiFrmLth = 9;
            g_ucU1TX_Data[0] = FRAME_HEAD;
            g_ucU1TX_Data[1] = g_ucCMD1|0X80;
            g_ucU1TX_Data[2] = 0;
            g_ucU1TX_Data[3] = g_uiFrmLth & 0xff;//桢长
            g_ucU1TX_Data[4] = Real_temp[g_ucRealTemp_Chanel]>>8;             
            g_ucU1TX_Data[5] = Real_temp[g_ucRealTemp_Chanel]&0x00ff;         
            g_ucU1TX_Data[6] = TempChn[g_ucRealTemp_Chanel].cTubeTempAriv;
            g_ucU1TX_Data[7] = Flag_STATUS;//状态位
            g_ucU1TX_Data[8] = (unsigned char)Check(g_ucU1TX_Data,g_uiFrmLth-1);
            
            while(DMA3CONbits.CHEN);        
            DMA3CNT=(g_uiFrmLth-1);
            DMA3CONbits.CHEN  = 1;		
            DMA3REQbits.FORCE = 1;	 
            break; 
            
        case PCR_RTPCREMP://0x10    
            g_ucRealTemp_Chanel = g_ucU1RX_Data[4];                  
            g_ucRealTemp_Chanel = 0;
            Real_temp[0] = (unsigned int)(TempChn[0].fCurrentTemperature*100.0); 
            
//            if((TempChn[0].cTubeTempAriv == 1)||(TempChn[1].cTubeTempAriv == 1)||(TempChn[2].cTubeTempAriv == 1)){
//                g_cTubeTempAriv = 1;
//            }else{
//                g_cTubeTempAriv = 0;
//            }
            g_uiFrmLth = 9;
            g_ucU1TX_Data[0] = FRAME_HEAD;
            g_ucU1TX_Data[1] = g_ucCMD1|0X80;
            g_ucU1TX_Data[2] = 0;
            g_ucU1TX_Data[3] = g_uiFrmLth & 0xff;//桢长
            g_ucU1TX_Data[4] = Real_temp[0]>>8;           
            g_ucU1TX_Data[5] = Real_temp[0]&0x00ff;   
            g_ucU1TX_Data[6] =TempChn[0].cTubeTempAriv;
            g_ucU1TX_Data[7] = Flag_STATUS;  //状态位
            g_ucU1TX_Data[8] = (unsigned char)Check(g_ucU1TX_Data,g_uiFrmLth-1);
            
            while(DMA3CONbits.CHEN);        
            DMA3CNT=(g_uiFrmLth-1);
            DMA3CONbits.CHEN  = 1;		
            DMA3REQbits.FORCE = 1;	
            break;                 
            /**********************(0x0A)************************/   
       case PCR_SETCAP://0x0A
         
            CAPPower = g_ucU1RX_Data[4];
            CAPPower = (CAPPower<<8) + g_ucU1RX_Data[5];
            
            if(g_ucU1RX_Data[4] == 0xFF){
                CAPTarget_temp[0] = g_tEE.CAPTarget_temp[0];
                CAPTarget_temp[1] = g_tEE.CAPTarget_temp[1]; 
            }
            else {
                if(CAPPower < 13000){
                   CAPTarget_temp[0] = CAPTarget_temp[1] = CAPPower/100;  
                }else{
                    
                }
                
            }           
                                   
            g_uiFrmLth = 6;
            g_ucU1TX_Data[0] = FRAME_HEAD;
            g_ucU1TX_Data[1] = g_ucCMD1|0X80;
            g_ucU1TX_Data[2] = 0;
            g_ucU1TX_Data[3] = g_uiFrmLth & 0xff;
            g_ucU1TX_Data[4] = 0;
            g_ucU1TX_Data[5] = (unsigned char)Check(g_ucU1TX_Data,g_uiFrmLth-1);
            
            while(DMA3CONbits.CHEN);        
            DMA3CNT=(g_uiFrmLth-1);
            DMA3CONbits.CHEN  = 1;		
            DMA3REQbits.FORCE = 1;	
            break;      
            /********************（0x0c）***********************/               
     case RD_PCRDATA://0x0C 
            g_ucPCRDATA_Chanel=g_ucU1RX_Data[4]; 
            ucBuffer_Data[0]=((g_ucCMD1|0x80)<<8)+FRAME_HEAD;
            ucBuffer_Data[1]=(ZLENTH1<<8)+0;//帧长+CMDNO，
            g_ucU1RX_Data[3]=0;
            
//            for(i=0;i<20;i++){
//                lMPPCtemp += g_uiMPPCtemp[i];
//            }           
            lMPPCtemp = AD_Get(0x0F);
//            if((MPPCALLtemp>60000)||((MPPCALLtemp<100)){                      
//            }
            HangHao=0;
            //FAM
            for(i=0;i<8;i++){
                g_fAD_Max[i] =  g_fFAMAD_Max[i];
            }
            for(i=8;i<16;i++){
                g_fAD_Max[i] =  g_fFAMAD_Max[i+1];     
            }
            for (i = 0; i < 16; i++) {
                if (g_tEE.uiQCbuffer == 0) { 
                    g_fAD_Max[i] = g_fAD_Max[i];
                } else if (g_tEE.uiQCbuffer == 1) {
                    if (g_fAD_Max[i] > g_tEE.FAM_MPPCB) {
                        g_fAD_Max[i] = g_fAD_Max[i] - g_tEE.FAM_MPPCB;    
                        g_fAD_Max[i] = g_fAD_Max[i] / (g_fQCFAM_Current / g_fQCFAM);
                        g_fAD_Max[i] = g_fAD_Max[i] + g_tEE.FAM_MPPCB;   
                    }else{ 
                        g_fAD_Max[i] = g_fAD_Max[i] / (g_fQCFAM_Current / g_fQCFAM);
                    }                     
                } else if (g_tEE.uiQCbuffer == 2) {
                    if (g_fAD_Max[i] > g_tEE.FAM_MPPCB) {
                        g_fAD_Max[i] = g_fAD_Max[i] - g_tEE.FAM_MPPCB;    
                        g_fAD_Max[i] = g_fAD_Max[i] / (g_tEE.FAM_MPPCTk1 * lMPPCtemp * lMPPCtemp + g_tEE.FAM_MPPCTk2 * lMPPCtemp + g_tEE.FAM_MPPCTb1); /*温度补偿*/
                        g_fAD_Max[i] = g_fAD_Max[i] + g_tEE.FAM_MPPCB;   
                    }else{ 
                        g_fAD_Max[i] = g_fAD_Max[i];
                    }    
                }else {
                }
                g_fAD_Max[i] = (g_tEE.fSFAMk[i] * g_fAD_Max[i] + g_tEE.sSFAMb[i]); 
                if (g_fAD_Max[i] > 60000)g_fAD_Max[i] = 60000;
                if (g_fAD_Max[i] < 20)g_fAD_Max[i] = 20;
                uiAD_Max[i] = (unsigned int) g_fAD_Max[i];
                
            }
           for(GlobalNum1=0;GlobalNum1<16;GlobalNum1++){
               ucBuffer_Data[2+ GlobalNum1] = uiAD_Max[GlobalNum1];//帧
               g_ucU1RX_Data[3] += ucBuffer_Data[2+GlobalNum1]>>8;
               g_ucU1RX_Data[3] += ucBuffer_Data[2+GlobalNum1]&0xff;
           }  
  
            for(i=0;i<8;i++){
                g_fAD_Max[i] =  g_fCY5AD_Max[i];
            }
            for(i=8;i<16;i++){  
                g_fAD_Max[i] =  g_fCY5AD_Max[i+1];     
            }            
            for (i = 0; i < 16; i++) {
                if (g_tEE.uiQCbuffer == 0) { 
                    g_fAD_Max[i] = g_fAD_Max[i];
                }
                else if (g_tEE.uiQCbuffer == 1) {
                    if (g_fAD_Max[i] > g_tEE.CY5_MPPCB) {
                        g_fAD_Max[i] = g_fAD_Max[i] - g_tEE.CY5_MPPCB;    
                        g_fAD_Max[i] = g_fAD_Max[i] / (g_fQCCY5_Current / g_fQCCY5);
                        g_fAD_Max[i] = g_fAD_Max[i] + g_tEE.CY5_MPPCB;   
                    }else{ 
                        g_fAD_Max[i] = g_fAD_Max[i] / (g_fQCCY5_Current / g_fQCCY5);
                    }                       
                }
                else if (g_tEE.uiQCbuffer == 2) {
                    if (g_fAD_Max[i] > g_tEE.CY5_MPPCB) {
                        g_fAD_Max[i] = g_fAD_Max[i] - g_tEE.CY5_MPPCB;    
                        g_fAD_Max[i] = g_fAD_Max[i] / (g_tEE.CY5_MPPCTk1 * lMPPCtemp * lMPPCtemp + g_tEE.CY5_MPPCTk2 * lMPPCtemp + g_tEE.CY5_MPPCTb1);
                        g_fAD_Max[i] = g_fAD_Max[i] + g_tEE.CY5_MPPCB;   
                    }else{ 
                        g_fAD_Max[i] = g_fAD_Max[i]; 
                    }    
                }
                else {
                }
                g_fAD_Max[i] = (g_tEE.fSCY5k[i] * g_fAD_Max[i] + g_tEE.sSCY5b[i]); 
                if (g_fAD_Max[i] > 60000)g_fAD_Max[i] = 60000;
                if (g_fAD_Max[i] < 20)g_fAD_Max[i] = 20;
                uiAD_Max[i] = (unsigned int) g_fAD_Max[i];
                
            }
            for(GlobalNum1=16;GlobalNum1<32;GlobalNum1++){
                ucBuffer_Data[2+GlobalNum1]=uiAD_Max[GlobalNum1-16];//帧
                g_ucU1RX_Data[3] += ucBuffer_Data[2+GlobalNum1]>>8;
                g_ucU1RX_Data[3] += ucBuffer_Data[2+GlobalNum1]&0xff;
            }
  
            for(i=0;i<8;i++){
                g_fAD_Max[i] =  g_fVICAD_Max[i];
            }
            for(i=8;i<16;i++){
                g_fAD_Max[i] =  g_fVICAD_Max[i+1];     
            }            
            for (i = 0; i < 16; i++) {
                if (g_tEE.uiQCbuffer == 0) {
                    g_fAD_Max[i] = g_fAD_Max[i];
                } else if (g_tEE.uiQCbuffer == 1) {
                    if (g_fAD_Max[i] > g_tEE.VIC_MPPCB) {
                        g_fAD_Max[i] = g_fAD_Max[i] - g_tEE.VIC_MPPCB;    
                        g_fAD_Max[i] = g_fAD_Max[i] / (g_fQCVIC_Current / g_fQCVIC);
                        g_fAD_Max[i] = g_fAD_Max[i] + g_tEE.VIC_MPPCB;   
                    }else{ 
                        g_fAD_Max[i] = g_fAD_Max[i] / (g_fQCVIC_Current / g_fQCVIC);
                    }                    
                } else if (g_tEE.uiQCbuffer == 2) {
                    if (g_fAD_Max[i] > g_tEE.VIC_MPPCB) {
                        g_fAD_Max[i] = g_fAD_Max[i] - g_tEE.VIC_MPPCB;    
                        g_fAD_Max[i] = g_fAD_Max[i] / (g_tEE.VIC_MPPCTk1 * lMPPCtemp * lMPPCtemp + g_tEE.VIC_MPPCTk2 * lMPPCtemp + g_tEE.VIC_MPPCTb1); 
                        g_fAD_Max[i] = g_fAD_Max[i] + g_tEE.VIC_MPPCB;   
                    }else{ 
                        g_fAD_Max[i] = g_fAD_Max[i];
                    }    
                }else {
                }
                g_fAD_Max[i] = (g_tEE.fSVICk[i] * g_fAD_Max[i] + g_tEE.sSVICb[i]); 
                if (g_fAD_Max[i] > 60000)g_fAD_Max[i] = 60000;
                if (g_fAD_Max[i] < 20)g_fAD_Max[i] = 20;
                uiAD_Max[i] = (unsigned int) g_fAD_Max[i];
                
            }
            for(GlobalNum1=32;GlobalNum1<48;GlobalNum1++){
                ucBuffer_Data[2+GlobalNum1]=uiAD_Max[GlobalNum1-32];//帧
                g_ucU1RX_Data[3] += ucBuffer_Data[2+GlobalNum1]>>8;
                g_ucU1RX_Data[3] += ucBuffer_Data[2+GlobalNum1]&0xff;
            }

            for(i=0;i<8;i++){
                g_fAD_Max[i] =  g_fROXAD_Max[i];
            }
            for(i=8;i<16;i++){//排序      
                g_fAD_Max[i] =  g_fROXAD_Max[i+1];     
            }            
            for (i = 0; i < 16; i++) {
                if (g_tEE.uiQCbuffer == 0) {
                    g_fAD_Max[i] = g_fAD_Max[i];
                } else if (g_tEE.uiQCbuffer == 1) {
                    if (g_fAD_Max[i] > g_tEE.ROX_MPPCB) {
                        g_fAD_Max[i] = g_fAD_Max[i] - g_tEE.ROX_MPPCB;    
                        g_fAD_Max[i] = g_fAD_Max[i] / (g_fQCROX_Current / g_fQCROX);
                        g_fAD_Max[i] = g_fAD_Max[i] + g_tEE.ROX_MPPCB;   
                    }else{ 
                        g_fAD_Max[i] = g_fAD_Max[i] / (g_fQCROX_Current / g_fQCROX);
                    }                    
                    
                } else if (g_tEE.uiQCbuffer == 2) {
                    if (g_fAD_Max[i] > g_tEE.ROX_MPPCB) {
                        g_fAD_Max[i] = g_fAD_Max[i] - g_tEE.ROX_MPPCB;    
                        g_fAD_Max[i] = g_fAD_Max[i] / (g_tEE.ROX_MPPCTk1 * lMPPCtemp * lMPPCtemp + g_tEE.ROX_MPPCTk2 * lMPPCtemp + g_tEE.ROX_MPPCTb1); 
                        g_fAD_Max[i] = g_fAD_Max[i] + g_tEE.ROX_MPPCB;   
                    }else{ 
                        g_fAD_Max[i] = g_fAD_Max[i]; 
                    }    
                }else {
                }
                g_fAD_Max[i] = (g_tEE.fSROXk[i] * g_fAD_Max[i] + g_tEE.sSROXb[i]); 
                if (g_fAD_Max[i] > 60000)g_fAD_Max[i] = 60000;
                if (g_fAD_Max[i] < 20)g_fAD_Max[i] = 20;
                uiAD_Max[i] = (unsigned int) g_fAD_Max[i];
                
            }
            for(GlobalNum1=48;GlobalNum1<55;GlobalNum1++){
                ucBuffer_Data[2+GlobalNum1]=uiAD_Max[GlobalNum1-48];//帧
                g_ucU1RX_Data[3] += ucBuffer_Data[2+GlobalNum1]>>8;
                g_ucU1RX_Data[3] += ucBuffer_Data[2+GlobalNum1]&0xff;
            } 
            
            if(g_ucMPPCtemp == 1){
                ucBuffer_Data[57] = (unsigned int)lMPPCtemp;
                g_ucU1RX_Data[3] += ucBuffer_Data[57]>>8;
                g_ucU1RX_Data[3] += ucBuffer_Data[57]&0xff;
            }else{
                ucBuffer_Data[57]=uiAD_Max[7];//帧
                g_ucU1RX_Data[3] += ucBuffer_Data[57]>>8;
                g_ucU1RX_Data[3] += ucBuffer_Data[57]&0xff;        
            }            

            for(GlobalNum1=56;GlobalNum1<64;GlobalNum1++){
                ucBuffer_Data[2+GlobalNum1]=uiAD_Max[GlobalNum1-48];//帧
                g_ucU1RX_Data[3] += ucBuffer_Data[2+GlobalNum1]>>8;
                g_ucU1RX_Data[3] += ucBuffer_Data[2+GlobalNum1]&0xff;
            }
            
            g_ucU1RX_Data[3] +=ucBuffer_Data[0]>>8;
            g_ucU1RX_Data[3] +=ucBuffer_Data[0]&0xff;
            g_ucU1RX_Data[3] +=ucBuffer_Data[1]>>8;
            g_ucU1RX_Data[3] +=ucBuffer_Data[1]&0xff;
            ucBuffer_Data[GlobalNum1+2]=g_ucU1RX_Data[3]<<8;         
                     
            memset( uiAD_Max,0,16*sizeof(unsigned int));
            
            while(DMA1CONbits.CHEN);
            DMA1CNT=(ucBuffer_Data[1]>>8)-1;
            DMA1CONbits.CHEN=1;
            DMA1REQbits.FORCE =1;
            
            break;              
        /***********************0x0d)******************************/            
        case PCR_PMT:
            MPPCPower = g_ucU1RX_Data[4];
            MPPCPower = (MPPCPower<<8) + g_ucU1RX_Data[5];
            
            Write_DAC(DA_FAM);
            Delay_ms(10);
            Write_DAC(DA_FAM);
            
            g_uiFrmLth  = 6;
            g_ucU1TX_Data[0] = FRAME_HEAD;
            g_ucU1TX_Data[1] = g_ucCMD1|0X80;
            g_ucU1TX_Data[2] = 0;
            g_ucU1TX_Data[3] = g_uiFrmLth & 0xff;
            g_ucU1TX_Data[4] = Flag_STATUS;  //状态位
            g_ucU1TX_Data[5] = (unsigned char)Check(g_ucU1TX_Data,g_uiFrmLth-1);           
            while(DMA3CONbits.CHEN);        
            DMA3CNT=(g_uiFrmLth-1);
            DMA3CONbits.CHEN  = 1;		
            DMA3REQbits.FORCE = 1;	
            break; 
            /**********************（0x0f）***********************/   
       case PCR_STALED:
            g_ucSTATE_RUN = g_ucU1RX_Data[4];
            
            if(g_ucSTATE_RUN == 2){
                CAPTarget_temp[0] = CAPTarget_temp[1] = g_tEE.CAPTemp_PCR;
//             
//                IEC1bits.INT2IE = 1;
                Alldata = 1;
                MotorXScan(g_tEE.uiXPulseScan * 2, 1, g_tEE.uiXSpeedScan);
                MotorXMoveTo(0, uiSpeed);
                MotorXHome(g_tEE.uiXPulseHome,g_tEE.uiXSpeedHome,g_tEE.uiXSpeedLeave); 
                Alldata = 2;
                
                ulAD_Max = 0;
                Bubble_Sort( &FAMData[8][15], 50);
                for(j=18;j<(SUM1-18);j++){
                        ulAD_Max += FAMData[8][j];
                }
                g_fQCFAM = (float)(ulAD_Max/3);               
                if(g_fQCFAM<100)g_fQCFAM = 100;
                if(g_fQCFAM>60000)g_fQCFAM = 60000;
                
                ulAD_Max = 0;   
                Bubble_Sort( &VICData[8][15], 50);
                for(j=18;j<(SUM1-18);j++){
                        ulAD_Max += VICData[8][j];
                }
                g_fQCVIC = (float)(ulAD_Max/3);
                if(g_fQCVIC<100)g_fQCVIC = 100;
                if(g_fQCVIC>60000)g_fQCVIC = 60000;
                
                ulAD_Max = 0;
                Bubble_Sort( &ROXData[8][15], 50);
                for(j=18;j<(SUM1-18);j++){
                        ulAD_Max += ROXData[8][j];
                }
                g_fQCROX = (float)(ulAD_Max/3);
                if(g_fQCROX<100)g_fQCROX = 100;
                if(g_fQCROX>60000)g_fQCROX = 60000;
                
                ulAD_Max = 0;      
                Bubble_Sort( &CY5Data[8][15], 50);
                for(j=18;j<(SUM1-18);j++){
                        ulAD_Max += CY5Data[8][j];
                }
                g_fQCCY5 = (float)(ulAD_Max/3);
                if(g_fQCCY5<100)g_fQCCY5 = 100;
                if(g_fQCCY5>60000)g_fQCCY5 = 60000;

                ulAD_Max = 0;  
                Bubble_Sort( &CY6Data[8][15], 50);
                for(j=18;j<(SUM1-18);j++){
                        ulAD_Max += CY6Data[8][j];
                }
                g_fQCCY6 = (float)(ulAD_Max/3);
                if(g_fQCCY6<100)g_fQCCY6 = 100;
                if(g_fQCCY6>60000)g_fQCCY6 = 60000;
                
    
            }
            else if(g_ucSTATE_RUN == 1){
                CAPTarget_temp[0] = g_tEE.CAPTarget_temp[0];
                CAPTarget_temp[1] = g_tEE.CAPTarget_temp[1]; 
               if(g_usEERadiatorOvertemp >= 60)g_usEERadiatorOvertemp = 60;
                if(g_usEERadiatorOvertemp < 20)g_usEERadiatorOvertemp = 20;    

                for (i = 0; i < 2; i++) {                
                    TempChn[i].fBlockTargetTemp = g_usEERadiatorOvertemp;
                    TempChn[i].cPeltierRun = 1;
                    ScheduleOperate(i);
                }                 
            }
             
            g_uiFrmLth = 6;
            g_ucU1TX_Data[0] = FRAME_HEAD;
            g_ucU1TX_Data[1] = g_ucCMD1|0X80;
            g_ucU1TX_Data[2] = 0;
            g_ucU1TX_Data[3] = g_uiFrmLth & 0xff;
            g_ucU1TX_Data[4] = Flag_STATUS;  //状态位
            g_ucU1TX_Data[5] = (unsigned char)Check(g_ucU1TX_Data,g_uiFrmLth-1);         
            while(DMA3CONbits.CHEN);        
            DMA3CNT=(g_uiFrmLth-1);
            DMA3CONbits.CHEN  = 1;		
            DMA3REQbits.FORCE = 1;	
            break;  
        /***************************(0x11)************************/  
        case READ_EEPROM:            
            uiEE_address = g_ucU1RX_Data[4];
            uiEE_address = (uiEE_address << 8) + g_ucU1RX_Data[5]; 
            uiEE_address = (uiEE_address << 8) + g_ucU1RX_Data[6];           
            GlobalTmp	 = g_ucU1RX_Data[7];
            
            for(i=0;i<GlobalTmp;i++){
                g_ucU1TX_Data[FRAME_LTHL_INDEX+i] = EE_read(uiEE_address+i);
            }
            g_uiFrmLth = GlobalTmp+6;
            g_ucU1TX_Data[0] = FRAME_HEAD;
            g_ucU1TX_Data[1] = g_ucCMD1|0X80;
            g_ucU1TX_Data[2] = 0;//地址
            g_ucU1TX_Data[3] =  g_uiFrmLth & 0xff;
            g_ucU1TX_Data[g_uiFrmLth-FRAME_STATE_INDEX-1] = Flag_STATUS;    
            g_ucU1TX_Data[g_uiFrmLth-FRAME_CRC_INDEX-1] = (unsigned char)Check(g_ucU1TX_Data,g_uiFrmLth-1);                       
            while(DMA3CONbits.CHEN);        
            DMA3CNT=(g_uiFrmLth-1);
            DMA3CONbits.CHEN  = 1;		
            DMA3REQbits.FORCE = 1;	
            break;           
        /***************************(0x12)*************************/  
        case WRITE_EEPROM:
            uiEE_address = g_ucU1RX_Data[4];                               
            uiEE_address = (uiEE_address << 8) + g_ucU1RX_Data[5]; 
            uiEE_address = (uiEE_address << 8) + g_ucU1RX_Data[6];
            if((uiEE_address >= 0x20)&&(uiEE_address < 0x40)){
                
            }else{
                GlobalTmp = g_ucU1RX_Data[3]-8;                                   
                for(i=0;i<GlobalTmp;i++){
                    EE_write(uiEE_address+i,g_ucU1RX_Data[7+i]);               
                    Delay_ms(10);
                }
                Read_Sys_EE(uiEE_address);
            }
            g_uiFrmLth = 6;
            g_ucU1TX_Data[0] = FRAME_HEAD;
            g_ucU1TX_Data[1] = g_ucCMD1|0X80;
            g_ucU1TX_Data[2] = 0;
            g_ucU1TX_Data[3] = g_uiFrmLth & 0xff;
            g_ucU1TX_Data[4] = Flag_STATUS;  //状态标志位
            g_ucU1TX_Data[5] = (unsigned char)Check(g_ucU1TX_Data,g_uiFrmLth-1);
                        
            while(DMA3CONbits.CHEN);        
            DMA3CNT=(g_uiFrmLth-1);
            DMA3CONbits.CHEN  = 1;		
            DMA3REQbits.FORCE = 1;	
            break;
        /**************************(0x15)**********************/     
        case PCR_RDSENSOR:
            
            g_uiFrmLth = 7;
            
            if(HOMEX==1)Sensor = 1;
            else        Sensor = 0;
            g_ucU1TX_Data[0] = FRAME_HEAD;
            g_ucU1TX_Data[1] = g_ucCMD1|0X80;
            g_ucU1TX_Data[2] = 0;
            g_ucU1TX_Data[3] = g_uiFrmLth & 0xff;
            g_ucU1TX_Data[4] = Sensor;
            g_ucU1TX_Data[5] = Flag_STATUS;  
            g_ucU1TX_Data[6] = (unsigned char)Check(g_ucU1TX_Data,g_uiFrmLth-1);
            
            while(DMA3CONbits.CHEN);        
            DMA3CNT=(g_uiFrmLth-1);
            DMA3CONbits.CHEN  = 1;		
            DMA3REQbits.FORCE = 1;
        /**************************(0x18)**********************/   
        case GET_MPPCAD:   
            
            
            memset( uiMppcADBuff,0,6*sizeof(unsigned int));
            
            uiMppcADBuff[0] =  AD_Get(0x09);     
            uiMppcADBuff[1] =  AD_Get(0x0B);            
            uiMppcADBuff[2] =  AD_Get(0x0A);             
            uiMppcADBuff[3] =  AD_Get(0x0C);        
            uiMppcADBuff[6] =  AD_Get(0x0F);         
            
            g_uiFrmLth = 20;
            g_ucU1TX_Data[0]  = FRAME_HEAD;
            g_ucU1TX_Data[1]  = g_ucCMD1|0X80;
            g_ucU1TX_Data[2]  = 0;
            g_ucU1TX_Data[3]  = g_uiFrmLth & 0xff;
            g_ucU1TX_Data[4]  = uiMppcADBuff[0] >> 8;
            g_ucU1TX_Data[5]  = (unsigned char) uiMppcADBuff[0];
            g_ucU1TX_Data[6]  = uiMppcADBuff[1] >> 8;
            g_ucU1TX_Data[7]  = (unsigned char) uiMppcADBuff[1];
            g_ucU1TX_Data[8]  = uiMppcADBuff[2] >> 8;
            g_ucU1TX_Data[9]  = (unsigned char) uiMppcADBuff[2];
            g_ucU1TX_Data[10] = uiMppcADBuff[3] >> 8;
            g_ucU1TX_Data[11] = (unsigned char) uiMppcADBuff[3];     
            g_ucU1TX_Data[12]  = uiMppcADBuff[4] >> 8;
            g_ucU1TX_Data[13]  = (unsigned char) uiMppcADBuff[4];
            g_ucU1TX_Data[14]  = uiMppcADBuff[5] >> 8;
            g_ucU1TX_Data[15]  = (unsigned char) uiMppcADBuff[5];
            g_ucU1TX_Data[16] = uiMppcADBuff[6] >> 8;
            g_ucU1TX_Data[17] = (unsigned char) uiMppcADBuff[6];             
            g_ucU1TX_Data[18] = Flag_STATUS; //状态位
            g_ucU1TX_Data[19] = (unsigned char)Check(g_ucU1TX_Data,g_uiFrmLth-1);   
            
            while(DMA3CONbits.CHEN);        
            DMA3CNT=(g_uiFrmLth-1);
            DMA3CONbits.CHEN  = 1;		
            DMA3REQbits.FORCE = 1;	
            break;  
        /*************************** (0x18)***********************/   
        case PCR_RDADC:          
            g_uiFrmLth = 24;
            g_ucU1TX_Data[0]  = FRAME_HEAD;
            g_ucU1TX_Data[1]  = g_ucCMD1|0X80;
            g_ucU1TX_Data[2]  = 0;
            g_ucU1TX_Data[3]  = g_uiFrmLth & 0xff;
            g_ucU1TX_Data[4]  = dTemperatureAD[0] >> 8;
            g_ucU1TX_Data[5]  = (unsigned char) dTemperatureAD[0];     
            g_ucU1TX_Data[6]  = dTemperatureAD[1] >> 8;
            g_ucU1TX_Data[7]  = (unsigned char) dTemperatureAD[1];    
            g_ucU1TX_Data[8]  = dTemperatureAD[2] >> 8;
            g_ucU1TX_Data[9]  = (unsigned char) dTemperatureAD[2];   
            g_ucU1TX_Data[10] = dTemperatureAD[3] >> 8;
            g_ucU1TX_Data[11] = (unsigned char) dTemperatureAD[3];  
            g_ucU1TX_Data[12] = dTemperatureAD[4] >> 8;
            g_ucU1TX_Data[13] = (unsigned char) dTemperatureAD[4];    
            g_ucU1TX_Data[14] = dTemperatureAD[5] >> 8;
            g_ucU1TX_Data[15] = (unsigned char) dTemperatureAD[5];    
            g_ucU1TX_Data[16] = dTemperatureAD[6] >> 8; 
            g_ucU1TX_Data[17] = (unsigned char) dTemperatureAD[6];   
            g_ucU1TX_Data[18] = dTemperatureAD[7] >> 8;
            g_ucU1TX_Data[19] = (unsigned char) dTemperatureAD[7];     
            g_ucU1TX_Data[20] = dTemperatureAD[8] >> 8;
            g_ucU1TX_Data[21] = (unsigned char) dTemperatureAD[8];          
            g_ucU1TX_Data[22] = Flag_STATUS; 
            g_ucU1TX_Data[23] = (unsigned char)Check(g_ucU1TX_Data,g_uiFrmLth-1);                        
            while(DMA3CONbits.CHEN);        
            DMA3CNT=(g_uiFrmLth-1);
            DMA3CONbits.CHEN  = 1;		
            DMA3REQbits.FORCE = 1;	
            break;            
        /***************************(0x18)***********************/   
//        case ADGET:       
//
//            ADC = AD_Get(g_ucU1RX_Data[4]);
//            
//            g_uiFrmLth = 8;
//            g_ucU1TX_Data[0]  = FRAME_HEAD;
//            g_ucU1TX_Data[1]  = g_ucCMD1|0X80;
//            g_ucU1TX_Data[2]  = 0;
//            g_ucU1TX_Data[3]  = g_uiFrmLth & 0xff;
//            g_ucU1TX_Data[4] = AD_Get(g_ucU1RX_Data[4]) >> 8;
//            g_ucU1TX_Data[5] = (unsigned char) AD_Get(g_ucU1RX_Data[4]);       
//            g_ucU1TX_Data[6] = Flag_STATUS; //状态位
//            g_ucU1TX_Data[7] = (unsigned char)Check(g_ucU1TX_Data,g_uiFrmLth-1);                        
//            while(DMA3CONbits.CHEN);        
//            DMA3CNT=(g_uiFrmLth-1);
//            DMA3CONbits.CHEN  = 1;		
//            DMA3REQbits.FORCE = 1;	
//            break;            
            
            
        /***************************(0x1C)***********************/    
        case PCR_FAN:           
            FanCount  = g_ucU1RX_Data[4];
            MPPCPower = g_ucU1RX_Data[5];
            MPPCPower = (MPPCPower<<8) + g_ucU1RX_Data[6];           
            FANOC_Set(FanCount,MPPCPower);            
            g_uiFrmLth = 6;
            g_ucU1TX_Data[0] = FRAME_HEAD;
            g_ucU1TX_Data[1] = g_ucCMD1|0X80;
            g_ucU1TX_Data[2] = 0;
            g_ucU1TX_Data[3] = g_uiFrmLth & 0xff;
            g_ucU1TX_Data[4] = Flag_STATUS;  //状态位
            g_ucU1TX_Data[5] = (unsigned char)Check(g_ucU1TX_Data,g_uiFrmLth-1);           
            while(DMA3CONbits.CHEN);        
            DMA3CNT=(g_uiFrmLth-1);
            DMA3CONbits.CHEN  = 1;		
            DMA3REQbits.FORCE = 1;	
            break;
        /**************************(0x44)***********************/   
        case QC_Data:          
            g_uiFrmLth = 14;
            g_ucU1TX_Data[0]  = FRAME_HEAD;
            g_ucU1TX_Data[1]  = g_ucCMD1|0X80;
            g_ucU1TX_Data[2]  = 0;
            g_ucU1TX_Data[3]  = g_uiFrmLth & 0xff;
            g_ucU1TX_Data[4]  = (unsigned int)g_fQCFAM_Current >> 8;
            g_ucU1TX_Data[5]  = (unsigned char) g_fQCFAM_Current;
            g_ucU1TX_Data[6]  = (unsigned int)g_fQCVIC_Current >> 8;
            g_ucU1TX_Data[7]  = (unsigned char) g_fQCVIC_Current;
            g_ucU1TX_Data[8]  = (unsigned int)g_fQCROX_Current >> 8;
            g_ucU1TX_Data[9]  = (unsigned char) g_fQCROX_Current;
            g_ucU1TX_Data[10] = (unsigned int)g_fQCCY5_Current >> 8;
            g_ucU1TX_Data[11] = (unsigned char) g_fQCCY5_Current;          
            g_ucU1TX_Data[12] = Flag_STATUS; //状态位
            g_ucU1TX_Data[13] = (unsigned char)Check(g_ucU1TX_Data,g_uiFrmLth-1);                        
            while(DMA3CONbits.CHEN);        
            DMA3CNT=(g_uiFrmLth-1);
            DMA3CONbits.CHEN  = 1;		
            DMA3REQbits.FORCE = 1;	
            break;            
            
            
        /***************************(0x1E)*************************/    
        case PCR_IO:         
            g_uiFrmLth = 6;           
            if(g_ucU1RX_Data[4] == 255){     
                g_ucENABLE = 0;
            }else if(g_ucU1RX_Data[4] == 254){
                g_ucENABLE = 1;
            }else{
                SetIO(g_ucU1RX_Data[4],g_ucU1RX_Data[5]);   
            }                     
            g_ucU1TX_Data[0] = FRAME_HEAD;
            g_ucU1TX_Data[1] = g_ucCMD1|0X80;
            g_ucU1TX_Data[2] = 0;
            g_ucU1TX_Data[3] = g_uiFrmLth & 0xff;
            g_ucU1TX_Data[4] = Flag_STATUS;  //状态位
            g_ucU1TX_Data[5] = (unsigned char)Check(g_ucU1TX_Data,g_uiFrmLth-1);           
            while(DMA3CONbits.CHEN);        
            DMA3CNT=(g_uiFrmLth-1);
            DMA3CONbits.CHEN  = 1;		
            DMA3REQbits.FORCE = 1;
            
            if(g_ucU1RX_Data[4] == 253){
                _RP97R  = 0x01;
                _U1RXR  = 0x6D;    
    			STU2 = 0; 
            }
            else if(g_ucU1RX_Data[4] == 252){
                _RP97R  = 0x01;
                _U1RXR  = 0x60;    
    			STU2 = 1;
            }
            else{}        
            
            
            break;            
        /*****************************（0xE0）***************************/
        case GET_IO:
            Get_IOstate = Get_IO(g_ucU1RX_Data[4]);
            g_uiFrmLth = 7;
            g_ucU1TX_Data[0] = FRAME_HEAD;
            g_ucU1TX_Data[1] = g_ucCMD1 | 0X80;
            g_ucU1TX_Data[2] = 0;
            g_ucU1TX_Data[3] = g_uiFrmLth; //
            g_ucU1TX_Data[4] = Get_IOstate; //获取的IO状态
            g_ucU1TX_Data[5] = Flag_STATUS; //状态位
            g_ucU1TX_Data[6] = (unsigned char) Check(g_ucU1TX_Data, g_uiFrmLth - 1);
            while (DMA3CONbits.CHEN);
            DMA3CNT = (g_uiFrmLth - 1);
            DMA3CONbits.CHEN = 1;
            DMA3REQbits.FORCE = 1;
            break;                 
        /************************** (0x31)*************************/
        case SET_PWM:       
            ucPWMindex = g_ucU1RX_Data[4];
            lPWMstate = g_ucU1RX_Data[5];
            lPWMstate = (lPWMstate << 8) + g_ucU1RX_Data[6];
            ucCtrlMode = g_ucU1RX_Data[7];
            if (ucCtrlMode == 0) {
                SetPWM(ucPWMindex, lPWMstate);
            } else if (ucCtrlMode == 1) {
                SetPWM(ucPWMindex, -lPWMstate);
            } else {}                                  
            g_uiFrmLth = 6;
            g_ucU1TX_Data[0] = FRAME_HEAD;
            g_ucU1TX_Data[1] = g_ucCMD1 | 0X80;
            g_ucU1TX_Data[2] = 0;
            g_ucU1TX_Data[3] = g_uiFrmLth;
            g_ucU1TX_Data[4] = 0x00; //状态位
            g_ucU1TX_Data[5] = (unsigned char) Check(g_ucU1TX_Data, g_uiFrmLth - 1);
            while(DMA3CONbits.CHEN);        
            DMA3CNT=(g_uiFrmLth-1);
            DMA3CONbits.CHEN  = 1;		
            DMA3REQbits.FORCE = 1;	
            break;
        /**************************(0x32)***********************/   
        case GET_PWM:          
            g_uiFrmLth = 18;
            g_ucU1TX_Data[0]  = FRAME_HEAD;
            g_ucU1TX_Data[1]  = g_ucCMD1|0X80;
            g_ucU1TX_Data[2]  = 0;
            g_ucU1TX_Data[3]  = g_uiFrmLth & 0xff;
            g_ucU1TX_Data[4]  = g_uiGetPWM[0] >> 8;
            g_ucU1TX_Data[5]  = (unsigned char) g_uiGetPWM[0];
            g_ucU1TX_Data[6]  = g_uiGetPWM[1] >> 8;
            g_ucU1TX_Data[7]  = (unsigned char) g_uiGetPWM[1];
            g_ucU1TX_Data[8]  = g_uiGetPWM[2] >> 8;
            g_ucU1TX_Data[9]  = (unsigned char) g_uiGetPWM[2];
            g_ucU1TX_Data[10] = g_uiGetPWM[3] >> 8;
            g_ucU1TX_Data[11] = (unsigned char) g_uiGetPWM[3];
            g_ucU1TX_Data[12] = g_uiGetPWM[4] >> 8;
            g_ucU1TX_Data[13] = (unsigned char) g_uiGetPWM[4];
            g_ucU1TX_Data[14] = g_uiGetPWM[5] >> 8;
            g_ucU1TX_Data[15] = (unsigned char) g_uiGetPWM[5];
            g_ucU1TX_Data[16] = Flag_STATUS; //状态位
            g_ucU1TX_Data[17] = (unsigned char)Check(g_ucU1TX_Data,g_uiFrmLth-1);                        
            while(DMA3CONbits.CHEN);        
            DMA3CNT=(g_uiFrmLth-1);
            DMA3CONbits.CHEN  = 1;		
            DMA3REQbits.FORCE = 1;	
            break;            
            /********************(0x25)**********************/   
       case PCR_TUBEMODE:
           
           
           
            g_uiFrmLth = 6;
            g_ucU1TX_Data[0] = FRAME_HEAD;
            g_ucU1TX_Data[1] = g_ucCMD1|0X80;
            g_ucU1TX_Data[2] = 0;
            g_ucU1TX_Data[3] = g_uiFrmLth & 0xff;
            g_ucU1TX_Data[4] = Flag_STATUS;  //状态位
            g_ucU1TX_Data[5] = (unsigned char)Check(g_ucU1TX_Data,g_uiFrmLth-1);           
            while(DMA3CONbits.CHEN);        
            DMA3CNT=(g_uiFrmLth-1);
            DMA3CONbits.CHEN  = 1;		
            DMA3REQbits.FORCE = 1;	
            break; 
            /**********************(0x26)***************************/   
        case PCR_INBOX: 
            
            g_uiFrmLth = 6;
            g_ucU1TX_Data[0] = FRAME_HEAD;
            g_ucU1TX_Data[1] = g_ucCMD1|0X80;
            g_ucU1TX_Data[2] = 0;
            g_ucU1TX_Data[3] = g_uiFrmLth & 0xff;
            g_ucU1TX_Data[4] = 0;  //状态位
            g_ucU1TX_Data[5] = (unsigned char)Check(g_ucU1TX_Data,g_uiFrmLth-1);        
            while(DMA3CONbits.CHEN);        
            DMA3CNT=(g_uiFrmLth-1);
            DMA3CONbits.CHEN  = 1;		
            DMA3REQbits.FORCE = 1;	
            break;

            /**********************(0x27)***************************/   
        case PCR_OUTBOX: 
            
            g_uiFrmLth = 6;
            g_ucU1TX_Data[0] = FRAME_HEAD;
            g_ucU1TX_Data[1] = g_ucCMD1|0X80;
            g_ucU1TX_Data[2] = 0;
            g_ucU1TX_Data[3] = g_uiFrmLth & 0xff;
            g_ucU1TX_Data[4] = 0;  //状态位
            g_ucU1TX_Data[5] = (unsigned char)Check(g_ucU1TX_Data,g_uiFrmLth-1);        
            while(DMA3CONbits.CHEN);        
            DMA3CNT=(g_uiFrmLth-1);
            DMA3CONbits.CHEN  = 1;		
            DMA3REQbits.FORCE = 1;	
            break;            
            
        case PCR_TEMP://0x43
            
            if((TempChn[0].cTubeTempAriv == 1)||(TempChn[1].cTubeTempAriv == 1)||(TempChn[2].cTubeTempAriv == 1)||(TempChn[3].cTubeTempAriv == 1)
                ){
                g_cTubeTempAriv = 1;
            }else{
                g_cTubeTempAriv = 0;
            } 
            g_uiFrmLth = 23;
            g_ucU1TX_Data[0]  = FRAME_HEAD;
            g_ucU1TX_Data[1]  = g_ucCMD1|0X80;
            g_ucU1TX_Data[2]  = 0;
            g_ucU1TX_Data[3]  = g_uiFrmLth & 0xff;
            g_ucU1TX_Data[4]  = (unsigned int)(TempChn[0].fCurrentTemperature*100.0) >> 8;
            g_ucU1TX_Data[5]  = (unsigned char) (TempChn[0].fCurrentTemperature*100.0);
            g_ucU1TX_Data[6]  = (unsigned int)(TempChn[1].fCurrentTemperature*100.0) >> 8;
            g_ucU1TX_Data[7]  = (unsigned char) (TempChn[1].fCurrentTemperature*100.0);
            g_ucU1TX_Data[8]  = (unsigned int)(TempChn[2].fCurrentTemperature*100.0) >> 8;
            g_ucU1TX_Data[9]  = (unsigned char) (TempChn[2].fCurrentTemperature*100.0);
            g_ucU1TX_Data[10] = (unsigned int)(TempChn[3].fCurrentTemperature*100.0) >> 8;
            g_ucU1TX_Data[11] = (unsigned char) (TempChn[3].fCurrentTemperature*100.0);
            g_ucU1TX_Data[12] = (unsigned int)(TempChn[4].fCurrentTemperature*100.0) >> 8;
            g_ucU1TX_Data[13] = (unsigned char) (TempChn[4].fCurrentTemperature*100.0);
            g_ucU1TX_Data[14] = (unsigned int)(TempChn[5].fCurrentTemperature*100.0) >> 8;
            g_ucU1TX_Data[15] = (unsigned char) (TempChn[5].fCurrentTemperature*100.0);
            g_ucU1TX_Data[16] = (unsigned int)(TempChn[5].fCurrentTemperature*100.0) >> 8;
            g_ucU1TX_Data[17] = (unsigned char) (TempChn[5].fCurrentTemperature*100.0);
            g_ucU1TX_Data[18] = (unsigned int)(TempChn[5].fCurrentTemperature*100.0) >> 8;
            g_ucU1TX_Data[19] = (unsigned char) (TempChn[5].fCurrentTemperature*100.0);            
            g_ucU1TX_Data[20] = g_cTubeTempAriv;
            g_ucU1TX_Data[21] = Flag_STATUS; //状态位
            g_ucU1TX_Data[22] = (unsigned char) Check(g_ucU1TX_Data, g_uiFrmLth - 1);
                        
            while(DMA3CONbits.CHEN);        
            DMA3CNT=(g_uiFrmLth-1);
            DMA3CONbits.CHEN  = 1;		
            DMA3REQbits.FORCE = 1;	
            break;            
            /***************(0x28)*********************/   
        case PCR_STATEBIT://0x28 

            g_uiFrmLth = 8;
            g_ucU1TX_Data[0] = FRAME_HEAD;
            g_ucU1TX_Data[1] = g_ucCMD1|0X80;
            g_ucU1TX_Data[2] = 0;
            g_ucU1TX_Data[3] = g_uiFrmLth & 0xff;
            g_ucU1TX_Data[4] = 0x00;
            g_ucU1TX_Data[5] = 0x00;
            g_ucU1TX_Data[6] = Flag_STATUS;  //状态位
            g_ucU1TX_Data[7] = (unsigned char)Check(g_ucU1TX_Data,g_uiFrmLth-1);
            
            while(DMA3CONbits.CHEN);        
            DMA3CNT=(g_uiFrmLth-1);
            DMA3CONbits.CHEN  = 1;		
            DMA3REQbits.FORCE = 1;	
            break;   
            /*********************（0xFF）***********************/   
        case RD_PCRALLDATA: 
            ucBuffer_Data[0]=((g_ucCMD1|0x80)<<8)+FRAME_HEAD;                                                                                
            ucBuffer_Data[1]=(ZLENTH2<<8)+0;
            g_ucU1RX_Data[3]=0;
            BTvar.ucScanNum = 0;          
            if(g_ucU1RX_Data[4] == 1){
                SampleTransNo = 0;
                for(i = 0;i<6748;i++){
                     ucBuffer_Data[i+2]  = ((ucBuffer_Data[i+2]<< 8) + (ucBuffer_Data[i+2]>> 8));
                }
                ucBuffer_Data[2] = 0;
                for(GlobalNum1=0;GlobalNum1<(ZLENTH2/2-3);GlobalNum1++){
                    g_ucU1RX_Data[3] += ucBuffer_Data[2+GlobalNum1]>>8;
                    g_ucU1RX_Data[3] += ucBuffer_Data[2+GlobalNum1]&0xff;
                }
            }
            else {
                SampleTransNo ++;
                for(GlobalNum1=0;GlobalNum1<(ZLENTH2/2-3);GlobalNum1++){
                    ucBuffer_Data[2+GlobalNum1]=ucBuffer_Data[SampleTransNo * (ZLENTH2/2-3)+GlobalNum1];//帧
                    g_ucU1RX_Data[3] += ucBuffer_Data[2+GlobalNum1]>>8;
                    g_ucU1RX_Data[3] += ucBuffer_Data[2+GlobalNum1]&0xff;
                }
            }
            g_ucU1RX_Data[3] +=ucBuffer_Data[0]>>8;
            g_ucU1RX_Data[3] +=ucBuffer_Data[0]&0xff;
            g_ucU1RX_Data[3] +=ucBuffer_Data[1]>>8;
            g_ucU1RX_Data[3] +=ucBuffer_Data[1]&0xff;
            ucBuffer_Data[GlobalNum1+2]=(g_ucU1RX_Data[3]<<8);//低位先发送,错误       
            while(DMA1CONbits.CHEN);
            DMA1CNT=(ucBuffer_Data[1]>>8)-1;
            DMA1CONbits.CHEN  = 1;
            DMA1REQbits.FORCE = 1;
            
            break;            
            /********************（0xFE）***********************/   
        case RD_ALLDATAMAX: 
            
            ucBuffer_Data[0]=((g_ucCMD1|0x80)<<8)+FRAME_HEAD;                                                                                
            ucBuffer_Data[1]=(ZLENTH2<<8)+0;
            g_ucU1RX_Data[3]=0;
            
            if(g_ucU1RX_Data[4] == 1){
                SampleTransNo = 0;
                n = 0;
                if(g_ucU1RX_Data[5] == 1){
                    for(i = 0;i<17;i++){
                        for(j = 0;j<SUM1;j++){
                             Alldata_Max[n]  = ((FAMData[i][j]<< 8) + (FAMData[i][j]>> 8));
                             n++;
                        }               
                    }                    
                }
                else if(g_ucU1RX_Data[5] == 2){
                    for(i = 0;i<17;i++){
                        for(j = 0;j<SUM1;j++){
                             Alldata_Max[n]  = ((VICData[i][j]<< 8) + (VICData[i][j]>> 8));
                             n++;
                        }               
                    }                    
                }
                else if(g_ucU1RX_Data[5] == 3){
                    for(i = 0;i<17;i++){
                        for(j = 0;j<SUM1;j++){
                             Alldata_Max[n]  = ((ROXData[i][j]<< 8) + (ROXData[i][j]>> 8));
                             n++;
                        }               
                    }                    
                }
                else if(g_ucU1RX_Data[5] == 4){
                    for(i = 0;i<17;i++){
                        for(j = 0;j<SUM1;j++){
                             Alldata_Max[n]  = ((CY5Data[i][j]<< 8) + (CY5Data[i][j]>> 8));
                             n++;
                        }               
                    }                    
                }
            }
            else SampleTransNo ++;
            for(GlobalNum1=0;GlobalNum1<ZLENTH2/2-3;GlobalNum1++){
                ucBuffer_Data[2+GlobalNum1]=Alldata_Max[SampleTransNo * (ZLENTH2/2-3)+GlobalNum1];//帧
                g_ucU1RX_Data[3] += ucBuffer_Data[2+GlobalNum1]>>8;
                g_ucU1RX_Data[3] += ucBuffer_Data[2+GlobalNum1]&0xff;
            }

            g_ucU1RX_Data[3] +=ucBuffer_Data[0]>>8;
            g_ucU1RX_Data[3] +=ucBuffer_Data[0]&0xff;
            g_ucU1RX_Data[3] +=ucBuffer_Data[1]>>8;
            g_ucU1RX_Data[3] +=ucBuffer_Data[1]&0xff;
            ucBuffer_Data[GlobalNum1+2]=(g_ucU1RX_Data[3]<<8);
           
            while(DMA1CONbits.CHEN);
            DMA1CNT=(ucBuffer_Data[1]>>8)-1;
            DMA1CONbits.CHEN  = 1;                                           
            DMA1REQbits.FORCE = 1;
            
            break;
            /****************(0x66)*********************/   
        case BT_Protocol://

            BTvar.ucStepNum = g_ucU1RX_Data[5];
   
            for (i = 0; i < BTvar.ucStepNum; i++) {
                BTStep[i].Temp_Start = (g_ucU1RX_Data[i * 10 + 6] << 8) + g_ucU1RX_Data[i * 10 + 7];
                BTStep[i].Temp_End   = (g_ucU1RX_Data[i * 10 + 8] << 8) + g_ucU1RX_Data[i * 10 + 9]; 
                BTStep[i].Duration   = (g_ucU1RX_Data[i * 10 + 10] << 8) + g_ucU1RX_Data[i * 10 + 11]; 
                BTStep[i].Cycle  =  g_ucU1RX_Data[i * 10 + 12]; 
                if(BTStep[i].Cycle == 0)
                
                BTStep[i].Mode   =  g_ucU1RX_Data[i * 10 + 13]; 
                BTStep[i].Point  =  g_ucU1RX_Data[i * 10 + 14]; 
                BTStep[i].Goto   =  g_ucU1RX_Data[i * 10 + 15]; 
            }
            BTvar.ucStartbuffer = 1;
            BTvar.ucQCbuffer = 1;
            
            g_uiFrmLth = 8;
            g_ucU1TX_Data[0] = FRAME_HEAD;
            g_ucU1TX_Data[1] = g_ucCMD1|0X80;
            g_ucU1TX_Data[2] = 0;
            g_ucU1TX_Data[3] = g_uiFrmLth & 0xff;
            g_ucU1TX_Data[4] = 0x00;
            g_ucU1TX_Data[5] = 0x00;
            g_ucU1TX_Data[6] = Flag_STATUS;  //状态位
            g_ucU1TX_Data[7] = (unsigned char)Check(g_ucU1TX_Data,g_uiFrmLth-1);
            
            while(DMA3CONbits.CHEN);        
            DMA3CNT=(g_uiFrmLth-1);
            DMA3CONbits.CHEN  = 1;		
            DMA3REQbits.FORCE = 1;	
            break; 

            
        default:
            break;
             
    }
    g_ucUART1_flag  = 0;
    g_uiUart1_No    = 0;
    g_ucHeaderFlag1 = 0;
    memset(g_ucU1RX_Data,0,g_uiLth1*sizeof(unsigned char));
    g_BUSY1 = 0;
}


uint32_t m_pow_n(uint32_t m, uint32_t n)
{
    uint32_t i = 0, ret = 1;
    if (n < 0) return 0;
    for (i = 0; i < n; i++)
    {
        ret *= m;
    }
    return ret;
}
void my_send_char(char ch){
 	 g_ucU3TX_buf[g_ucU3TX_Last++] = ch;
}

// 返回值为打印字符的个数
// 支持%d，%o, %x，%s，%c，%f（只打印6位数字）
//int my_printf(const char* str, ...)
//{
//    if (str == NULL) return -1;
//
//	uint32_t ret_num = 0;// 返回打印字符的个数
//    char* pStr = (char*)str;// 指向str
//    int ArgIntVal = 0;  // 接收整型
//    uint32_t ArgHexVal = 0;// 接十六进制
//    char* ArgStrVal = NULL;  // 接收字符型
//    double ArgFloVal = 0.0; // 接受浮点型
//    uint32_t val_seg = 0;   // 数据切分
//    uint32_t val_temp = 0;  // 临时保存数据
//    int cnt = 0;       // 数据长度计数
//    int cnt_float = 0;       // 数据长度计数
//    int i = 0;
//    
//    va_list pArgs; // 定义va_list类型指针，用于存储参数的地址
//    va_start(pArgs, str); // 初始化pArgs
//    if(g_ucU3TX_Last > 0){
//		return 0;
//	}
//    while (*pStr != '\0')
//    {
//        switch (*pStr)
//        {
//        case ' ':
//        case '\r':
//        case '\n':
//            my_send_char(*pStr); ret_num++; break;
//        case '\t':
//            my_send_char(*pStr); ret_num += 4; break;
//        case '%':
//            pStr++;
//            // % 格式解析
//
//			if('.' == *pStr)
//			{
//            	pStr++;
//				cnt_float = *pStr - '0';// %.Nf，输出指定位数小数
//                pStr++;
//			}
//			
//            switch (*pStr)
//            {
//            case '%':
//                my_send_char('%');// %%，输出%
//                ret_num++;
//                pStr++;
//				continue;
//            case 'c':
//                ArgIntVal = va_arg(pArgs, int);// %c，输出char
//                my_send_char((char)ArgIntVal);
//                ret_num++;
//                pStr++;
//				continue;
//            case 'd':
//                // 接收整型
//                ArgIntVal = va_arg(pArgs, int);
//                if (ArgIntVal < 0)// 如果为负数打印，负号
//                {
//                    ArgIntVal = -ArgIntVal;// 取相反数
//
//                    my_send_char('-');
//                    ret_num++;
//                }
//                val_seg = ArgIntVal;// 赋值给 val_seg处理数据
//                // 计算ArgIntVal长度
//                if (ArgIntVal)
//                {
//                    while (val_seg) {
//                        cnt++;
//                        val_seg /= 10;
//                    }
//                }
//                else cnt = 1;// 数字0的长度为1
//
//                ret_num += cnt;// 字符个数加上整数的长度
//
//                // 将整数转为单个字符打印
//                while (cnt)
//                {
//                    val_seg = ArgIntVal / m_pow_n(10, cnt - 1);
//                    ArgIntVal %= m_pow_n(10, cnt - 1);
//                    my_send_char((char)val_seg + '0');
//                    cnt--;
//                }
//                pStr++;
//                continue;
//            case 'o':
//                // 接收整型
//                ArgIntVal = va_arg(pArgs, int);
//                if (ArgIntVal < 0)// 如果为负数打印，负号
//                {
//                    ArgIntVal = -ArgIntVal;// 取相反数
//
//                    my_send_char('-');
//                    ret_num++;
//                }
//                val_seg = ArgIntVal;// 赋值给 val_seg处理数据
//                // 计算ArgIntVal长度
//                if (ArgIntVal)
//                {
//                    while (val_seg) {
//                        cnt++;
//                        val_seg /= 8;
//                    }
//                }
//                else cnt = 1;// 数字0的长度为1
//
//                ret_num += cnt;// 字符个数加上整数的长度
//
//                // 将整数转为单个字符打印
//                while (cnt)
//                {
//                    val_seg = ArgIntVal / m_pow_n(8, cnt - 1);
//                    ArgIntVal %= m_pow_n(8, cnt - 1);
//                    my_send_char((char)val_seg + '0');
//                    cnt--;
//                }
//                pStr++;
//				continue;
//            case 'x':
//                // 接收16进制
//                ArgHexVal = va_arg(pArgs, uint32_t);
//                val_seg = ArgHexVal;
//                // 计算ArgIntVal长度
//                if (ArgHexVal)
//                {
//                    while (val_seg) {
//                        cnt++;
//                        val_seg /= 16;
//                    }
//                }
//                else cnt = 1;// 数字0的长度为1
//
//                ret_num += cnt;// 字符个数加上整数的长度
//                // 将整数转为单个字符打印
//                while (cnt)
//                {
//                    val_seg = ArgHexVal / m_pow_n(16, cnt - 1);
//                    ArgHexVal %= m_pow_n(16, cnt - 1);
//                    if (val_seg <= 9)
//                        my_send_char((char)val_seg + '0');
//                    else
//                    {
//						//my_send_char((char)val_seg - 10 + 'a'); //小写字母
//                        my_send_char((char)val_seg - 10 + 'A');
//                    }
//                    cnt--;
//                }
//                pStr++;
//				continue;
//            case 'b':
//                // 接收整型
//                ArgIntVal = va_arg(pArgs, int);
//                val_seg = ArgIntVal;
//                // 计算ArgIntVal长度
//                if (ArgIntVal)
//                {
//                    while (val_seg) {
//                        cnt++;
//                        val_seg /= 2;
//                    }
//                }
//                else cnt = 1;// 数字0的长度为1
//
//                ret_num += cnt;// 字符个数加上整数的长度
//                // 将整数转为单个字符打印
//                while (cnt)
//                {
//                    val_seg = ArgIntVal / m_pow_n(2, cnt - 1);
//                    ArgIntVal %= m_pow_n(2, cnt - 1);
//                    my_send_char((char)val_seg + '0');
//                    cnt--;
//                }
//                pStr++;
//				continue;
//            case 's':
//                // 接收字符
//                ArgStrVal = va_arg(pArgs, char*);
//                ret_num += (uint32_t)strlen(ArgStrVal);
//                while (*ArgStrVal)
//                {
//                    my_send_char(*ArgStrVal);
//                    ArgStrVal++;
//                }
//
//                pStr++;
//				continue;
//
//            case 'f':
//                // 接收浮点型 保留6为小数，不采取四舍五入
//                ArgFloVal = va_arg(pArgs, double);
//				
//                if (ArgFloVal < 0)// 如果为负数打印，负号
//                {
//                    ArgFloVal = -ArgFloVal;// 取相反数
//
//                    my_send_char('-');
//                    ret_num++;
//                }
//                val_seg = (uint32_t)ArgFloVal;// 取整数部分
//                val_temp = val_seg;      // 临时保存整数部分数据
//                ArgFloVal = ArgFloVal - val_seg;// 得出余下的小数部分
//                // 计算整数部分长度
//                if (val_seg)
//                {
//                    while (val_seg) {
//                        cnt++;
//                        val_seg /= 10;
//                    }
//                }
//                else cnt = 1;// 数字0的长度为1
//                ret_num += cnt;// 字符个数加上整数的长度
//                // 将整数转为单个字符打印
//                while (cnt)
//                {
//                    val_seg = val_temp / m_pow_n(10, cnt - 1);
//                    val_temp %= m_pow_n(10, cnt - 1);
//                    my_send_char((char)val_seg + '0');
//                    cnt--;
//                }
//                // 打印小数点
//                my_send_char('.');
//                ret_num++;
//                // printf("\r\n %f\r\n", ArgFloVal);
//				if(cnt_float == 0)
//                	cnt_float = 6;
//					
//                // 开始输出小数部分
//                //ArgFloVal *= 1000000;
//                ArgFloVal *= m_pow_n(10, cnt_float);
//
//                val_temp = (int)ArgFloVal;// 取整数部分
//                while (cnt_float)
//                {
//                    val_seg = val_temp / m_pow_n(10, cnt_float - 1);
//                    val_temp %= m_pow_n(10, cnt_float - 1);
//                    my_send_char((char)val_seg + '0');
//                    cnt_float--;
//                }
//                ret_num += 6;
//                pStr++;
//				continue;
//            default:// % 匹配错误，暂输出空格
//				my_send_char(' '); ret_num++;
//				break;
//            }
//			break;
//
//
//        default:
//            my_send_char(*pStr); ret_num++;
//            break;
//        }
//        pStr++;
//    }
//    va_end(pArgs);// 结束取参数
//
//	for(int i;i<ret_num;i++){
//		g_ucU3TX_Data[i] = g_ucU3TX_buf[i];
//	}
//	g_ucU3TX_Last = 0;
//    while(DMA2CONbits.CHEN);        
//    DMA2CNT=(ret_num-1);
//    DMA2CONbits.CHEN  = 1;		
//    DMA2REQbits.FORCE = 1;	
//
//    
//    return ret_num;
//}