799 lines
18 KiB
C
799 lines
18 KiB
C
#include "appTask.h"
|
|
#include "iodefine.h"
|
|
#include "extern.h"
|
|
#include "r_cg_adc.h"
|
|
#include "r_cg_intc.h"
|
|
#include "r_cg_timer.h"
|
|
#include "PINdef.h"
|
|
#include "hwCtrl.h"
|
|
#include "crc.h"
|
|
#include "pfdl.h"
|
|
|
|
u8 can_data_init_flag = 0;
|
|
|
|
unsigned long Can_1ms_count_alive;
|
|
|
|
|
|
|
|
unsigned char IGN_Voltage_error_flag;
|
|
uint16_t IGN_Voltage_error_count;
|
|
|
|
|
|
unsigned char Timer_1ms_flag;
|
|
unsigned char Timer_5ms_flag;
|
|
unsigned char Timer_10ms_flag;
|
|
unsigned char Timer_20ms_flag;
|
|
unsigned char Timer_50ms_flag;
|
|
unsigned char Timer_1000ms_flag;
|
|
|
|
unsigned int CAN_LostCount;
|
|
unsigned char key_count, key_last;
|
|
unsigned char IGN_Lost, IGN_Lost_Count;
|
|
unsigned char IGN_On, IGN_On_Count;
|
|
/********************* Network Manage ****************************/
|
|
unsigned char ucIgnStus;
|
|
unsigned int uiBusOffCnt; // ms
|
|
unsigned char ucBusOffModeState; // 0:Normal 1~4:Fast Rec 5:Slow Rec
|
|
unsigned char BusoffFlag;
|
|
/***************************************************/
|
|
|
|
uint16_t VehicleSpeedRaw,VehicleSpeed;
|
|
|
|
uint8_t nouse;//Relocation value is odd number
|
|
uint8_t lock_state,lkey_state,Pkey_state,re2key_state;
|
|
#define LOCK_STATE_LOCKED 0
|
|
#define LOCK_STATE_UNLOCKED 1
|
|
static uint8_t g_lh_state,g_fnr_state;
|
|
uint8_t g_f_op,g_n_op,g_r_op;
|
|
static uint8_t PowerUpDetect_flag;
|
|
static uint8_t PowerUp_FNR_Error_flag,OperationFault_flag;
|
|
static uint8_t err_counter;
|
|
static uint8_t P_light_rcv;
|
|
#define FNR_ERROR_HL_POS 0
|
|
#define FNR_ERROR_F_POS 1
|
|
#define FNR_ERROR_N_POS 2
|
|
#define FNR_ERROR_R_POS 3
|
|
#define FNR_ERROR_P_POS 4
|
|
|
|
void IND_task(void);
|
|
void HD_task(void);
|
|
void PowerUpDetect(void);
|
|
void P_light_task(void);
|
|
|
|
|
|
void Apply_task(void)
|
|
{
|
|
|
|
// DiagnosticSession_Present=MngDcm_GetDiagnosticSession();
|
|
|
|
|
|
// DiagnosticSession_Present=MngDcm_GetDiagnosticSession();
|
|
if(CAN_STB == 0 && ucBusOffModeState == 0)//Tx enable
|
|
{
|
|
TxServe();
|
|
}
|
|
if (Timer_1ms_flag == 1)
|
|
{
|
|
Timer_1ms_flag = 0;
|
|
MngDcm_MainFunction();
|
|
MngCanTp_MainFunction();
|
|
App28sTxRxStatus = GetNormalMsgSts();
|
|
Nw28sTxRxStatus = GetNetworkMsgSts();
|
|
if (BusOff_Detect_delay_count == 0 /*&& (ad_voltage_fact[2]>=85 && ad_voltage_fact[2]<=165)*/)
|
|
{
|
|
BusOff_Detect();
|
|
}
|
|
KeyScan();
|
|
|
|
IND_task();
|
|
//IGN_Detect();
|
|
//CanNwHandle();
|
|
}
|
|
if (Timer_5ms_flag == 1)
|
|
{
|
|
Timer_5ms_flag = 0;
|
|
CAN_RX_Data_Handle();
|
|
if (PowerUpDetect_flag == 1)
|
|
{
|
|
HD_task();
|
|
}
|
|
|
|
|
|
// IGN_Detect();
|
|
|
|
}
|
|
|
|
if (Timer_10ms_flag == 1)
|
|
{
|
|
Timer_10ms_flag = 0;
|
|
KeyPro();
|
|
Can_Msg_Change();
|
|
if (PowerUpDetect_flag == 0)
|
|
{
|
|
PowerUpDetect();
|
|
}
|
|
P_light_task();
|
|
}
|
|
if (Timer_20ms_flag == 1)
|
|
{
|
|
Timer_20ms_flag = 0;
|
|
|
|
IGN_Voltage_Detect();
|
|
|
|
}
|
|
if (Timer_50ms_flag == 1)
|
|
{
|
|
Timer_50ms_flag = 0;
|
|
//TxTestMsg();
|
|
|
|
//SleepDetect();//TODO
|
|
}
|
|
}
|
|
extern uint8 txbuf1[8];
|
|
|
|
void HD_F_CTRL(void)
|
|
{
|
|
|
|
|
|
}
|
|
//200MS
|
|
#define HD_DEBOUNCE 40
|
|
void HD_task(void)//5ms
|
|
{
|
|
uint16_t adval[3] = {0};
|
|
static uint8_t fnr_step = 0, lh_step = 0;
|
|
static uint16_t fnr_counter[3] = {0},OperationFault_counter[3] = {0};
|
|
uint8_t db_pos = 0;
|
|
|
|
if (lkey_state == 1)
|
|
{
|
|
lkey_state = 0;
|
|
if (g_lh_state == LH_STATE_L)
|
|
{
|
|
g_lh_state = LH_STATE_H;
|
|
}
|
|
else
|
|
{
|
|
g_lh_state = LH_STATE_L;
|
|
}
|
|
}
|
|
|
|
|
|
adval[FNR_STATE_F] = getAdval(ADCH_HALL_F);
|
|
adval[FNR_STATE_N] = getAdval(ADCH_HALL_N);
|
|
adval[FNR_STATE_R] = getAdval(ADCH_HALL_R);
|
|
|
|
switch (g_fnr_state)
|
|
{
|
|
case FNR_STATE_N:
|
|
if (adval[FNR_STATE_F] < 20 && adval[FNR_STATE_N] > 1000 && g_f_op == 0 && OperationFault_flag == 0)
|
|
{
|
|
fnr_counter[FNR_STATE_F]++;
|
|
if (fnr_counter[FNR_STATE_F] > HD_DEBOUNCE)
|
|
{
|
|
fnr_counter[FNR_STATE_F] = HD_DEBOUNCE;
|
|
if (lock_state == LOCK_STATE_LOCKED)
|
|
{
|
|
g_f_op = 1;
|
|
}
|
|
else
|
|
{
|
|
g_fnr_state = FNR_STATE_F;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
fnr_counter[FNR_STATE_F] = 0;
|
|
}
|
|
|
|
if (adval[FNR_STATE_R] < 20 && adval[FNR_STATE_N] > 1000 && g_f_op == 0 && OperationFault_flag == 0)
|
|
{
|
|
fnr_counter[FNR_STATE_R]++;
|
|
if (fnr_counter[FNR_STATE_R] > HD_DEBOUNCE)
|
|
{
|
|
fnr_counter[FNR_STATE_R] = HD_DEBOUNCE;
|
|
if (lock_state == LOCK_STATE_LOCKED)
|
|
{
|
|
g_r_op = 1;
|
|
}
|
|
else
|
|
{
|
|
g_fnr_state = FNR_STATE_R;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
fnr_counter[FNR_STATE_R] = 0;
|
|
}
|
|
|
|
if (adval[FNR_STATE_N] < 20 && adval[FNR_STATE_F] > 1000 && adval[FNR_STATE_R] > 1000)
|
|
{
|
|
g_f_op = 0;
|
|
g_r_op = 0;
|
|
OperationFault_flag = 0;
|
|
}
|
|
if (adval[FNR_STATE_N] < 20 && adval[FNR_STATE_F] < 20)
|
|
{
|
|
OperationFault_counter[FNR_STATE_F]++;
|
|
if (OperationFault_counter[FNR_STATE_F] > HD_DEBOUNCE)
|
|
{
|
|
OperationFault_counter[FNR_STATE_F] = HD_DEBOUNCE;
|
|
OperationFault_flag |= 1<<FNR_ERROR_F_POS;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
OperationFault_counter[FNR_STATE_F] = 0;
|
|
//OperationFault_flag &= ~(1<<FNR_ERROR_F_POS);
|
|
}
|
|
|
|
if (adval[FNR_STATE_N] < 20 && adval[FNR_STATE_R] < 20)
|
|
{
|
|
OperationFault_counter[FNR_STATE_R]++;
|
|
if (OperationFault_counter[FNR_STATE_R] > HD_DEBOUNCE)
|
|
{
|
|
OperationFault_counter[FNR_STATE_R] = HD_DEBOUNCE;
|
|
OperationFault_flag |= 1<<FNR_ERROR_R_POS;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
OperationFault_counter[FNR_STATE_R] = 0;
|
|
//OperationFault_flag &= ~(1<<FNR_ERROR_R_POS);
|
|
}
|
|
|
|
break;
|
|
case FNR_STATE_F:
|
|
case FNR_STATE_R:
|
|
if (adval[FNR_STATE_N] < 20 && adval[FNR_STATE_F] > 1000 && adval[FNR_STATE_R] > 1000 && lock_state == LOCK_STATE_UNLOCKED)
|
|
{
|
|
fnr_counter[FNR_STATE_N]++;
|
|
if (fnr_counter[FNR_STATE_N] > HD_DEBOUNCE)
|
|
{
|
|
g_fnr_state = FNR_STATE_N;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
fnr_counter[FNR_STATE_N] = 0;
|
|
}
|
|
break;
|
|
default:
|
|
g_fnr_state = FNR_STATE_N;
|
|
break;
|
|
}
|
|
|
|
|
|
txbuf1[0] = adval[FNR_STATE_F]<50?0:1;
|
|
txbuf1[1] = adval[FNR_STATE_N]<50?0:1;
|
|
txbuf1[2] = adval[FNR_STATE_R]<50?0:1;
|
|
|
|
}
|
|
|
|
void PowerUpDetect(void)//10ms
|
|
{
|
|
static uint8_t count=0,powerupdelay=0;
|
|
uint16_t adval = 0;
|
|
uint8_t errbit = 0;
|
|
|
|
if (powerupdelay < 50)
|
|
{
|
|
powerupdelay++;
|
|
return;
|
|
}
|
|
|
|
|
|
PowerUp_FNR_Error_flag = 0;
|
|
|
|
//errbit = GetIOState(SIGID_SW_L_IN);
|
|
//PowerUp_FNR_Error_flag |= errbit<<FNR_ERROR_HL_POS;
|
|
|
|
errbit = GetIOState(SIGID_SW_P_IN);
|
|
PowerUp_FNR_Error_flag |= errbit<<FNR_ERROR_P_POS;
|
|
|
|
adval = getAdval(ADCH_HALL_F);
|
|
errbit = adval<50?1:0;
|
|
PowerUp_FNR_Error_flag |= errbit<<FNR_ERROR_F_POS;
|
|
|
|
adval = getAdval(ADCH_HALL_N);
|
|
errbit = adval<50?0:1;
|
|
PowerUp_FNR_Error_flag |= errbit<<FNR_ERROR_N_POS;
|
|
|
|
adval = getAdval(ADCH_HALL_R);
|
|
errbit = adval<50?1:0;
|
|
PowerUp_FNR_Error_flag |= errbit<<FNR_ERROR_R_POS;
|
|
|
|
if (PowerUp_FNR_Error_flag == 0)
|
|
{
|
|
count++;
|
|
if (count>=5)
|
|
{
|
|
PowerUpDetect_flag = 1;
|
|
count = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
count = 0;
|
|
}
|
|
|
|
}
|
|
|
|
void P_light_task(void)
|
|
{
|
|
static uint8_t counter;
|
|
switch (P_light_rcv)
|
|
{
|
|
case 0:
|
|
case 1:
|
|
case 2:
|
|
P_light_Ctrl(P_light_rcv);
|
|
counter=0;
|
|
break;
|
|
case 3:
|
|
counter++;
|
|
if (counter<11)
|
|
{
|
|
P_light_Ctrl(P_LIGHT_RED);
|
|
}
|
|
else if (counter<23)
|
|
{
|
|
P_light_Ctrl(P_LIGHT_YELLOE);
|
|
}
|
|
else
|
|
{
|
|
counter = 0;
|
|
}
|
|
break;
|
|
default:
|
|
counter=0;
|
|
P_light_Ctrl(0);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void IND_task(void)
|
|
{
|
|
static uint8_t counter=0;
|
|
|
|
if (counter < 7)
|
|
{
|
|
IND_Ctrl(g_fnr_state);
|
|
}
|
|
else
|
|
{
|
|
IND_Ctrl(FNR_ALL_LIGHT);
|
|
}
|
|
counter++;
|
|
if (counter > 9)
|
|
{
|
|
counter = 0;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void KeyPro(void)
|
|
{
|
|
//按下
|
|
if (getKeyPressFlag(SIGID_SW_LOCK_IN) == KEY_PRESSED)
|
|
{
|
|
lock_state = LOCK_STATE_UNLOCKED;
|
|
}
|
|
if (getKeyPressFlag(SIGID_SW_L_IN) == KEY_PRESSED)
|
|
{
|
|
lkey_state = 1;
|
|
}
|
|
if (getKeyPressFlag(SIGID_SW_P_IN) == KEY_PRESSED)
|
|
{
|
|
Pkey_state = !Pkey_state;
|
|
//RE1LED_CTRL(Pkey_state);
|
|
}
|
|
if (getKeyPressFlag(SIGID_SW_RE2) == KEY_PRESSED)
|
|
{
|
|
re2key_state = !re2key_state;
|
|
RE2LED_CTRL(re2key_state);
|
|
}
|
|
|
|
//释放
|
|
if (getKeyReleaseFlag(SIGID_SW_LOCK_IN) == KEY_PRESSED)
|
|
{
|
|
lock_state = LOCK_STATE_LOCKED;
|
|
}
|
|
if (getKeyReleaseFlag(SIGID_SW_L_IN) == KEY_PRESSED)
|
|
{
|
|
lkey_state = 0;
|
|
}
|
|
|
|
|
|
}
|
|
|
|
void Can_Msg_Change(void)
|
|
{
|
|
//CAN_45A.Msg_Part.SCM_PsngrSeatBeltWarnSts = sbrWarnState;
|
|
CAN_188.Msg_Part.SL_Fswitch = (g_fnr_state == FNR_STATE_F)?1:0;
|
|
CAN_188.Msg_Part.SL_Hswitch = 0;//(g_lh_state == LH_STATE_H)?1:0;
|
|
CAN_188.Msg_Part.SL_Lswitch = 0;//(g_lh_state == LH_STATE_L)?1:0;
|
|
CAN_188.Msg_Part.SL_Nswitch = (g_fnr_state == FNR_STATE_N)?1:0;
|
|
CAN_188.Msg_Part.SL_Rswitch = (g_fnr_state == FNR_STATE_R)?1:0;
|
|
CAN_188.Msg_Part.switch1 = Pkey_state;
|
|
CAN_188.Msg_Part.switch2 = re2key_state;
|
|
CAN_188.Msg_Part.Reserve_1 = 0;
|
|
CAN_188.Msg_Part.F_OP = g_f_op;
|
|
CAN_188.Msg_Part.N_OP = g_n_op;
|
|
CAN_188.Msg_Part.R_OP = g_r_op;
|
|
CAN_188.Msg_Part.err1 = 0;//20240815delete
|
|
CAN_188.Msg_Part.err2 = PowerUp_FNR_Error_flag&(1<<FNR_ERROR_F_POS)?1:0;
|
|
CAN_188.Msg_Part.err3 = PowerUp_FNR_Error_flag&(1<<FNR_ERROR_N_POS)?1:0;
|
|
CAN_188.Msg_Part.err4 = PowerUp_FNR_Error_flag&(1<<FNR_ERROR_R_POS)?1:0;
|
|
CAN_188.Msg_Part.err5 = OperationFault_flag&(1<<FNR_ERROR_F_POS)?1:0;
|
|
CAN_188.Msg_Part.err6 = 0;
|
|
CAN_188.Msg_Part.err7 = OperationFault_flag&(1<<FNR_ERROR_R_POS)?1:0;
|
|
CAN_188.Msg_Part.err8 = PowerUp_FNR_Error_flag&(1<<FNR_ERROR_P_POS)?1:0;
|
|
CAN_188.Msg_Part.CRC = CRC_Calc_Table(CAN_188.Msg_Byte,7);
|
|
}
|
|
|
|
void EEL_READ(void)
|
|
{
|
|
|
|
|
|
}
|
|
|
|
#define SC_500MS_PC_1MS 500
|
|
|
|
void EEL_WRITE(void)
|
|
{
|
|
|
|
}
|
|
|
|
void EEL_Write_Enable_Check(void)
|
|
{
|
|
//EEL_SAVE_ENABLE = 1;
|
|
}
|
|
|
|
void DID_data_save_init(void)
|
|
{
|
|
unsigned char DID_init_Buf[33], i;
|
|
ReadFlashData(DID_init_Buf, 0x000F1000 + 0x400, 1);
|
|
|
|
if (DID_init_Buf[0] == 0xff)
|
|
{
|
|
for (i = 0; i < 33; i++)
|
|
{
|
|
if (i < 8)
|
|
{
|
|
DID_init_Buf[i] = DID_0xF110_VehicleNetworkConfiguration[i];
|
|
}
|
|
else if (i < 25)
|
|
{
|
|
DID_init_Buf[i] = DID_0xF190_vehicleIdentificationNumber[i - 8];
|
|
}
|
|
else if (i < 33)
|
|
{
|
|
DID_init_Buf[i] = DID_0xF197_SystemNameOrEngineType[i - 25];
|
|
}
|
|
}
|
|
WriteDataflash(DID_init_Buf, 0x000F1000 + 0x400, 33);
|
|
}
|
|
ReadFlashData(DID_init_Buf, 0x000F1000 + 0x800, 1);
|
|
if (DID_init_Buf[0] == 0xff)
|
|
{
|
|
for (i = 0; i < 32; i++)
|
|
{
|
|
if (i < 16)
|
|
{
|
|
DID_init_Buf[i] = DID_0xF198_RepairShopCodeOrTesterSerialNumber[i];
|
|
}
|
|
else if (i < 20)
|
|
{
|
|
DID_init_Buf[i] = DID_0xF199_ProgrammingOrConfigurationDate[i - 16];
|
|
}
|
|
else if (i < 24)
|
|
{
|
|
DID_init_Buf[i] = DID_0xF19D_ECUInstallationDateDataIdentifier[i - 20];
|
|
}
|
|
else if (i < 32)
|
|
{
|
|
DID_init_Buf[i] = DID_0xF112_VehicleName[i - 24];
|
|
}
|
|
}
|
|
WriteDataflash(DID_init_Buf, 0x000F1000 + 0x800, 32);
|
|
}
|
|
}
|
|
|
|
unsigned char BusOffTimeCnt = 0;
|
|
unsigned short BusOff1msCnt = 0;
|
|
unsigned char CanBusOffPro(void)
|
|
{
|
|
unsigned char ret = 0;
|
|
if (C0ERFLLL & 0x08) // Bus-Off Stutas
|
|
{
|
|
ret = 1;
|
|
}
|
|
if ((C0CTRLL & 0x02) == 0x02) // Channal Halt Mode
|
|
{
|
|
|
|
if (C0ERFLLL & 0x08) // Bus-Off Stutas
|
|
{
|
|
BusOff1msCnt++;
|
|
ret = 1;
|
|
}
|
|
|
|
if ((BusOffTimeCnt < 10) && (BusOff1msCnt >= 100))
|
|
{
|
|
BusOffTimeCnt++;
|
|
BusOff1msCnt = 0;
|
|
C0ERFLL = 0;
|
|
C0CTRL &= ~0x03; /* CHMDC[1:0] = 00B change to communication mode. */
|
|
}
|
|
else if ((BusOffTimeCnt >= 10) && (BusOff1msCnt >= 1000))
|
|
{
|
|
BusOffTimeCnt = 10;
|
|
BusOff1msCnt = 0;
|
|
C0ERFLL = 0;
|
|
C0CTRL &= ~0x03; /* CHMDC[1:0] = 00B change to communication mode. */
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
#define FAST_BUSOFF_THRESHOULD 100 // 100MS
|
|
#define SLOW_BUSOFF_THRESHOULD 1000 // 100MS
|
|
|
|
void BusOff_Recovery(void);
|
|
|
|
void BusOff_Detect(void)
|
|
{
|
|
|
|
if ((C0ERFLL & 0x08) && (R_CAN_ReadChStatus_CH0() & 0x02))
|
|
{
|
|
|
|
if (uiBusOffCnt == 0)
|
|
{
|
|
if (ucBusOffModeState == 0)
|
|
{
|
|
uiBusOffCnt = FAST_BUSOFF_THRESHOULD;
|
|
// BusOff_Recovery();
|
|
}
|
|
if ((ucBusOffModeState > 0) && (ucBusOffModeState < 5))
|
|
{
|
|
BusOff_Recovery();
|
|
uiBusOffCnt = FAST_BUSOFF_THRESHOULD; //fast recover
|
|
}
|
|
else if (ucBusOffModeState >= 5)
|
|
{
|
|
BusOff_Recovery();
|
|
uiBusOffCnt = SLOW_BUSOFF_THRESHOULD; //soft recover
|
|
}
|
|
else
|
|
{
|
|
;
|
|
}
|
|
if (ucBusOffModeState < 5)
|
|
{
|
|
ucBusOffModeState++;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (ucBusOffModeState > 0)
|
|
{
|
|
if (uiBusOffCnt == 0)
|
|
{
|
|
ucBusOffModeState = 0;
|
|
|
|
// 原来程序的标志位
|
|
}
|
|
}
|
|
else
|
|
{
|
|
;
|
|
}
|
|
BusOff_flag = 0;
|
|
}
|
|
}
|
|
|
|
void BusOff_Recovery(void)
|
|
{
|
|
CFCCL0L &= ~0x01;
|
|
NOP();
|
|
CFCCL0L |= 0x01;
|
|
if (C0ERFLL != 0)
|
|
{
|
|
C0ERFLL = 0;
|
|
}
|
|
C0CTRL &= 0xfffc; // bus off
|
|
}
|
|
uint16_t SupplyVoltage;
|
|
uint32_t IGN_Voltage;
|
|
void IGN_Voltage_Detect(void)//20ms
|
|
{
|
|
uint32_t adval;
|
|
adval = getAdval(ADCH_IGN);
|
|
SupplyVoltage = (adval*57*5)>>10; //100mV
|
|
//adval / 1024 * 5 * 5.7
|
|
IGN_Voltage = ((adval*57*500)>>10) + 700;//1mv
|
|
if (IGN_Voltage <= 8500 )
|
|
{
|
|
IGN_Voltage_error_count++;
|
|
if (IGN_Voltage_error_count >= 250)
|
|
{
|
|
IGN_Voltage_error_count = 250;
|
|
IGN_Voltage_error_flag = 1;
|
|
}
|
|
}
|
|
else if (IGN_Voltage >= 16500 )//16.5
|
|
{
|
|
IGN_Voltage_error_count++;
|
|
if (IGN_Voltage_error_count >= 250)
|
|
{
|
|
IGN_Voltage_error_count = 250;
|
|
IGN_Voltage_error_flag = 2;
|
|
}
|
|
}
|
|
else if (IGN_Voltage >= 9000 && IGN_Voltage <= 16000)
|
|
{
|
|
if (IGN_Voltage_error_count > 0)
|
|
{
|
|
IGN_Voltage_error_count--;
|
|
}
|
|
else
|
|
{
|
|
IGN_Voltage_error_count = 0;
|
|
IGN_Voltage_error_flag = 0;
|
|
}
|
|
}
|
|
|
|
|
|
if (IGN_Voltage_error_flag != 0)
|
|
{
|
|
// TAU0_Channel1_ChangeDuty(0);
|
|
}
|
|
}
|
|
|
|
|
|
void value_init(void)
|
|
{
|
|
|
|
CAN_LostCount = 500;
|
|
BusOff_Detect_delay_count = 2000;
|
|
ucIgnStus = IGN_OFF;
|
|
lock_state = LOCK_STATE_LOCKED;
|
|
lkey_state = 0;
|
|
g_fnr_state = FNR_STATE_N;
|
|
g_lh_state = LH_STATE_H;
|
|
PowerUpDetect_flag = 0;
|
|
P_light_rcv = 0;
|
|
}
|
|
void CAN_RX_Data_Handle(void)
|
|
{
|
|
P_light_rcv = CAN_189.Msg_Part.P_light;
|
|
|
|
}
|
|
|
|
|
|
void SleepDetect(void)
|
|
{
|
|
|
|
// if(CAN_LostCount==0 && IGN_Lost == 1)
|
|
{
|
|
|
|
R_TAU0_Channel0_Stop();
|
|
// R_TAU0_Channel2_Stop();
|
|
// R_TAU0_Channel6_Stop();
|
|
// R_TAU1_Channel0_Stop();
|
|
TO0 = 0;
|
|
TO1 = 0;
|
|
TOE0 = 0;
|
|
TOE1 = 0;
|
|
TO0 = 0;
|
|
TO1 = 0;
|
|
|
|
// R_IICA0_Stop();
|
|
R_ADC_Stop();
|
|
ADCE = 0;
|
|
IICA0EN = 0;
|
|
TAU0EN = 0;
|
|
TAU1EN = 0;
|
|
|
|
P6_bit.no2 = 0;
|
|
P6_bit.no3 = 0;
|
|
P12_bit.no0 = 0;
|
|
P3_bit.no3 = 0;
|
|
P1_bit.no3 = 0;
|
|
P1_bit.no4 = 0;
|
|
P3_bit.no0 = 0;
|
|
|
|
CAN_STB = 1;
|
|
|
|
C0CTRL |= (uint16_t)(CAN_STP_BIT_ON);
|
|
GCTRL |= 0x01;
|
|
NOP();
|
|
GCTRL |= (uint16_t)(CAN_GLB_STP_BIT_ON);
|
|
PLLON = 0;
|
|
//R_INTC3_Start();
|
|
CAN0WUPIF = 0U;
|
|
CAN0WUPMK = 0U;
|
|
|
|
if (I_IGN_SIGN != IGN_ON)
|
|
STOP();
|
|
|
|
WakeUP();
|
|
}
|
|
}
|
|
|
|
void WakeUP(void)
|
|
{
|
|
// stop can and ex interrupt
|
|
CAN0WUPIF = 0U;
|
|
CAN0WUPMK = 1U;
|
|
//R_INTC3_Stop();
|
|
// WDTE = 0xff; //reset
|
|
CAN_STB = 0;
|
|
hdwinit();
|
|
R_MAIN_UserInit();
|
|
R_TAU0_Channel0_Start(); // timer
|
|
|
|
|
|
}
|
|
|
|
void Signal_Lost_Detect(unsigned char Pin,
|
|
unsigned char Lost_state,
|
|
unsigned char *Signal_Lost,
|
|
unsigned char *Signal_Lost_count,
|
|
unsigned char Lost_time)
|
|
{
|
|
if (Pin == Lost_state)
|
|
{
|
|
(*Signal_Lost_count)++;
|
|
if ((*Signal_Lost_count) >= Lost_time)
|
|
{
|
|
*Signal_Lost_count = 0;
|
|
*Signal_Lost = 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
*Signal_Lost_count = 0;
|
|
*Signal_Lost = 0;
|
|
}
|
|
}
|
|
|
|
void IGN_Detect(void)
|
|
{
|
|
static unsigned char IGN_last;
|
|
Signal_Lost_Detect(I_IGN_SIGN, 1, &IGN_Lost, &IGN_Lost_Count, 5);
|
|
Signal_Lost_Detect(I_IGN_SIGN, 0, &IGN_On, &IGN_On_Count, 5);
|
|
|
|
if (IGN_On == 1)
|
|
{
|
|
ucIgnStus = IGN_ON;
|
|
}
|
|
else if (IGN_Lost == 1)
|
|
{
|
|
ucIgnStus = IGN_OFF;
|
|
|
|
PWN_KEY = 0;
|
|
}
|
|
if (IGN_last != ucIgnStus)
|
|
{
|
|
IGN_last = ucIgnStus;
|
|
if (IGN_ON == ucIgnStus)
|
|
C0CTRH &= ~0x0300; // 设置正常模式
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
/*****************diagnostic******************/
|
|
|
|
void getIGNVoltage(unsigned char* data)
|
|
{
|
|
data[0] = (uint8_t)SupplyVoltage;
|
|
}
|