WDFJKEY/source/user/mapp_can.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_can_audi.h"
#include "mapp_can_fod.h"
#include "mapp_can_fod.h"
#include "mapp_can_Buick.h"
#include "mapp_can_trump.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"
#include "mapp_pwr.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
 *------------------------------------------------------------------------------*/
static VU16        s_vu16CanTaskTmr   = 0;
VU16        s_vu16CanLostTmr   = 0;
static VU16        s_vu16Can2RxMem    = 0;
static VU16 s_vu16AirDispTmr=0;

/*------------------------------------------------------------------------------
 *						G L O B A L
 *------------------------------------------------------------------------------*/
T_CAN_RXQ gtCanRxBuf = {0}; /* CAN1 receive buffer		    */
U08 MidFuction=0;
T_CAN_STATE s_tCanState        = {CAN_POWER_START};
/*------------------------------------------------------------------------------
 *						P R O T O T Y P E
 *------------------------------------------------------------------------------*/
static void s_CanVariablesInit(void);
static void s_CanDrvTrcvCfg(T_TRCVR_STATE stat);
static void CarTypeJudgeTask(void);





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

    /* Configure CAN2 **************************************************/
	RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA, ENABLE);
	GPIO_PinAFConfig(GPIOA,GPIO_PinSource12,GPIO_AF_4);
	GPIO_PinAFConfig(GPIOA,GPIO_PinSource11,GPIO_AF_4);

	/* Configure CAN pin: TX */
	GPIO_InitStructure.GPIO_Pin    = GPIO_Pin_12|GPIO_Pin_11;//TXRX
	GPIO_InitStructure.GPIO_Mode   = GPIO_Mode_AF;
	GPIO_InitStructure.GPIO_OType  = GPIO_OType_OD;
	GPIO_InitStructure.GPIO_Speed  = GPIO_Speed_50MHz;
	#ifdef  CAN_BUICK_ONLY
		GPIO_InitStructure.GPIO_PuPd   = GPIO_PuPd_UP;//±ð¿Ë¼ÓÉÏÀ
	#else
		GPIO_InitStructure.GPIO_PuPd   = GPIO_PuPd_NOPULL;
	#endif
	//GPIO_InitStructure.GPIO_PuPd   = GPIO_PuPd_UP;//±ð¿Ë¼ÓÉÏÀ­
	GPIO_Init(GPIOA, &GPIO_InitStructure);

    /* CAN2 Periph clocks enable */
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN, ENABLE);
    /* CAN1 and CAN2 register init */
    CAN_DeInit(CAN);
    //CAN_DeInit(CAN2);

    /* Struct init*/
    CAN_StructInit(&CAN_InitStructure);

    /* CAN1 and CAN2 cell init */
    CAN_InitStructure.CAN_TTCM = DISABLE;
    CAN_InitStructure.CAN_ABOM = ENABLE;
    CAN_InitStructure.CAN_AWUM = DISABLE;
    CAN_InitStructure.CAN_NART = DISABLE;
    CAN_InitStructure.CAN_RFLM = DISABLE;
    CAN_InitStructure.CAN_TXFP = ENABLE;
    CAN_InitStructure.CAN_Mode = CAN_Mode_Normal;
    CAN_InitStructure.CAN_SJW  = CAN_SJW_1tq;
    CAN_InitStructure.CAN_BS1  = CAN_BS1_5tq;
    CAN_InitStructure.CAN_BS2  = CAN_BS2_2tq;

    if((gtCarType.CarType == CARTYPE_AUDI )||(gtCarType.CarType == CARTYPE_FOD)) {
        CAN_InitStructure.CAN_Prescaler = 12;
    } else if( gtCarType.CarType == CARTYPE_HONDA ) {
        CAN_InitStructure.CAN_Prescaler = 48;
    } else if( gtCarType.CarType == CARTYPE_BUICK) {
        CAN_InitStructure.CAN_Prescaler = 180;
    }  else if( gtCarType.CarType == CARTYPE_TRUMPCHI) {
        CAN_InitStructure.CAN_Prescaler = 48;
    } else {
        gtCarType.CarType = CARTYPE_AUDI;
        CAN_InitStructure.CAN_Prescaler = 12;
    }
    /*Initializes CAN1 */
    CAN_Init(CAN, &CAN_InitStructure);

    //if (gtSysCfg.can2Brt == CAN_050K) {
    //    CAN_InitStructure.CAN_Prescaler = 90;  /* 36MHz/[(SWJ+BS1+BS2)*Prescaler]=50Kbps */
    //} else if (gtSysCfg.can2Brt == CAN_100K) {
    //    CAN_InitStructure.CAN_Prescaler = 45;  /* 36MHz/[(SWJ+BS1+BS2)*Prescaler]=100Kbps */
    //} else if (gtSysCfg.can2Brt == CAN_125K) {
    //    CAN_InitStructure.CAN_Prescaler = 36;  /* 36MHz/[(SWJ+BS1+BS2)*Prescaler]=125Kbps */
    //} else if (gtSysCfg.can2Brt == CAN_250K) {
    //    CAN_InitStructure.CAN_Prescaler = 18;  /* 36MHz/[(SWJ+BS1+BS2)*Prescaler]=250Kbps */
    //} else if (gtSysCfg.can2Brt == CAN_500K) {
    //    CAN_InitStructure.CAN_Prescaler = 9;  /* 36MHz/[(SWJ+BS1+BS2)*Prescaler]=500Kbps */
    //} else {
    //    CAN_InitStructure.CAN_Prescaler = 9;  /* 36MHz/[(SWJ+BS1+BS2)*Prescaler]=500Kbps */
    //}
    /*Initializes CAN2 */
    //CAN_Init(CAN2, &CAN_InitStructure);


    /* CAN1 filter init */

        CanHondaFilterInit();

     /* IT Configuration for CAN1 */
    CAN_ITConfig(CAN, CAN_IT_FMP0, ENABLE);

}




/*----------------------------------------------------------------------
// Function uses    : CanTask
// Input  parameter :
// Output parameter :
// Use  Function    : CAN BUS main task.
// Reserve  date    : 11:31am, 29.Jan.2013, written by Sirius
 ----------------------------------------------------------------------*/
void CanTask(void)
{
    switch (s_tCanState) {
        case CAN_POWER_START:
            //------------------------------------------------------------------
            // Wait about 100ms for system hardware stable.
            // 09:17am, 30.Aug.2012, modified by Sirius
            //------------------------------------------------------------------
            s_vu16CanTaskTmr = 0;//OS_TIMER_200MS
         
                s_tCanState++;
      
            break;

        case CAN_TRCVR_INIT:
            if (s_vu16CanTaskTmr) {
                break;
            }
            s_CanVariablesInit();
            s_vu16CanTaskTmr = 0;
            s_tCanState++;
            break;

        case CAN_LAYER_INIT:
            if (s_vu16CanTaskTmr) {
                break;
            }
            //------------------------------------------------------------------
            // Init can controller.
            // 10:09am, 30.Aug.2012, modified by Sirius
            //------------------------------------------------------------------
            CanCfgInit();
             s_CanDrvTrcvCfg(TRCVR_INIT);
            s_tCanState++;
            break;

         case CAN_WAKE_UP:
            if (s_vu16CanTaskTmr) {
                break;
            }
            CAN_WakeUp(CAN);
            s_vu16CanTaskTmr = OS_TIMER_500MS;
            s_tCanState++;
            break;

        case CAN_STATE_RUN:
            if( s_vu16CanTaskTmr ) {
                return;
            }
      
        
            break;

        case CAN_STATE_SLEEP:
            if (s_vu16CanTaskTmr) {
                break;
            }
            s_CanDrvTrcvCfg(TRCVR_OFF);
            break;

        default:
            break;

    }
}

/*----------------------------------------------------------------------
// Function uses    : CanTaskTmr
// Input  parameter :
// Output parameter :
// Use  Function    :
// Reserve  date    : 09:11am, 30.Aug.2012, written by Sirius
 ----------------------------------------------------------------------*/
void CanTaskTmr(void)
{
	if (s_vu16CanTaskTmr)      { s_vu16CanTaskTmr--; }
        if (s_vu16CanLostTmr != 0xffff)   {s_vu16CanLostTmr++;  }
        CanFodTaskTmr();
}

/*----------------------------------------------------------------------
// Function uses    : CanTaskState
// Input  parameter :
// Output parameter :
// Use  Function    :
// Reserve  date    : 13:52pm, 25.Dec.2012, written by Sirius
 ----------------------------------------------------------------------*/
T_CAN_STATE CanTaskState(void)
{
    return (s_tCanState);
}

/*----------------------------------------------------------------------
// Function uses    : CanBusSleep
// Input  parameter :
// Output parameter :
// Use  Function    : can bus go into sleep mode.
// Reserve  date    : 12:22pm, 29.Jan.2013, written by Sirius
 ----------------------------------------------------------------------*/
void CanBusSleep(void)
{
    //CAN_Sleep(CAN1);
    //CAN_Sleep(CAN2);
   // s_CanDrvTrcvCfg(TRCVR_WATOFF);
   // s_tCanState = CAN_STATE_SLEEP;
}

/*----------------------------------------------------------------------
// Function uses    : CanBusRunState
// Input  parameter :
// Output parameter :
// Use  Function    : can bus go into sleep mode.
// Reserve  date    : 12:22pm, 29.Jan.2013, written by Sirius
 ----------------------------------------------------------------------*/
U08 CanBusRunState(void)
{
   // if(CAN_STATE_RUN == s_tCanState) {
  //      return 1;
   // } else {
       // return 0;
 //   }
}
/*----------------------------------------------------------------------
// Function uses    : CanBusWakeup
// Input  parameter :
// Output parameter :
// Use  Function    : can bus ready to wake up.
// Reserve  date    : 12:22pm, 29.Jan.2013, written by Sirius
 ----------------------------------------------------------------------*/
void CanBusWakeup(void)
{
   // s_CanVariablesInit();
  //  s_CanDrvTrcvCfg(TRCVR_INIT);
  //  s_tCanState = CAN_WAKE_UP;
 //   s_vu16CanTaskTmr = OS_TIMER_100MS;   /* Wait 100ms for TRCV stable */
  
}

/*----------------------------------------------------------------------
// Function name    : Judge CAN system go into sleep.
// Input  parameter :
// Output parameter :
// Use  Function    :
// Reserve  date    : 10:10am, 31.May.2013, written by Charlie
 ----------------------------------------------------------------------*/
BOOL CanBusActive(void)
{
    return (s_vu16CanLostTmr < OS_TIMER_3S);
}



//----------------------------------------------------------------------------
void CanVariablesInit(void)
{
	s_vu16CanTaskTmr   = 0;
//	s_tCanState        = CAN_POWER_START;

}
/*----------------------------------------------------------------------
// Function uses    : s_CanVariablesInit
// Input  parameter :
// Output parameter :
// Use  Function    :
// Reserve  date    : 09:30am, 30.Aug.2012, written by Sirius
 ----------------------------------------------------------------------*/
static void s_CanVariablesInit(void)
{
	//gtCanRxBuf.enque = 0;
	//gtCanRxBuf.deque = 0;
	//MEMSET(&gtCanRxBuf, 0 , sizeof(T_CAN_RXQ));

}

/*----------------------------------------------------------------------
// Function uses    : s_CanDrvTrcvCfg
// Input  parameter : Transceiver TJA1040 standby control.
// Output parameter :
// Use  Function    :
// Reserve  date    : 10:36am, 29.Jan.2013, written by Sirius
 ----------------------------------------------------------------------*/
static void s_CanDrvTrcvCfg(T_TRCVR_STATE stat)
{
/*    switch (stat) {
        case TRCVR_INIT:
        case TRCVR_ON:
        default:
            GpioTrcv1040StandbyCfg(RESET);
		
            break;

        case TRCVR_OFF:
            GpioTrcv1040StandbyCfg(SET);
            GpioTrcv28056StandbyCfg(RESET);
            GpioTrcv28056EnableCfg(RESET);
            break;

        case TRCVR_WATOFF:
            GpioTrcv1040StandbyCfg(SET);

            break;
    }*/
}

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

  if (CAN_STATE_RUN != s_tCanState) {
        return;
    }
    //------------------------------------------------------------------
    // CAN1 data received & processed.
    // 14:51pm, 29.Jan.2013, modified by Sirius
    //------------------------------------------------------------------
    while(gtCanRxBuf.enque != gtCanRxBuf.deque) {
        gtPwrCfg.CanLostTmr = 0;
        if(gtCanRxBuf.msgQ[gtCanRxBuf.deque].IDE)
        {
            frmid=gtCanRxBuf.msgQ[gtCanRxBuf.deque].ExtId;
        }
        else
        {
            frmid=gtCanRxBuf.msgQ[gtCanRxBuf.deque].StdId;
        }

            CanHondaMsgAnalyseTask(frmid);


        gtCanRxBuf.deque++;
        if (gtCanRxBuf.deque >= CAN_RX_MSG_CNT) {
              gtCanRxBuf.deque = 0;
        }
    }

}




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