NewMNFJ/source/user/mapp_can_FJ.c

//==================================================================
//
//	Filename: mapp_can.c
//	Description: CAN2 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 "main.h"
#include "mapp_ami.h"
#include "mapp_can_honda.h"
#include "mapp_arm.h"
#include "mapp_ext.h"
#include "mapp_gpio.h"
#include "mapp_key.h"
#include "mapp_msg.h"
#include "mapp_can.h"
#include "app_avm.h"
/*------------------------------------------------------------------------------
 *						D E F I N E
 *------------------------------------------------------------------------------*/
/*--- ADC1 DMA base address	---*/

/*------------------------------------------------------------------------------
 *						S T R U C T
 *------------------------------------------------------------------------------*/

/*------------------------------------------------------------------------------
 *						S T A T I C - V A R I A B L E S
 *------------------------------------------------------------------------------*/


/*------------------------------------------------------------------------------
 *						G L O B A L
 *------------------------------------------------------------------------------*/

/*------------------------------------------------------------------------------
 *						P R O T O T Y P E
 *------------------------------------------------------------------------------*/

static void s_frmCanHondaRxReverse(void);
static void s_frmCanHondaRxEps(void);
static void s_frmCanHondaRxRadar(void);
static void s_frmCanHondaFuncSwc(void);
static void s_frmCanHondaFuncSwc1(void);
static void s_frmCanHondaFuncRled(void);
static void s_frmCanHondaRxIll(void);
static U08 CanHondaRadarToDvd(U08 dat);

static void s_frmCanHondaFuncClimate(void);

static void s_frmCanHondaFuncSpeed(void);
static void s_frmCanHondaFuncLeftDoor(void);
static void s_frmCanHondaFuncRightDoor(void);
static void s_frmCanHondaFuncBagDoor(void);
static void s_frmCanHondaFuncBagDoor(void);
static void s_frmCanHondaFuncEngineDoor(void);
static void s_frmCanHondaRxSource(void);

//------------------------------------------------------------------
#define CAN1HONDA_CFG_TBL_SIZE    (14)
static const T_CANHONDA_CFG  arryCan1HondaRxCfgTbl[CAN1HONDA_CFG_TBL_SIZE] =
{
     {0x12f91550,                  s_frmCanHondaFuncSwc},
     {0x12f94f50,                  s_frmCanHondaFuncSwc1},
    {0x12F8A79A,                  s_frmCanHondaRxRadar},
        //{0x12f8E054,             	s_frmCanFuncBt},
     {0x12F97150,		s_frmCanHondaRxEps},
     {0x12F81018,		s_frmCanHondaRxReverse},
        //{0x0EF97B51,		s_frmCanRxACInfo},
     {0x0EF98751,		s_frmCanHondaFuncClimate},
     {0x0AF87018,		s_frmCanHondaFuncRled},  //转向灯
     {0x12F85450,    		s_frmCanHondaRxIll},
      {0X12F85050,    		s_frmCanHondaFuncSpeed},     /*8*/
     {0x12F83018,                s_frmCanHondaFuncLeftDoor},   /*9*/
      {0x12F84018,                s_frmCanHondaFuncRightDoor},   /*10*/
    {0x12F84318,                s_frmCanHondaFuncBagDoor},   /*11*/
     {0x0AF81118,	         s_frmCanHondaFuncEngineDoor},  /*12*/
     {0x12F8EC54,    		s_frmCanHondaRxSource},       /*13*/
};

/*----------------------------------------------------------------------
// Function uses    : CanCfgInit
// Input  parameter :
// Output parameter :
// Use  Function    : Configuration CAN2 system.
// Reserve  date    : 11:47am, 25.Jan.2013, written by Sirius
 ----------------------------------------------------------------------*/
void CanHondaFilterInit(void)
{
    CAN_FilterInitTypeDef  CAN_FilterInitStructure;

    /* CAN1 filter init */
    CAN_FilterInitStructure.CAN_FilterNumber = 0;
    CAN_FilterInitStructure.CAN_FilterMode = CAN_FilterMode_IdList;
    CAN_FilterInitStructure.CAN_FilterScale = CAN_FilterScale_32bit;
    CAN_FilterInitStructure.CAN_FilterIdHigh = (U16)(((U32)arryCan1HondaRxCfgTbl[0].frmid<<3)>>16);
    CAN_FilterInitStructure.CAN_FilterIdLow = (U16)((((U32)arryCan1HondaRxCfgTbl[0].frmid<<3)|CAN_ID_EXT|CAN_RTR_DATA)&0xFFFF);
    CAN_FilterInitStructure.CAN_FilterMaskIdHigh =(U16)(((U32)arryCan1HondaRxCfgTbl[1].frmid<<3)>>16);
    CAN_FilterInitStructure.CAN_FilterMaskIdLow = (U16)((((U32)arryCan1HondaRxCfgTbl[1].frmid<<3)|CAN_ID_EXT|CAN_RTR_DATA)&0xFFFF);
    CAN_FilterInitStructure.CAN_FilterFIFOAssignment = CAN_FIFO0;
    CAN_FilterInitStructure.CAN_FilterActivation = ENABLE;
    CAN_FilterInit(&CAN_FilterInitStructure);

    CAN_FilterInitStructure.CAN_FilterNumber = 1;
    CAN_FilterInitStructure.CAN_FilterMode = CAN_FilterMode_IdList;
    CAN_FilterInitStructure.CAN_FilterScale = CAN_FilterScale_32bit;
    CAN_FilterInitStructure.CAN_FilterIdHigh = (U16)(((U32)arryCan1HondaRxCfgTbl[2].frmid<<3)>>16);
    CAN_FilterInitStructure.CAN_FilterIdLow = (U16)((((U32)arryCan1HondaRxCfgTbl[2].frmid<<3)|CAN_ID_EXT|CAN_RTR_DATA)&0xFFFF);
    CAN_FilterInitStructure.CAN_FilterMaskIdHigh =(U16)(((U32)arryCan1HondaRxCfgTbl[3].frmid<<3)>>16);
    CAN_FilterInitStructure.CAN_FilterMaskIdLow = (U16)((((U32)arryCan1HondaRxCfgTbl[3].frmid<<3)|CAN_ID_EXT|CAN_RTR_DATA)&0xFFFF);
    CAN_FilterInitStructure.CAN_FilterFIFOAssignment = CAN_FIFO0;
    CAN_FilterInitStructure.CAN_FilterActivation = ENABLE;
    CAN_FilterInit(&CAN_FilterInitStructure);

   CAN_FilterInitStructure.CAN_FilterNumber = 2;
    CAN_FilterInitStructure.CAN_FilterMode = CAN_FilterMode_IdList;
    CAN_FilterInitStructure.CAN_FilterScale = CAN_FilterScale_32bit;
    CAN_FilterInitStructure.CAN_FilterIdHigh = (U16)(((U32)arryCan1HondaRxCfgTbl[4].frmid<<3)>>16);
    CAN_FilterInitStructure.CAN_FilterIdLow = (U16)((((U32)arryCan1HondaRxCfgTbl[4].frmid<<3)|CAN_ID_EXT|CAN_RTR_DATA)&0xFFFF);
    CAN_FilterInitStructure.CAN_FilterMaskIdHigh =(U16)(((U32)arryCan1HondaRxCfgTbl[5].frmid<<3)>>16);
    CAN_FilterInitStructure.CAN_FilterMaskIdLow =(U16)((((U32)arryCan1HondaRxCfgTbl[5].frmid<<3)|CAN_ID_EXT|CAN_RTR_DATA)&0xFFFF);
    CAN_FilterInitStructure.CAN_FilterFIFOAssignment = CAN_FIFO0;
    CAN_FilterInitStructure.CAN_FilterActivation = ENABLE;
    CAN_FilterInit(&CAN_FilterInitStructure);

    CAN_FilterInitStructure.CAN_FilterNumber = 3;
    CAN_FilterInitStructure.CAN_FilterMode = CAN_FilterMode_IdList;
    CAN_FilterInitStructure.CAN_FilterScale = CAN_FilterScale_32bit;
    CAN_FilterInitStructure.CAN_FilterIdHigh = (U16)(((U32)arryCan1HondaRxCfgTbl[6].frmid<<3)>>16);
    CAN_FilterInitStructure.CAN_FilterIdLow = (U16)((((U32)arryCan1HondaRxCfgTbl[6].frmid<<3)|CAN_ID_EXT|CAN_RTR_DATA)&0xFFFF);
    CAN_FilterInitStructure.CAN_FilterMaskIdHigh =(U16)(((U32)arryCan1HondaRxCfgTbl[7].frmid<<3)>>16);
    CAN_FilterInitStructure.CAN_FilterMaskIdLow =(U16)((((U32)arryCan1HondaRxCfgTbl[7].frmid<<3)|CAN_ID_EXT|CAN_RTR_DATA)&0xFFFF);
    CAN_FilterInitStructure.CAN_FilterFIFOAssignment = CAN_FIFO0;
    CAN_FilterInitStructure.CAN_FilterActivation = ENABLE;
    CAN_FilterInit(&CAN_FilterInitStructure);

   CAN_FilterInitStructure.CAN_FilterNumber = 4;
    CAN_FilterInitStructure.CAN_FilterMode = CAN_FilterMode_IdList;
    CAN_FilterInitStructure.CAN_FilterScale = CAN_FilterScale_32bit;
    CAN_FilterInitStructure.CAN_FilterIdHigh = (U16)(((U32)arryCan1HondaRxCfgTbl[8].frmid<<3)>>16);
    CAN_FilterInitStructure.CAN_FilterIdLow = (U16)((((U32)arryCan1HondaRxCfgTbl[8].frmid<<3)|CAN_ID_EXT|CAN_RTR_DATA)&0xFFFF);
    CAN_FilterInitStructure.CAN_FilterMaskIdHigh =(U16)(((U32)arryCan1HondaRxCfgTbl[9].frmid<<3)>>16);
    CAN_FilterInitStructure.CAN_FilterMaskIdLow =(U16)((((U32)arryCan1HondaRxCfgTbl[9].frmid<<3)|CAN_ID_EXT|CAN_RTR_DATA)&0xFFFF);
    CAN_FilterInitStructure.CAN_FilterFIFOAssignment = CAN_FIFO0;
    CAN_FilterInitStructure.CAN_FilterActivation = ENABLE;
    CAN_FilterInit(&CAN_FilterInitStructure);

       CAN_FilterInitStructure.CAN_FilterNumber = 5;
    CAN_FilterInitStructure.CAN_FilterMode = CAN_FilterMode_IdList;
    CAN_FilterInitStructure.CAN_FilterScale = CAN_FilterScale_32bit;
    CAN_FilterInitStructure.CAN_FilterIdHigh = (U16)(((U32)arryCan1HondaRxCfgTbl[10].frmid<<3)>>16);
    CAN_FilterInitStructure.CAN_FilterIdLow = (U16)((((U32)arryCan1HondaRxCfgTbl[10].frmid<<3)|CAN_ID_EXT|CAN_RTR_DATA)&0xFFFF);
    CAN_FilterInitStructure.CAN_FilterMaskIdHigh =(U16)(((U32)arryCan1HondaRxCfgTbl[11].frmid<<3)>>16);
    CAN_FilterInitStructure.CAN_FilterMaskIdLow =(U16)((((U32)arryCan1HondaRxCfgTbl[11].frmid<<3)|CAN_ID_EXT|CAN_RTR_DATA)&0xFFFF);
    CAN_FilterInitStructure.CAN_FilterFIFOAssignment = CAN_FIFO0;
    CAN_FilterInitStructure.CAN_FilterActivation = ENABLE;
    CAN_FilterInit(&CAN_FilterInitStructure);

       CAN_FilterInitStructure.CAN_FilterNumber = 6;
    CAN_FilterInitStructure.CAN_FilterMode = CAN_FilterMode_IdList;
    CAN_FilterInitStructure.CAN_FilterScale = CAN_FilterScale_32bit;
    CAN_FilterInitStructure.CAN_FilterIdHigh = (U16)(((U32)arryCan1HondaRxCfgTbl[12].frmid<<3)>>16);
    CAN_FilterInitStructure.CAN_FilterIdLow = (U16)((((U32)arryCan1HondaRxCfgTbl[12].frmid<<3)|CAN_ID_EXT|CAN_RTR_DATA)&0xFFFF);
    CAN_FilterInitStructure.CAN_FilterMaskIdHigh =(U16)(((U32)arryCan1HondaRxCfgTbl[13].frmid<<3)>>16);
    CAN_FilterInitStructure.CAN_FilterMaskIdLow =(U16)((((U32)arryCan1HondaRxCfgTbl[13].frmid<<3)|CAN_ID_EXT|CAN_RTR_DATA)&0xFFFF);
    CAN_FilterInitStructure.CAN_FilterFIFOAssignment = CAN_FIFO0;
    CAN_FilterInitStructure.CAN_FilterActivation = ENABLE;
    CAN_FilterInit(&CAN_FilterInitStructure);

}

/*----------------------------------------------------------------------
// Function uses    : CanHondaMsgAnalyseTask
// Input  parameter :
// Output parameter :
// Use  Function    : deque can message received from other node.
// Reserve  date    : 14:11pm, 29.Jan.2013, written by Sirius
 ----------------------------------------------------------------------*/
void CanHondaMsgAnalyseTask(U32 frmid)
{
    U08      u8Cnt = 0;

    for (u8Cnt = 0; u8Cnt < CAN1HONDA_CFG_TBL_SIZE; u8Cnt++) {
        if(frmid==arryCan1HondaRxCfgTbl[u8Cnt].frmid) {
            arryCan1HondaRxCfgTbl[u8Cnt].frmfunc();
            break;
        }
    }
}


/*----------------------------------------------------------------------
// Function uses    : CanTaskTmr
// Input  parameter :
// Output parameter :
// Use  Function    :
// Reserve  date    : 09:11am, 30.Aug.2012, written by Sirius
 ----------------------------------------------------------------------*/
void CanHondaTaskTmr(void)
{

}




static void s_frmCanHondaFuncSwc(void)
{
    T_HONDAKEY_CODE keycode = {NO_HONDAKEY};

    if(!gtAmi.basic.ignit)                  return;

    while (TRUE) {
        /*< NAVI >*/
        if (gtCanRxBuf.msgQ[gtCanRxBuf.deque].Data[3] &0x08) {

	   keycode = HONDAKEY_SWITCHER;  //HONDAKEY_PICKUP
            break;
        }


        keycode = NO_HONDAKEY;
        break;
    }

    KeySetProperty(SWC_CAN1, keycode);

}

 /*----------------------------------------------------------------------
// Function uses    : s_frmCanRxPanel
// Input  parameter :
// Output parameter :
// Use  Function    : 100ms  timer.
// Reserve  date    : 15:20pm, 16.Dec.2016, written by dwd
 ----------------------------------------------------------------------*/
static void s_frmCanHondaFuncSwc1(void)
{
    T_HONDAKEY_CODE keycode = {NO_HONDAKEY};

    if(!gtAmi.basic.ignit)                  return;


    while (TRUE) {
        /*< NAVI >*/
        if (gtCanRxBuf.msgQ[gtCanRxBuf.deque].Data[2] &0x08) {

	 keycode = HONDAKEY_SWITCHER;  //HONDAKEY_PICKUP
            break;
        }


        keycode = NO_HONDAKEY;
        break;
    }

    KeySetProperty(SWC_CAN1, keycode);

}




/*----------------------------------------------------------------------
// Function uses    : s_frmCanRxReverse
// Input  parameter :
// Output parameter :
// Use  Function    : 40ms cycle.
// Reserve  date    : 00:32am, 22.Nov.2011, written by Sirius
//---------------------------------------------------------------------*/
static void s_frmCanHondaRxReverse(void)
{
    U08 u8prm   = 0;
    static U08 u8ReverseCnt = 0;
     static U08 u8RevPowerCnt = 0;
    static U08 revflag = 0;
    static U08 revsourceflag =0;

    #define  REVERSE_DELAY       (3)     /* about 500ms delay  */

     u8prm = (U08)(gtCanRxBuf.msgQ[gtCanRxBuf.deque].Data[2] &0xA0);
   if (u8prm ==0xA0) {
         gtAvm.basic.DangerLight =1;
    } else {
         gtAvm.basic.DangerLight =0;
    }

    u8prm = (U08)(gtCanRxBuf.msgQ[gtCanRxBuf.deque].Data[3] &0x80);
    if (u8prm) {
        u8ReverseCnt++;
            GpioCameraPowerOutputCfg(SET);
	   gtAvm.basic.rev =1;
        if (u8ReverseCnt >= REVERSE_DELAY && revflag == 0){
            u8ReverseCnt = 0;
            revflag = 1;

	   gtAmi.basic.rev = 1;

         if ((gtArm.facset.camera ==CAM_TYPE_CAN) ||(gtArm.facset.camera ==CAM_TYPE_CANVGA)){

                	    OSQPost(ArmMsgQueue, ARM_MSG_BASIC, 0);
                	    OSQPost(ArmMsgQueue, ARM_MSG_EPS, 0);
                	    OSQPost(ArmMsgQueue, ARM_MSG_RADAR, 0);
                      OSQPost(ArmMsgQueue, ARM_MSG_RADAR, 1);
                   if (gtArm.slaver.cursrc == SRC_TYPE_ORIG) {
                         revsourceflag =1;
                         if (gtArm.facset.type == Cartype_HONDA_CIVICVN) {  //原车进倒车加装
                              OSQPost(AmiMsgQueue, AMI_MSG_HONDALIGHT, OS_TIMER_100MS);
                         }
                            OSQPost(AmiMsgQueue, AMI_MSG_SWTICH, OS_TIMER_500MS);
                    }
            } else if ((gtArm.facset.camera ==CAM_TYPE_AVM) || (gtArm.facset.camera ==CAM_TYPE_AVMVGA)){

                	    OSQPost(ArmMsgQueue, ARM_MSG_BASIC, 0);
                	    OSQPost(ArmMsgQueue, ARM_MSG_EPS, 0);
                	    OSQPost(ArmMsgQueue, ARM_MSG_RADAR, 0);
                     OSQPost(ArmMsgQueue, ARM_MSG_RADAR, 1);
            } else   {
                 if (gtArm.slaver.cursrc != SRC_TYPE_ORIG) {
                            revsourceflag =1;
                            if (gtArm.facset.type == Cartype_HONDA_CIVICVN) {  //原车进倒车加装
                              OSQPost(AmiMsgQueue, AMI_MSG_HONDALIGHT, OS_TIMER_100MS);
                             }
                             OSQPost(AmiMsgQueue, AMI_MSG_SWTICH, OS_TIMER_5MS);
                            OSQPost(ArmMsgQueue, ARM_MSG_BASIC, 0);

                    }
               }
          }
    } else {
        u8ReverseCnt = 0;
	   gtAvm.basic.rev =0;
        if (revflag ==0){
            u8RevPowerCnt ++;
            if (u8RevPowerCnt >5) {
                    u8RevPowerCnt =0;
                      GpioCameraPowerOutputCfg(RESET);
                }
            return;
        }
        u8RevPowerCnt =0;
        revflag = 0;
       gtAmi.basic.rev = 0;

	  if ((gtArm.facset.camera == CAM_TYPE_AVM) ||(gtArm.facset.camera ==CAM_TYPE_AVMVGA)){
                OSQPost(ArmMsgQueue, ARM_MSG_BASIC, 0);
             return;
          }
         if (revsourceflag) {
                 if (gtArm.facset.type == Cartype_HONDA_CIVICVN) {  //原车进倒车加装
                                   OSQPost(AmiMsgQueue, AMI_MSG_HONDALIGHT, OS_TIMER_100MS);
                 }
                 OSQPost(AmiMsgQueue, AMI_MSG_SWTICH, OS_TIMER_5MS);
            }
          revsourceflag =0;

	OSQPost(ArmMsgQueue, ARM_MSG_BASIC, 0);
	 OSQPost(ArmMsgQueue, ARM_MSG_SRC, 0);
    }

}



/*----------------------------------------------------------------------
// Function uses    : s_frmCanRxReverse
// Input  parameter :
// Output parameter :
// Use  Function    : 40ms cycle.
// Reserve  date    : 00:32am, 22.Nov.2011, written by Sirius
//---------------------------------------------------------------------*/
static void s_frmCanHondaRxIll(void)
{
   U08 tempill = 0;

   if(gtCanRxBuf.msgQ[gtCanRxBuf.deque].Data[0]&0x40){
  	gtAmi.basic.ill=1;
    }else{
     	gtAmi.basic.ill=0;
    }


    if (tempill !=  gtAmi.basic.ill ) {
             gtAmi.basic.ill = tempill;
        //     OSQPost(ArmMsgQueue, ARM_MSG_BASIC, 0);
        }
}



/*----------------------------------------------------------------------
// Function uses    : s_frmCanRxEps
// Input  parameter :
// Output parameter :
// Use  Function    : Get Car Swc Angle from can,120ms cycle
// 11:46am, 23.May.2013, modified by slzhang
//--------------------------------------------------------------------*/
static void s_frmCanHondaRxEps(void)
{
    U16 epsflag = 0;
    static U08 lastEps=0;



    epsflag = TO_WORD(gtCanRxBuf.msgQ[gtCanRxBuf.deque].Data[1],gtCanRxBuf.msgQ[gtCanRxBuf.deque].Data[2]);
    if (lastEps !=gtCanRxBuf.msgQ[gtCanRxBuf.deque].Data[1] ) {  //转角度约为正负0x1050
      lastEps =gtCanRxBuf.msgQ[gtCanRxBuf.deque].Data[1] ;

     if (epsflag &0x8000) {
         gtAmi.eps.signch|= 0x01;
         epsflag = ~ epsflag;
         epsflag +=1;
    } else {
        gtAmi.eps.signch &=0xfe;
      }
    epsflag = (U16)(epsflag *2/3);
    if (epsflag >= 0xa00) {
            epsflag  =0xa00;
        }

       gtAmi.eps.val = epsflag;

	if(gtAmi.basic.rev) {
    		   OSQInquery(ArmMsgQueue, ARM_MSG_EPS, 0);
	}
    }


}



//--------------------------------------------------
static U08 CanHondaRadarToDvd(U08 dat)
{
    if(dat==0x01)
    return (U08)0x3c;
    else if(dat==0x02)
    return (U08)0x2d;
    else if(dat==0x03)
    return (U08)0x1e;
    else if(dat==0x04)
    return (U08)0x0f;
    else
    return (U08)0xa6;
}

/*----------------------------------------------------------------------
// Function name    : s_frmCanRxRadar
// Input  parameter :
// Output parameter :
// Use  Function    :
// Reserve  date    : 14:29pm, 15.Dec.2014, written by Charlie
 ----------------------------------------------------------------------*/
static void s_frmCanHondaRxRadar(void)
{
   T_AMI_RADAR  prm = {0};


    prm.rl = (U08)((gtCanRxBuf.msgQ[gtCanRxBuf.deque].Data[1] & 0xf0) >> 4);
	prm.rl=CanHondaRadarToDvd(prm.rl);
	prm.rlm = (U08)(gtCanRxBuf.msgQ[gtCanRxBuf.deque].Data[2] & 0x0f);
	prm.rlm=CanHondaRadarToDvd(prm.rlm);
	//prm.rrm=prm.rlm;
	prm.rr = (U08)(gtCanRxBuf.msgQ[gtCanRxBuf.deque].Data[1] & 0x0f);
	prm.rr=CanHondaRadarToDvd(prm.rr);

	prm.fl = (U08)((gtCanRxBuf.msgQ[gtCanRxBuf.deque].Data[0] & 0xf0) >> 4);
	prm.fl=CanHondaRadarToDvd(prm.fl);
	prm.flm = (U08)((gtCanRxBuf.msgQ[gtCanRxBuf.deque].Data[2] & 0xf0)>>4);
	prm.flm=CanHondaRadarToDvd(prm.flm);
	//prm.frm=prm.flm;
	prm.fr = (U08)(gtCanRxBuf.msgQ[gtCanRxBuf.deque].Data[0] & 0x0f);
	prm.fr=CanHondaRadarToDvd(prm.fr);
	if ((gtAmi.radar.rl != prm.rl) ||
	(gtAmi.radar.rlm != prm.rlm) ||
	(gtAmi.radar.rr != prm.rr)
	){
		gtAmi.radar.rl = prm.rl;
		gtAmi.radar.rlm = prm.rlm;
		gtAmi.radar.rrm = prm.rlm;
		gtAmi.radar.rr = prm.rr;
		OSQPost(ArmMsgQueue, ARM_MSG_RADAR, 0);
	}

	if((gtAmi.radar.fl != prm.fl) ||
        (gtAmi.radar.flm != prm.flm) ||
	    (gtAmi.radar.fr != prm.fr)) {
		gtAmi.radar.fl = prm.fl;
		gtAmi.radar.flm = prm.flm;
		gtAmi.radar.frm = prm.flm;
		gtAmi.radar.fr = prm.fr;
		OSQPost(ArmMsgQueue, ARM_MSG_RADAR, 1);
	}
}


static void s_frmCanHondaFuncClimate(void)
{
  U08 buff;

  if(gtAmi.basic.rev||gtAmi.basic.avm) {
            return;
        }

    buff=(U08)(gtCanRxBuf.msgQ[gtCanRxBuf.deque].Data[2]&0x01);


   if (buff !=gtAmi.acclimate) {
            gtAmi.acclimate = buff;
            if (	 gtAmi.acclimate) {
                    VideoSwitchBySource (SRC_TYPE_ORIG);
                }
          //   OSQPost(ArmMsgQueue, ARM_MSG_AC, 0);
    }
}

static void s_frmCanHondaFuncRled(void)
{
    U08 u8prm   = 0;
    static U08 turnflag = 0;


    u8prm = (U08)(gtCanRxBuf.msgQ[gtCanRxBuf.deque].Data[1] &0xC0);

  if(u8prm&0x40){
        gtAvm.basic.TurnRight =0x01;
        gtAmi.basic.R_video=1;
    }else {
              gtAvm.basic.TurnRight =0x00;
              gtAmi.basic.R_video=0;
	}
  if(u8prm&0x80){
          gtAvm.basic.TurnLeft=0x01;
    } else {
         gtAvm.basic.TurnLeft=0x00;
     }

   #if 0
   if ((!gtAmi.basic.R_videoEn) ||  (gtAmi.basic.rev ) ||  (gtAmi.basic.avm)) {
            turnflag = 0;
            return;
    }
  if (turnflag != gtAmi.basic.R_video) {
        turnflag = gtAmi.basic.R_video;

        if (gtAmi.basic.R_video) {
                  VideoSwitchBySource(SRC_TYPE_ORIG);
            } else {
                  VideoSwitchBySource( gtArm.slaver.eldsrc);
            }
    }
  #endif

}


/*----------------------------------------------------------------------
// Function uses    : s_frmCanFuncSpeed
// Input  parameter :
// Output parameter :
// Use  Function    : for None-can bus car.
// Reserve  date    : 19:58pm, 2.July.2013, written by Sirius
//---------------------------------------------------------------------*/
static void s_frmCanHondaFuncSpeed(void)  //预留车速信息
{
    U08       bufval = 0;


    bufval = (U08) (gtCanRxBuf.msgQ[gtCanRxBuf.deque].Data[0]);

     gtAmi.basic.CarSpeed = bufval;}

static void s_frmCanHondaFuncRightDoor(void)
{
    U08       bufval = 0;

    bufval = (U08) (gtCanRxBuf.msgQ[gtCanRxBuf.deque].Data[0]);
    if(bufval&0x40){//右前
    	gtAmi.basic.cardoor |=0x02;
    }else{
    	gtAmi.basic.cardoor &=0xfd;
    }
    if(bufval&0x10){//右后
    	gtAmi.basic.cardoor |=0x08;
    }else{
    	gtAmi.basic.cardoor &=0xf7;
    }
}

static void s_frmCanHondaFuncLeftDoor(void)
{
    U08       bufval = 0;

    bufval = (U08) (gtCanRxBuf.msgQ[gtCanRxBuf.deque].Data[0]);
    if(bufval&0x80){//左前
    	gtAmi.basic.cardoor |=0x01;
    }else{
    	gtAmi.basic.cardoor &=0xfe;
    }
    if(bufval&0x20){//左后
    	gtAmi.basic.cardoor |=0x04;
    }else{
    	gtAmi.basic.cardoor &=0xfb;
    }
}

static void s_frmCanHondaFuncBagDoor(void)
{
    U08       bufval = 0;

    bufval = (U08) (gtCanRxBuf.msgQ[gtCanRxBuf.deque].Data[0]);
    if(bufval&0x80){//后备箱
    	gtAmi.basic.cardoor |=0x10;
    }else{
    	gtAmi.basic.cardoor &=0xef;
    }

}

static void s_frmCanHondaFuncEngineDoor(void)
{
    U08       bufval = 0;

    bufval = (U08) (gtCanRxBuf.msgQ[gtCanRxBuf.deque].Data[0]);
    if(bufval&0x80){//前盖
    	gtAmi.basic.cardoor |=0x20;
    }else{
    	gtAmi.basic.cardoor &=0xdf;
    }
}

static void s_frmCanHondaRxSource(void)
{

}


/*------------------------------- E O F ----------------------------------------*/