NewMNFJ/source/user/mapp_arm.c

//==================================================================
//
//	Filename: mapp_arm.c
//	Description: arm driver
//
//------------------------------------------------------------------
//
// version:
// date: 23:54pm, 08.Apr.2012, by Sirius
//	Description:
//
//------------------------------------------------------------------
//==================================================================
/*------------------------------------------------------------------------------
 *						I N C L U D E
 *------------------------------------------------------------------------------*/
//#include <string.h>
#include "stm32f0xx.h"
#include "general.h"
#include "mapp_can.h"
#include "mapp_msg.h"
#include "mapp_uart1.h"
#include "main.h"
#include "mapp_ext.h"
#include "mapp_arm.h"
#include "mapp_ami.h"
#include "mapp_pwr.h"
#include "mapp_gpio.h"
#include "mapp_key.h"
#include "sx1276_7_8.h"

/*------------------------------------------------------------------------------
 *						D E F I N E
 *------------------------------------------------------------------------------*/
#define ARM_TX_BUF_LEN       (40)
#define ARM_RX_BUF_LEN       (30)



/*------------------------------------------------------------------------------
 *						S T R U C T
 *------------------------------------------------------------------------------*/
 const U08   HEARTSTR[]="$HEART";
           


/*------------------------------------------------------------------------------
 *						S T A T I C - V A R I A B L E S
 *------------------------------------------------------------------------------*/
//static U08      s_u8DvdRxBuf[UART3_RX_BUF_SIZE] = {0};
static U08 s_u8ArmRxBuf[ARM_RX_BUF_LEN] = {0};
static U08 s_u8ArmTxBuf[ARM_TX_BUF_LEN] = {0};

U08  s_u8NfcRxBuf[30] = {0};
static VU16     s_vu16DvdTaskTmr=0;

/*------------------------------------------------------------------------------
 *						G L O B A L
 *------------------------------------------------------------------------------*/
T_ARM_CFG gtArm ={0};

/*------------------------------------------------------------------------------
 *						P R O T O T Y P E
 *------------------------------------------------------------------------------*/
static BOOL s_ArmRxCheck(void);

static void s_frmArmRxSysReset(void);
static void s_frmArmRxHandshake(void);
static void s_frmArmRxSysUpdateReset(void);
static void s_frmArmRxMic(void);
static void s_frmArmRxNled(void);
static void s_frmArmRxUled(void);
static void s_frmArmRxRelay(void);
static void s_frmArmRxSip(void);
static void s_frmArmRxID(void);
static void s_frmArmRxDoorLed(void);
static void s_frmArmRxCallLed(void);
static void s_frmArmRxAsk(void);



static void s_frmArmTxNFC(U16 prm);
static void s_frmArmTxNull(U16 prm);
static void s_frmArmTxID(U16 prm);
static void s_frmArmTxKey(U16 prm);

static void s_frmArmTxVersion(U16 prm);
static void s_frmArmRxNetReset(void);

//------------------------------------------------------------------
// array for function receive data from DVD
// 13:53pm, 21.Sep.2012, modified by Sirius
//------------------------------------------------------------------
#define NbOfArmRxCmd        (14)
static const T_ARM_RX_FUNC  arryArmRxFuncTbl[NbOfArmRxCmd] = {
	{"CALL",	                s_frmArmRxHandshake},        /*   14  无效 */
	{ "HEART",                   s_frmArmRxHandshake},    /*   1  */		
	{"SYSRESET",              s_frmArmRxSysReset},        /*   2   */
	{"SYSUPDATE",           s_frmArmRxSysUpdateReset},               /*   3   */
	{"MIC",			   s_frmArmRxMic},     /*   4   */
	{"NLED",              	   s_frmArmRxNled},      /*   5  */
	{"ULED",			   s_frmArmRxUled},        /*   6   */
	{"RELAY",              	   s_frmArmRxRelay},       /*  7  */
	{"SIP",              	   s_frmArmRxSip},       /*   8   */
	{"ID",              		   s_frmArmRxID},        /*   9   */
	{"DOORLED",	           s_frmArmRxDoorLed},        /*   10   */
	{"CALLLED",	           s_frmArmRxCallLed},        /*   11   */
	{"ASK",	           s_frmArmRxAsk},        /*   12   */
	{"NETRESET",	           s_frmArmRxNetReset},        /*   13   */
	
};

//------------------------------------------------------------------
// array for function transmit data to DVD
// 17:42pm, 20.Sep.2012, modified by Sirius
//------------------------------------------------------------------
static const fp_prm arryArmTxFuncTbl[NumOfArmMsg] = {
    s_frmArmTxNull,                         /* ARM_MSG_NULL       */
    s_frmArmTxKey,                          /* ARM_MSG_KEY   */
    s_frmArmTxID,                       /* ARM_MSG_ID  */
	  s_frmArmTxNFC,                       /* ARM_MSG_NFC  */
	
    s_frmArmTxVersion,                   /* ARM_MSG_VER        */
};

U16 HexToInt(U32 u32prm)
{
    U16 i=0;
    U16 u16cnt = 0;

    if((DeviceMacInfo[0]>=0x30)&&(DeviceMacInfo[0]<=0x39))
        i= DeviceMacInfo[0]-0x30;
    else
        i= DeviceMacInfo[0]-0x37;
    u16cnt = i<<12;

   if((DeviceMacInfo[1]>=0x30)&&(DeviceMacInfo[1]<=0x39))
        i= DeviceMacInfo[1]-0x30;
    else
        i= DeviceMacInfo[1]-0x37;
        i =i<<8;
	u16cnt |=  i;	

    if((DeviceMacInfo[2]>=0x30)&&(DeviceMacInfo[2]<=0x39))
        i= DeviceMacInfo[2]-0x30;
    else
        i= DeviceMacInfo[2]-0x37;
        i =i<<4;
	u16cnt |=  i;	

    if((DeviceMacInfo[3]>=0x30)&&(DeviceMacInfo[3]<=0x39))
        i= DeviceMacInfo[3]-0x30;
    else
        i= DeviceMacInfo[3]-0x37;
  
			u16cnt |=  i;	
   
        return u16cnt;
}

//------------------------------------------------------------------------
void ArmValInit(void)
{
	U32 u32prm =0;
	
  MEMSET(&gtArm, 0, sizeof(T_ARM_CFG));
  u32prm = ( (DeviceMacInfo[0] <<24) | (DeviceMacInfo[1] <<16)  |  (DeviceMacInfo[2] <<8) |  DeviceMacInfo[4] ) ;
  gtArm.FJKeymac = HexToInt(u32prm);
}

  /*----------------------------------------------------------------------
// Function uses    : ArmTaskTmr
// Input  parameter :
// Output parameter :
// Use  Function    :
// Reserve  date    : 09:11am, 30.Aug.2012, written by Sirius
 ----------------------------------------------------------------------*/
void ArmTaskTmr(void)
{
      if( s_vu16DvdTaskTmr != 0xFFFF )   {s_vu16DvdTaskTmr++;}
}
/*----------------------------------------------------------------------
// Function uses    : s_ArmRxCheck
// Input  parameter :
// Output parameter :
// Use  Function    : check frame format received from ARM.
// Reserve  date    : 14:28pm, 21.Sep.2012, written by Sirius
 ----------------------------------------------------------------------*/
static BOOL s_ArmRxCheck(void)
{
   U08 i      = 0;
    U08 len    = 0;
    U08 chksum = 0;
    U08 chksum2 = 0;

    len = s_u8ArmRxBuf[1];
 
  	chksum2 = s_u8ArmRxBuf[3];
    for (i = 0; i < (len-3); i++) {
        chksum2 ^= s_u8ArmRxBuf[i+4];
    }
    chksum = s_u8ArmRxBuf[1] ^ chksum2 ^ s_u8ArmRxBuf[2];
    if (chksum == s_u8ArmRxBuf[i+4]) {   
			for(i=0;i<(len+2) ;i++) {
						s_u8NfcRxBuf[i] = s_u8ArmRxBuf[i];
					}			
        return (TRUE);
    } else {
        return (FALSE);
    }
}

/*----------------------------------------------------------------------
// Function uses    : s_ArmRxIDCheck
// Input  parameter :
// Output parameter :
// Use  Function    : check frame format received from ARM.
// Reserve  date    : 11:51am, 30.Sep.2019, written by dwd
 ----------------------------------------------------------------------*/
static BOOL s_ArmRxIDCheck(U08 u8cnt)
{
    U08 i      = 0;
    U08 len    = 0;
    /* LEN ==4，只比较前4个字节*/
   len = strlen(arryArmRxFuncTbl[u8cnt].datatype);  
     for (i = 0; i < len; i++) {
   	if (arryArmRxFuncTbl[u8cnt].datatype[i] !=  s_u8ArmRxBuf[1+i]) {
			return (FALSE);
   		} 
  	 } 
	 return (TRUE);
  
}

/*----------------------------------------------------------------------
// Function uses    : DvdRxTask
// Input  parameter :
// Output parameter :
// Use  Function    : Receive command data from DVD.
// Reserve  date    : 15:18pm, 22.Feb.2013, written by Sirius
 ----------------------------------------------------------------------*/
void ArmRxTask(void)
{
   U08 err = 0;
    U08 i   = 0;

    Uart1GetChar(s_u8ArmRxBuf, 0, &err);            /* Copy data if received                    */

    if (err == COM_NO_ERR) {                        /* Valid data received                      */
		
	  if (s_ArmRxCheck()) {                    /* Caculate checksum and feed back Ack data */
					
				   OSQPost(ArmMsgQueue, ARM_MSG_NFC, 0);
        }
    }
}
/*----------------------------------------------------------------------
// Function uses    : DvdTxTask
// Input  parameter :
// Output parameter :
// Use  Function    : Transmit data to DVD.
// Reserve  date    : 14:29pm, 19.Feb.2013, written by Sirius
 ----------------------------------------------------------------------*/
void ArmTxTask(void)
{
   T_MESSAGE   *pmsg;

     pmsg = OSQGet(ArmMsgQueue);
    if (pmsg->id < NumOfArmMsg) {
        arryArmTxFuncTbl[pmsg->id](pmsg->prm);
    }
     if( s_vu16DvdTaskTmr >= 200 ) {
        s_vu16DvdTaskTmr = 0;
       // OSQPost(ArmMsgQueue, ARM_MSG_VER, 0);

    }
		 
		
}




/*----------------------------------------------------------------------
// Function uses    : s_frmArmRxHandshake
// Input  parameter :
// Output parameter :
// Use  Function    :
// Reserve  date    : 14:55pm, 6.Sep.2019, written by dwd
 ----------------------------------------------------------------------*/
static void s_frmArmRxHandshake(void)
{

	 Uart_Call_RevData(s_u8ArmRxBuf[9]);
	 
}



static void s_frmArmTxNull(U16 prm)
{
    prm = prm;
}


/*----------------------------------------------------------------------
// Function uses    : s_frmArmRxSysReset
// Input  parameter :
// Output parameter :
// Use  Function    :
// Reserve  date    : 14:55pm, 6.Sep.2019, written by dwd
 ----------------------------------------------------------------------*/
static void s_frmArmRxSysReset(void)
{
    gtPwrCfg.state = POWER_ON_RESET;
   gtArm.workmode = 0;  //进入测试模式
}

/*----------------------------------------------------------------------
// Function uses    : s_frmArmRxSysReset
// Input  parameter :
// Output parameter :
// Use  Function    :
// Reserve  date    : 14:55pm, 6.Sep.2019, written by dwd
 ----------------------------------------------------------------------*/
static void s_frmArmRxSysUpdateReset(void)
{
   //  SYS_SetUpdate();
     gtPwrCfg.state = POWER_ON_RESET;
     gtArm.workmode = 0;  //进入测试模式
}

/*----------------------------------------------------------------------
// Function uses    : s_frmArmRxMic
// Input  parameter :
// Output parameter :
// Use  Function    :0:手柄麦克风，1:面板麦克风
// Reserve  date    : 14:55pm, 6.Sep.2019, written by dwd
 ----------------------------------------------------------------------*/
static void s_frmArmRxMic(void)
{
   if(s_u8ArmRxBuf[5]=='0') {  
   		//GpioMicSwOutputCfg (RESET);
	}  else {
	//	GpioMicSwOutputCfg (SET);
	}
}

/*----------------------------------------------------------------------
// Function uses    : s_frmArmRxNled
// Input  parameter :
// Output parameter :
// Use  Function    :
// Reserve  date    : 14:55pm, 6.Sep.2019, written by dwd
 ----------------------------------------------------------------------*/
static void s_frmArmRxNled(void)
{
 #if WDKL_NLED_TYPE ==NLEDPCA9635
	 switch (s_u8ArmRxBuf[5])
	{
		  case '0':
                         gtArm.PCA9635Led[11]=(int)((s_u8ArmRxBuf[7]-0x30)*10+(s_u8ArmRxBuf[8]-0x30))*256/100;         //R
                         gtArm.PCA9635Led[12]=(int)((s_u8ArmRxBuf[9]-0x30)*10+(s_u8ArmRxBuf[10]-0x30))*256/100;        //G
                         gtArm.PCA9635Led[10]=(int)((s_u8ArmRxBuf[11]-0x30)*10+(s_u8ArmRxBuf[12]-0x30))*256/100;       //B
                          gtArm.PCA9635LedEn |=0x01;
                        break;
                    case '1':
                          gtArm.PCA9635Led[14]=(int)((s_u8ArmRxBuf[7]-0x30)*10+(s_u8ArmRxBuf[8]-0x30))*256/100;         //R
                          gtArm.PCA9635Led[15]=(int)((s_u8ArmRxBuf[9]-0x30)*10+(s_u8ArmRxBuf[10]-0x30))*256/100;        //G
                          gtArm.PCA9635Led[13]=(int)((s_u8ArmRxBuf[11]-0x30)*10+(s_u8ArmRxBuf[12]-0x30))*256/100;       //B
                         gtArm.PCA9635LedEn |=0x02;                    
                        break;
                    case '2':
                         gtArm.PCA9635Led[2]=(int)((s_u8ArmRxBuf[7]-0x30)*10+(s_u8ArmRxBuf[8]-0x30))*256/100;         //R
                          gtArm.PCA9635Led[3]=(int)((s_u8ArmRxBuf[9]-0x30)*10+(s_u8ArmRxBuf[10]-0x30))*256/100;        //G
                          gtArm.PCA9635Led[1]=(int)((s_u8ArmRxBuf[11]-0x30)*10+(s_u8ArmRxBuf[12]-0x30))*256/100;       //B
                          gtArm.PCA9635LedEn |=0x04;                      
                        break;
                    case '3':
                          gtArm.PCA9635Led[5]=(int)((s_u8ArmRxBuf[7]-0x30)*10+(s_u8ArmRxBuf[8]-0x30))*256/100;         //R
                          gtArm.PCA9635Led[6]=(int)((s_u8ArmRxBuf[9]-0x30)*10+(s_u8ArmRxBuf[10]-0x30))*256/100;        //G
                          gtArm.PCA9635Led[4]=(int)((s_u8ArmRxBuf[11]-0x30)*10+(s_u8ArmRxBuf[12]-0x30))*256/100;       //B
                          gtArm.PCA9635LedEn |=0x08;      
                        break;
                    case '4':
                          gtArm.PCA9635Led[8]=(int)((s_u8ArmRxBuf[7]-0x30)*10+(s_u8ArmRxBuf[8]-0x30))*256/100;         //R
                          gtArm.PCA9635Led[9]=(int)((s_u8ArmRxBuf[9]-0x30)*10+(s_u8ArmRxBuf[10]-0x30))*256/100;        //G
                          gtArm.PCA9635Led[7]=(int)((s_u8ArmRxBuf[11]-0x30)*10+(s_u8ArmRxBuf[12]-0x30))*256/100;       //B
                          gtArm.PCA9635LedEn |=0x10;  
                        break;                    

	 }
 #else
	switch (s_u8ArmRxBuf[5])
	{
		case '0':
			gtArm.PCA9635Led[0]=(int)((s_u8ArmRxBuf[7]-0x30)*10+(s_u8ArmRxBuf[8]-0x30))*256/100;         //R
			gtArm.PCA9635Led[1]=(int)((s_u8ArmRxBuf[9]-0x30)*10+(s_u8ArmRxBuf[10]-0x30))*256/100;        //G
			gtArm.PCA9635Led[2]=(int)((s_u8ArmRxBuf[11]-0x30)*10+(s_u8ArmRxBuf[12]-0x30))*256/100;       //B
			gtArm.Ledhm1620AllDate  &=0xfefefe;
			if ( gtArm.PCA9635Led [0]>0) {  //R
					gtArm.Ledhm1620AllDate  |=0x100;
				} 
			if ( gtArm.PCA9635Led [1]>0 ) {  //G
					gtArm.Ledhm1620AllDate  |=0x01;
				} 
			if ( gtArm.PCA9635Led [2]>0) { //B
					gtArm.Ledhm1620AllDate  |=0x10000;
				} 
			gtArm.ledhm1620pwmLevel[0] =  gtArm.PCA9635Led [0]/10;
			gtArm.ledhm1620pwmLevel[1] =  gtArm.PCA9635Led [1]/10;
			gtArm.ledhm1620pwmLevel[2] =  gtArm.PCA9635Led [2]/10;
			gtArm.PCA9635LedEn |=0x01;
                        break;
			case '1':
					gtArm.PCA9635Led[3]=(int)((s_u8ArmRxBuf[7]-0x30)*10+(s_u8ArmRxBuf[8]-0x30))*256/100;         //R
					gtArm.PCA9635Led[4]=(int)((s_u8ArmRxBuf[9]-0x30)*10+(s_u8ArmRxBuf[10]-0x30))*256/100;        //G
					gtArm.PCA9635Led[5]=(int)((s_u8ArmRxBuf[11]-0x30)*10+(s_u8ArmRxBuf[12]-0x30))*256/100;       //B
					gtArm.PCA9635LedEn |=0x02;        
			gtArm.Ledhm1620AllDate  &=0xfdfdfd;
			if ( gtArm.PCA9635Led [3]>0 ) {  //R
					gtArm.Ledhm1620AllDate  |=0x200;
				} 
			if ( gtArm.PCA9635Led [4]>0) {  //G
			
					gtArm.Ledhm1620AllDate  |=0x02;
				} 
			if ( gtArm.PCA9635Led [5]>0 ) { //B
					gtArm.Ledhm1620AllDate  |=0x20000;
				} 
			gtArm.ledhm1620pwmLevel[3] =  gtArm.PCA9635Led [3]/10;
			gtArm.ledhm1620pwmLevel[4] =  gtArm.PCA9635Led [4]/10;
			gtArm.ledhm1620pwmLevel[5] =  gtArm.PCA9635Led [5]/10;
                        break;
				case '2':
						gtArm.PCA9635Led[6]=(int)((s_u8ArmRxBuf[7]-0x30)*10+(s_u8ArmRxBuf[8]-0x30))*256/100;         //R
						gtArm.PCA9635Led[7]=(int)((s_u8ArmRxBuf[9]-0x30)*10+(s_u8ArmRxBuf[10]-0x30))*256/100;        //G
						gtArm.PCA9635Led[8]=(int)((s_u8ArmRxBuf[11]-0x30)*10+(s_u8ArmRxBuf[12]-0x30))*256/100;       //B
						gtArm.PCA9635LedEn |=0x04;   
			gtArm.Ledhm1620AllDate  &=0xfbfbfb;
			if ( gtArm.PCA9635Led [6]>0 ) {  //R
					gtArm.Ledhm1620AllDate  |=0x400;
				} 
			if ( gtArm.PCA9635Led [7]>0 ) {  //G
			
					gtArm.Ledhm1620AllDate  |=0x04;
				} 
			if ( gtArm.PCA9635Led [8]>0 ) { //B
					gtArm.Ledhm1620AllDate  |=0x40000;
				} 
			gtArm.ledhm1620pwmLevel[6] =  gtArm.PCA9635Led [6]/10;
			gtArm.ledhm1620pwmLevel[7] =  gtArm.PCA9635Led [7]/10;
			gtArm.ledhm1620pwmLevel[8] =  gtArm.PCA9635Led [8]/10;
                        break;
			case '3':
					gtArm.PCA9635Led[9]=(int)((s_u8ArmRxBuf[7]-0x30)*10+(s_u8ArmRxBuf[8]-0x30))*256/100;         //R
					gtArm.PCA9635Led[10]=(int)((s_u8ArmRxBuf[9]-0x30)*10+(s_u8ArmRxBuf[10]-0x30))*256/100;        //G
					gtArm.PCA9635Led[11]=(int)((s_u8ArmRxBuf[11]-0x30)*10+(s_u8ArmRxBuf[12]-0x30))*256/100;       //B
					gtArm.PCA9635LedEn |=0x08;      
			gtArm.Ledhm1620AllDate  &=0xf7f7f7;
			if ( gtArm.PCA9635Led [9]>0 ) {  //R
					gtArm.Ledhm1620AllDate  |=0x800;
				} 
			if ( gtArm.PCA9635Led [10]>0 ) {  //G
			
					gtArm.Ledhm1620AllDate  |=0x08;
				} 
			if ( gtArm.PCA9635Led [11]>0 ) { //B
					gtArm.Ledhm1620AllDate  |=0x80000;
				} 
			gtArm.ledhm1620pwmLevel[9] =  gtArm.PCA9635Led [9]/10;
			gtArm.ledhm1620pwmLevel[10] =  gtArm.PCA9635Led [10]/10;
			gtArm.ledhm1620pwmLevel[11] =  gtArm.PCA9635Led [11]/10;
                        break;
				case '4':
						gtArm.PCA9635Led[12]=(int)((s_u8ArmRxBuf[7]-0x30)*10+(s_u8ArmRxBuf[8]-0x30))*256/100;         //R
						gtArm.PCA9635Led[13]=(int)((s_u8ArmRxBuf[9]-0x30)*10+(s_u8ArmRxBuf[10]-0x30))*256/100;        //G
						gtArm.PCA9635Led[14]=(int)((s_u8ArmRxBuf[11]-0x30)*10+(s_u8ArmRxBuf[12]-0x30))*256/100;       //B
						gtArm.PCA9635LedEn |=0x10;  
			gtArm.Ledhm1620AllDate  &=0xefefef;
			if ( gtArm.PCA9635Led [12]>0) {  //R
					gtArm.Ledhm1620AllDate  |=0x1000;
				} 
			if ( gtArm.PCA9635Led [13]>0 ) {  //G
			
					gtArm.Ledhm1620AllDate  |=0x10;
				} 
			if ( gtArm.PCA9635Led [14]>0 ) { //B
					gtArm.Ledhm1620AllDate  |=0x100000;
				} 
			gtArm.ledhm1620pwmLevel[12] =  gtArm.PCA9635Led [12]/10;
			gtArm.ledhm1620pwmLevel[13] =  gtArm.PCA9635Led [13]/10;
			gtArm.ledhm1620pwmLevel[14] =  gtArm.PCA9635Led [14]/10;
                        break;           
		default:
			break;

	}
	#endif
}


/*----------------------------------------------------------------------
// Function name    : s_frmArmRxUled
// Input  parameter :
// Output parameter :
// Use  Function    :
// Reserve  date    :  14:55pm, 6.Sep.2019, written by dwd
 ----------------------------------------------------------------------*/
static void s_frmArmRxUled(void)
{
	U08 u8cnt =0;

	u8cnt =  s_u8ArmRxBuf[6] - 0x30;
	if (u8cnt >2) {
			u8cnt =2;
		}
	gtArm.Uled = u8cnt;
		
}

/*----------------------------------------------------------------------
// Function name    : s_frmArmRxUled
// Input  parameter :
// Output parameter :
// Use  Function    :
// Reserve  date    :  14:55pm, 6.Sep.2019, written by dwd
 ----------------------------------------------------------------------*/
static void s_frmArmRxRelay(void)
{
	 U08 u8cnt =0;

	u8cnt =  s_u8ArmRxBuf[6] - 0x30;
	if (u8cnt == 0) {
		gtArm.Relay[0 ]= s_u8ArmRxBuf[8];
		if ( gtArm.Relay[0 ] == '0') {
			RELAY_OFF;
		} else if ( gtArm.Relay[0 ] == '1') {
			RELAY_ON;
		}
	} else if (u8cnt == 1) {
		gtArm.Relay[1 ]= s_u8ArmRxBuf[8];
	} else {
		gtArm.Relay[2 ]= s_u8ArmRxBuf[8];
	}
	
}

/*----------------------------------------------------------------------
// Function name    : s_frmArmRxUled
// Input  parameter :
// Output parameter :
// Use  Function    :
// Reserve  date    :  14:55pm, 6.Sep.2019, written by dwd
 ----------------------------------------------------------------------*/
static void s_frmArmRxDoorLed(void)
{
	 gtArm.DoorLed[0] = s_u8ArmRxBuf[9]-0x30;
	 gtArm.DoorLed[1] = s_u8ArmRxBuf[10]-0x30;
	 gtArm.DoorLed[2] = s_u8ArmRxBuf[11]-0x30;
}



/*----------------------------------------------------------------------
// Function name    : s_frmArmRxUled
// Input  parameter :
// Output parameter :
// Use  Function    :
// Reserve  date    :  14:55pm, 6.Sep.2019, written by dwd
 ----------------------------------------------------------------------*/
static void s_frmArmRxSip(void)
{
 	     if(s_u8ArmRxBuf[5]=='0')
               {
                    gtArm.RTL8152_flag=0;
               }
               else if(s_u8ArmRxBuf[5]=='1')
               {
                    gtArm.RTL8152_flag=1;
               }
               else if(s_u8ArmRxBuf[5]=='2')
               {
                    gtArm.RTL8152_flag=2;
               }
}


/*----------------------------------------------------------------------
// Function name    : s_frmArmRxID
// Input  parameter :
// Output parameter :
// Use  Function    :
// Reserve  date    :  14:55pm, 6.Sep.2019, written by dwd
 ----------------------------------------------------------------------*/
static void s_frmArmRxID(void)
{
     OSQPost(ArmMsgQueue, ARM_MSG_ID, 0);
}

/*----------------------------------------------------------------------
// Function name    : s_frmArmRxID
// Input  parameter :
// Output parameter :
// Use  Function    :
// Reserve  date    :  18:35pm, 17.JAN.2020, written by dwd
 ----------------------------------------------------------------------*/
static void s_frmArmRxCallLed(void)
{
		gtArm.callled_red = s_u8ArmRxBuf[9] -0x30;
		gtArm.callled_yel = s_u8ArmRxBuf[10] -0x30;

	
}

/*----------------------------------------------------------------------
// Function name    : s_frmArmRxID
// Input  parameter :
// Output parameter :
// Use  Function    :
// Reserve  date    :  18:35pm, 17.JAN.2020, written by dwd
 ----------------------------------------------------------------------*/
static void s_frmArmRxAsk(void)
{
	if (s_u8ArmRxBuf[5] ==0x49) {
   		OSQPost(ArmMsgQueue, ARM_MSG_ID, 0);
	} else if (s_u8ArmRxBuf[5] ==0x56) {
		OSQPost(ArmMsgQueue, ARM_MSG_VER, 0);
	} 
}

static void s_frmArmRxNetReset(void)
{
	if (s_u8ArmRxBuf[10] == '0') {
		POWER_RESET_OFF;
	} else if(s_u8ArmRxBuf[10] == '1') {
		POWER_RESET_ON;
	} 
}


void LED_ACK_TASK(U16 prm)
{
	U08 u8keyp =0;
	u8keyp = HI_BYTE(prm);
	gtArm.LedKeyState =  u8keyp;
	 if (u8keyp == 14) {  //取消所有事件
		 LED_R_OFF;
	 } else  if (u8keyp == 13) { //换药
		 		 LED_BLUE_ON;
	 } else  if (u8keyp == 12) {
		  LED_RED_ON;
	 } else  if (u8keyp == 11) {
		  LED_GREEN_ON;
	 }
}


/*----------------------------------------------------------------------
// Function uses    :  s_frmArmTxKey
// Input  parameter :
// Output parameter :
// Use  Function    : SWC key code.
// Reserve  date    : 14:55pm, 6.Sep.2019, written by dwd
 ----------------------------------------------------------------------*/
static void  s_frmArmTxKey(U16 prm)
{
    U08 *buf    = (U08*)NULL;

	
    buf = &s_u8ArmTxBuf[0];                     /* Obtain pointer to Tx buffer          */
    *buf++ = '$';   
  #ifdef	WDFJKEY_MAC_ADD
	 	 *buf++ =  HI_BYTE( gtArm.FJKeymac);         //dwdtest  
   	 *buf++ =  LO_BYTE( gtArm.FJKeymac);    //dwdtest  
	#endif
 
    *buf++ = 'K';    
    *buf++ = 'E';   
    *buf++ = 'Y';   
		
	  if (HI_BYTE(prm)==8) {
				*buf++ = 0x30+0x0b;
    	} else if (HI_BYTE(prm)==9) {
				*buf++ = 0x30+0x0c;
    	}else  if (HI_BYTE(prm)==0xa) {
				*buf++ = 0x30+0x0d;
    	}else  if (HI_BYTE(prm)==0xb) {
				*buf++ = 0x30+0x0e;
    	} else {
				*buf++ = 0x30+HI_BYTE(prm);
			}
    
    *buf++ = ',';   
    gtArm.startworkflag =1;
    if ((HI_BYTE(prm)<5)  && (LO_BYTE(prm) == 0X02)){  //dwd200422
				prm &= 0xff00;
				prm |= 0x01;
    	}
    *buf++ = 0X30+LO_BYTE(prm);
    // LED_ACK_TASK(prm);
     *buf++ = '#';
			 #ifdef	WDFJKEY_MAC_ADD
			Uart1PutChar(s_u8ArmTxBuf, 11);
			#else
      Uart1PutChar(s_u8ArmTxBuf, 9);
			#endif
}



/*----------------------------------------------------------------------
// Function uses    :  s_frmArmTxID
// Input  parameter :
// Output parameter :
// Use  Function    : DEVICE ID
// Reserve  date    : 14:55pm, 6.Sep.2019, written by dwd
 ----------------------------------------------------------------------*/
static void s_frmArmTxID(U16 prm)
{
      U08 *buf    = (U08*)NULL;
      U08  u8cnt =0;

    buf = &s_u8ArmTxBuf[0];                     /* Obtain pointer to Tx buffer          */
    #ifdef	WDFJKEY_MAC_ADD
	 	 *buf++ =  HI_BYTE( gtArm.FJKeymac);         //dwdtest  
   	 *buf++ =  LO_BYTE( gtArm.FJKeymac);    //dwdtest  
	#endif
	  *buf++ = '$';               
    *buf++ = 'I';    
    *buf++ = 'D';   
     *buf++ = ',';   
    for (u8cnt = 0;u8cnt <15;u8cnt ++) {
	//	*buf ++ = DeviceID[u8cnt];
    	}
   // *buf++ = 0X30+LO_BYTE(prm);
    *buf++ = '1';
     *buf++ = '#';
    #ifdef	WDFJKEY_MAC_ADD
			Uart1PutChar(s_u8ArmTxBuf, 23);
			#else
    Uart1PutChar(s_u8ArmTxBuf, 21);
			#endif
}

/*----------------------------------------------------------------------
// Function uses    :  s_frmArmTxNFC
// Input  parameter :
// Output parameter :
// Use  Function    : 
// Reserve  date    : 11:50am, 6.Api.2023, written by dwd
 ----------------------------------------------------------------------*/
static void s_frmArmTxNFC(U16 prm)
{
    U08 *buf    = (U08*)NULL;
    U08  u8cnt =0;
	  U08 checksm = 0;
	  U08 len     = 0;

		buf = &s_u8ArmTxBuf[0];                     /* Obtain pointer to Tx buffer          */
	  *buf++ = s_u8NfcRxBuf[0];  //0XFE
	
		*buf++ =  HI_BYTE( gtArm.FJKeymac);        
		checksm +=  HI_BYTE( gtArm.FJKeymac);
		*buf++ =  LO_BYTE( gtArm.FJKeymac);   
		checksm +=  LO_BYTE( gtArm.FJKeymac);	

		len =  s_u8NfcRxBuf[1];
		*buf++ = s_u8NfcRxBuf[1];
		checksm +=  s_u8NfcRxBuf[1];
		for (u8cnt = 0;u8cnt <len;u8cnt ++) {
		*buf ++ = s_u8NfcRxBuf[u8cnt+2];
			checksm += s_u8NfcRxBuf[u8cnt+2];
		}
		checksm ^= 0xFF;
		*buf++ = checksm;
		len += 5;
		Uart2PutChar(s_u8ArmTxBuf, len);  //另一路串口发出
}

static void s_frmArmTxVersion(U16 prm)
{
    U08 *buf    = (U08*)NULL;
      U08  u8cnt =0;

    buf = &s_u8ArmTxBuf[0];                     /* Obtain pointer to Tx buffer          */
	  #ifdef	WDFJKEY_MAC_ADD
	 	 *buf++ =  HI_BYTE( gtArm.FJKeymac);         //dwdtest  
   	 *buf++ =  LO_BYTE( gtArm.FJKeymac);    //dwdtest  
	#endif
    *buf++ = '$';               
    *buf++ = 'V';    
     *buf++ = ',';   
    for (u8cnt = 0;u8cnt <15;u8cnt ++) {
		*buf ++ = DeviceVisionInfo[u8cnt];
    	}
   // *buf++ = 0X30+LO_BYTE(prm);
    *buf++ = 'F';
     *buf++ = '#';
		#ifdef	WDFJKEY_MAC_ADD
		Uart1PutChar(s_u8ArmTxBuf, 22);
		#else
		Uart1PutChar(s_u8ArmTxBuf, 20);
		#endif
}
//==============================================================
//			End Of File
//==============================================================