791 lines
18 KiB
C
791 lines
18 KiB
C
#include "appTask.h"
|
|
#include "iodefine.h"
|
|
#include "extern.h"
|
|
#include "r_cg_adc.h"
|
|
#include "r_cg_intc.h"
|
|
#include "PINdef.h"
|
|
#include "hwCtrl.h"
|
|
|
|
#include "pfdl.h"
|
|
|
|
u8 can_data_init_flag = 0;
|
|
|
|
unsigned long Can_1ms_count_alive;
|
|
|
|
|
|
|
|
unsigned char IGN_Voltage_error_flag, IGN_Voltage_error_count;
|
|
|
|
|
|
volatile uint8_t flag_IIC_SendEnd;
|
|
volatile uint8_t flag_IIC_ReceiveEnd;
|
|
|
|
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;
|
|
uint8_t maxBusOffTimes;
|
|
/***************************************************/
|
|
static unsigned int EEL_SAVE_CNT_DOWN_TIMER;
|
|
static uint8_t EEL_SAVE_ENABLE;
|
|
|
|
MotorStateEE_Type MotorStateEE;
|
|
MotorStateEE_Type *pEE;
|
|
|
|
|
|
uint16_t VehicleSpeedRaw,VehicleSpeed;
|
|
|
|
uint8_t lockstate,sbrstate,sbrWarnState;
|
|
uint8_t nouse;//Relocation value is odd number
|
|
|
|
|
|
|
|
|
|
void Apply_task(void)
|
|
{
|
|
|
|
// DiagnosticSession_Present=MngDcm_GetDiagnosticSession();
|
|
App28sTxRxStatus = GetNormalMsgSts();
|
|
Nw28sTxRxStatus = GetNetworkMsgSts();
|
|
|
|
// DiagnosticSession_Present=MngDcm_GetDiagnosticSession();
|
|
|
|
if (Timer_1ms_flag == 1)
|
|
{
|
|
Timer_1ms_flag = 0;
|
|
MngDcm_MainFunction();
|
|
MngCanTp_MainFunction();
|
|
if(CAN_STB == 0 && uiBusOffCnt == 0)//Tx enable
|
|
{
|
|
TxServe();
|
|
}
|
|
if (BusOff_Detect_delay_count == 0 /*&& (ad_voltage_fact[2]>=85 && ad_voltage_fact[2]<=165)*/)
|
|
{
|
|
BusOff_Detect();
|
|
}
|
|
KeyScan();
|
|
XN_Scan();
|
|
if (EEL_SAVE_CNT_DOWN_TIMER > 0)
|
|
{
|
|
EEL_SAVE_CNT_DOWN_TIMER--;
|
|
}
|
|
Can_Msg_Change();
|
|
//IGN_Detect();
|
|
//CanNwHandle();
|
|
}
|
|
if (Timer_5ms_flag == 1)
|
|
{
|
|
Timer_5ms_flag = 0;
|
|
CAN_RX_Data_Handle();
|
|
/*
|
|
if (IGN_On == 1 && ucActiveWakeupBit != PASSIVE_WAKEUP)
|
|
KeyScan();
|
|
*/
|
|
|
|
KeyPro();
|
|
// IGN_Detect();
|
|
|
|
}
|
|
|
|
if (Timer_10ms_flag == 1)
|
|
{
|
|
Timer_10ms_flag = 0;
|
|
XN_Pro();
|
|
|
|
// BAT_Voltage_Detect();
|
|
// CanNwHandle();
|
|
}
|
|
if (Timer_20ms_flag == 1)
|
|
{
|
|
Timer_20ms_flag = 0;
|
|
IGN_Voltage_Detect();
|
|
|
|
}
|
|
if (Timer_50ms_flag == 1)
|
|
{
|
|
Timer_50ms_flag = 0;
|
|
//EEL_WRITE();
|
|
//TxTestMsg();
|
|
//SleepDetect();//TODO
|
|
}
|
|
}
|
|
|
|
uint8_t xn_counter,xn_tx_num;
|
|
uint8_t keyPressState = 0,keyLongPressState=0;
|
|
uint8_t btn_req,toggle_req,rotation_req;
|
|
uint8_t xn_state;
|
|
#define XN_STATE_INIT 0
|
|
#define XN_STATE_IDLE 1
|
|
#define XN_STATE_MIDDLE 2
|
|
#define XN_STATE_MIDDLE_2 3
|
|
#define XN_STATE_STOP 4
|
|
void XN_StateMachine(void)
|
|
{
|
|
static uint8_t xn_dir;
|
|
switch (xn_state)
|
|
{
|
|
case XN_STATE_INIT:
|
|
if (GetIOState(KEYID_XNM) == 1 && GetIOState(KEYID_XNP) == 1)
|
|
{
|
|
xn_state = XN_STATE_IDLE;
|
|
xn_dir = 0;
|
|
}
|
|
break;
|
|
case XN_STATE_IDLE:
|
|
if (GetIOState(KEYID_XNM) == 1 && GetIOState(KEYID_XNP) == 0)
|
|
{
|
|
xn_dir = 1;
|
|
xn_state = XN_STATE_MIDDLE;
|
|
}
|
|
else if (GetIOState(KEYID_XNM) == 0 && GetIOState(KEYID_XNP) == 1)
|
|
{
|
|
xn_dir = 2;
|
|
xn_state = XN_STATE_MIDDLE;
|
|
}
|
|
else
|
|
{
|
|
xn_dir = 0;
|
|
}
|
|
break;
|
|
case XN_STATE_MIDDLE:
|
|
if (GetIOState(KEYID_XNM) == 0 && GetIOState(KEYID_XNP) == 0)
|
|
{
|
|
xn_state = XN_STATE_MIDDLE_2;
|
|
}
|
|
else if ((GetIOState(KEYID_XNM) == 1 && GetIOState(KEYID_XNP) == 1))
|
|
{
|
|
xn_state = XN_STATE_IDLE;
|
|
}
|
|
break;
|
|
case XN_STATE_MIDDLE_2:
|
|
if (xn_dir == 1 && GetIOState(KEYID_XNM) == 0 && GetIOState(KEYID_XNP) == 1)
|
|
{
|
|
xn_state = XN_STATE_STOP;
|
|
}
|
|
else if (xn_dir == 2 && GetIOState(KEYID_XNM) == 1 && GetIOState(KEYID_XNP) == 0)
|
|
{
|
|
xn_state = XN_STATE_STOP;
|
|
}
|
|
else if ((GetIOState(KEYID_XNM) == 1 && GetIOState(KEYID_XNP) == 1))
|
|
{
|
|
xn_state = XN_STATE_IDLE;
|
|
}
|
|
break;
|
|
case XN_STATE_STOP:
|
|
if (GetIOState(KEYID_XNM) == 1 && GetIOState(KEYID_XNP) == 1)
|
|
{
|
|
xn_state = XN_STATE_IDLE;
|
|
if (xn_dir == 1)
|
|
{
|
|
xn_counter++;
|
|
}
|
|
else if (xn_dir == 2)
|
|
{
|
|
xn_counter--;
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
xn_state = 0;
|
|
break;
|
|
}
|
|
}
|
|
|
|
void XN_Scan(void)
|
|
{
|
|
if (keyPressState == KEY_NOPRESSED && keyLongPressState == KEY_NOPRESSED)
|
|
{
|
|
XN_StateMachine();
|
|
}
|
|
|
|
}
|
|
|
|
void XN_Pro(void)
|
|
{
|
|
static uint8_t xn_txstate = 0;
|
|
static uint8_t tx_counter = 0;
|
|
switch (xn_txstate)
|
|
{
|
|
case 0:
|
|
if (xn_counter != xn_tx_num)
|
|
{
|
|
xn_tx_num = xn_counter;
|
|
xn_txstate++;
|
|
ClearTxCounter();
|
|
tx_counter = 0;
|
|
}
|
|
break;
|
|
case 1:
|
|
tx_counter++;
|
|
if (tx_counter > 2)
|
|
{
|
|
xn_txstate++;
|
|
ClearTxCounter();
|
|
tx_counter = 0;
|
|
}
|
|
break;
|
|
case 2:
|
|
tx_counter++;
|
|
if (tx_counter > 2)
|
|
{
|
|
xn_txstate = 0;
|
|
ClearTxCounter();
|
|
tx_counter = 0;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
xn_txstate = 0;
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
#define KEY_LONGPRESS_500MS 100
|
|
void KeyPro(void)//5ms
|
|
{
|
|
uint8_t i,num,key;
|
|
static uint16_t keyPressCounter;
|
|
static uint8_t LastKey;
|
|
static uint8_t KeyProState = 0,KeyProCounter=0;
|
|
switch (KeyProState)
|
|
{
|
|
case 0:
|
|
keyLongPressState = 0;
|
|
keyPressState = 0;
|
|
for (i = 1; i < 6; i++)
|
|
{
|
|
key = GetKeyState(i);
|
|
if (key == KEY_Long_PRESSED)
|
|
{
|
|
keyLongPressState = i;
|
|
KeyProState = 1;
|
|
break;
|
|
}
|
|
key = getKeyReleaseFlag(i);
|
|
if (key == KEY_PRESSED)
|
|
{
|
|
keyPressState = i;
|
|
KeyProState = 5;
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
case 1://长按
|
|
if (keyLongPressState == KEYID_MIDDLE)
|
|
{
|
|
btn_req = 2;
|
|
toggle_req = 0;
|
|
}
|
|
else if (keyLongPressState > KEY_NOPRESSED && keyLongPressState < KEYID_MIDDLE)
|
|
{
|
|
btn_req = 0;
|
|
toggle_req = keyLongPressState+4;
|
|
}
|
|
ClearTxCounter();
|
|
KeyProState++;
|
|
KeyProCounter = 0;
|
|
break;
|
|
case 2://
|
|
KeyProCounter++;
|
|
if (KeyProCounter >= 4)
|
|
{
|
|
KeyProCounter = 0;
|
|
ClearTxCounter();
|
|
KeyProState++;
|
|
}
|
|
break;
|
|
case 3://
|
|
KeyProCounter++;
|
|
if (KeyProCounter >= 4)
|
|
{
|
|
KeyProCounter = 0;
|
|
ClearTxCounter();
|
|
KeyProState++;
|
|
}
|
|
break;
|
|
case 4://
|
|
for (i = 1; i < 6; i++)
|
|
{
|
|
key = GetKeyState(i);
|
|
if (key != KEY_NOPRESSED)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
if (i == 6)
|
|
{
|
|
KeyProState = 0;
|
|
btn_req = 0;
|
|
toggle_req = 0;
|
|
keyLongPressState = 0;
|
|
keyPressState = 0;
|
|
ClearKeyState();
|
|
}
|
|
break;
|
|
case 5:
|
|
if (keyPressState == KEYID_MIDDLE)
|
|
{
|
|
btn_req = 1;
|
|
toggle_req = 0;
|
|
}
|
|
else if (keyPressState > KEY_NOPRESSED && keyPressState < KEYID_MIDDLE)
|
|
{
|
|
btn_req = 0;
|
|
toggle_req = keyPressState;
|
|
}
|
|
ClearTxCounter();
|
|
KeyProState++;
|
|
KeyProCounter = 0;
|
|
|
|
break;
|
|
case 6://
|
|
KeyProCounter++;
|
|
if (KeyProCounter >= 4)
|
|
{
|
|
KeyProCounter = 0;
|
|
ClearTxCounter();
|
|
KeyProState++;
|
|
}
|
|
break;
|
|
case 7://
|
|
KeyProCounter++;
|
|
if (KeyProCounter >= 4)
|
|
{
|
|
KeyProCounter = 0;
|
|
ClearTxCounter();
|
|
KeyProState++;
|
|
}
|
|
break;
|
|
case 8://
|
|
btn_req = 0;
|
|
toggle_req = 0;
|
|
KeyProState = 0;
|
|
ClearKeyState();
|
|
break;
|
|
default:
|
|
KeyProState = 0;
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
void Can_Msg_Change(void)
|
|
{
|
|
//CAN_45A.Msg_Part.SCM_PsngrSeatBeltWarnSts = sbrWarnState;
|
|
CAN_212.Msg_Part.MSW_PsdBtnReq = btn_req;
|
|
CAN_212.Msg_Part.MSW_TogReq = toggle_req;
|
|
CAN_212.Msg_Part.MSW_BtnFltSts = 0;
|
|
CAN_212.Msg_Part.MSW_RotStep = xn_tx_num;
|
|
//CAN_212.Msg_Part.Reserve_7 = 0;//maxBusOffTimes;
|
|
}
|
|
|
|
static uint8_t EEL_BUF[50];
|
|
void EEL_READ(void)
|
|
{
|
|
uint16_t checksum;
|
|
uint8_t *src,*des,i;
|
|
ReadFlashData(EEL_BUF, 0x000F1000, sizeof(MotorStateEE));
|
|
pEE = (MotorStateEE_Type *)EEL_BUF;
|
|
checksum = pEE->kbsoft1 + pEE->kbsoft2 + pEE->kbnow + pEE->zysoft1 + pEE->zysoft2 + pEE->zynow;
|
|
if (pEE ->start == 0x55AA && pEE->stop == 0xAA55 && checksum == pEE->checksum)
|
|
{
|
|
des = &MotorStateEE;
|
|
src = EEL_BUF;
|
|
for (i = 0; i < sizeof(MotorStateEE); i++)
|
|
{
|
|
des[i] = src[i];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
MotorStateEE.start = 0x55AA;
|
|
MotorStateEE.stop = 0xAA55;
|
|
MotorStateEE.kbnow = 0x8000;
|
|
MotorStateEE.kbsoft1 = 0;
|
|
MotorStateEE.kbsoft2 = 0;
|
|
MotorStateEE.zynow = 0x8000;
|
|
MotorStateEE.zysoft1 = 0;
|
|
MotorStateEE.zysoft2 = 0;
|
|
EEL_Write_Enable_Check();
|
|
}
|
|
|
|
}
|
|
|
|
#define SC_500MS_PC_1MS 500
|
|
|
|
void EEL_WRITE(void)
|
|
{
|
|
static unsigned char EEL_SAVE_REQUIRE_FLAG=0;
|
|
uint8_t i,*p;
|
|
if (EEL_SAVE_ENABLE)
|
|
{
|
|
EEL_SAVE_REQUIRE_FLAG = 1;
|
|
EEL_SAVE_CNT_DOWN_TIMER = SC_500MS_PC_1MS;
|
|
EEL_SAVE_ENABLE = 0;
|
|
}
|
|
|
|
if (0 == EEL_SAVE_CNT_DOWN_TIMER && 1 == EEL_SAVE_REQUIRE_FLAG)
|
|
{
|
|
MotorStateEE.checksum = MotorStateEE.kbsoft1 + MotorStateEE.kbsoft2 + MotorStateEE.kbnow + MotorStateEE.zysoft1 + MotorStateEE.zysoft2 + MotorStateEE.zynow;
|
|
p = &MotorStateEE;
|
|
for (i = 0; i < sizeof(MotorStateEE); i++)
|
|
{
|
|
EEL_BUF[i] = p[i];
|
|
}
|
|
|
|
if(WriteDataflash(EEL_BUF,0x000F1000,sizeof(MotorStateEE)) == 0x11)
|
|
{
|
|
EEL_SAVE_REQUIRE_FLAG=0;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
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);
|
|
}
|
|
}
|
|
|
|
uint8_t checkBusOff(void)
|
|
{
|
|
if ( (C0ERFLL & 0x08) )// && (R_CAN_ReadChStatus_CH0() & 0x02)
|
|
{
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
uint8_t checkExitBusOff(void)
|
|
{
|
|
if ( (C0STSL & 0x10) == 0x10 )
|
|
{
|
|
//C0ERFLL &= ~0x10;
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
#define FAST_BUSOFF_THRESHOULD 49 // 50MS
|
|
#define SLOW_BUSOFF_THRESHOULD 199 // 200MS
|
|
|
|
void BusOff_Recovery(void);
|
|
#define BUSOFF_INIT 0
|
|
#define BUSOFF_IDLE 1
|
|
#define BUSOFF_WAIT 2
|
|
#define BUSOFF_RECOVER 3
|
|
void BusOff_Detect(void)
|
|
{
|
|
static uint8_t netState=0,count;
|
|
static uint16_t powerupdelay=0;
|
|
switch (netState)
|
|
{
|
|
case BUSOFF_INIT:
|
|
powerupdelay++;
|
|
if (powerupdelay > 1000)
|
|
{
|
|
netState = BUSOFF_IDLE;
|
|
}
|
|
break;
|
|
case BUSOFF_IDLE:
|
|
if (checkBusOff())
|
|
{
|
|
BusOff_flag = 1;
|
|
netState = BUSOFF_WAIT;
|
|
if (ucBusOffModeState < 5)
|
|
{
|
|
ucBusOffModeState++;
|
|
uiBusOffCnt = FAST_BUSOFF_THRESHOULD;
|
|
}
|
|
else
|
|
{
|
|
if (ucBusOffModeState < 8)
|
|
{
|
|
ucBusOffModeState++;
|
|
}
|
|
|
|
uiBusOffCnt = SLOW_BUSOFF_THRESHOULD; //soft recover
|
|
}
|
|
BusOff_Recovery();
|
|
air_req_timer = 0;
|
|
}
|
|
break;
|
|
case BUSOFF_WAIT:
|
|
if (uiBusOffCnt == 0)
|
|
{
|
|
netState = BUSOFF_RECOVER;
|
|
count = 0;
|
|
}
|
|
break;
|
|
case BUSOFF_RECOVER:
|
|
maxBusOffTimes = ucBusOffModeState;
|
|
if (BusOff_flag == 0 )
|
|
{
|
|
if (checkExitBusOff() == 1)
|
|
{
|
|
//ucBusOffModeState = 0;
|
|
}
|
|
netState = BUSOFF_IDLE;
|
|
}
|
|
break;
|
|
default:
|
|
netState = BUSOFF_INIT;
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
void BusOff_Recovery(void)
|
|
{
|
|
CFCCL0L &= ~0x01;
|
|
NOP();
|
|
CFCCL0L |= 0x01;
|
|
if (C0ERFLL != 0)
|
|
{
|
|
C0ERFLL = 0;
|
|
}
|
|
C0CTRL &= 0xfffc; // bus off
|
|
}
|
|
uint16_t SupplyVoltage;
|
|
void IGN_Voltage_Detect(void)
|
|
{
|
|
uint32_t adval;
|
|
adval = getAdval(ADCH_IGN);
|
|
SupplyVoltage = (adval*57*5)>>10 + 7;
|
|
if (adval <= 305 )
|
|
{
|
|
IGN_Voltage_error_count++;
|
|
if (IGN_Voltage_error_count >= 250)
|
|
{
|
|
IGN_Voltage_error_count = 0;
|
|
IGN_Voltage_error_flag = 1;
|
|
}
|
|
}
|
|
else if (adval >= 592 )//16.5
|
|
{
|
|
IGN_Voltage_error_count++;
|
|
if (IGN_Voltage_error_count >= 250)
|
|
{
|
|
IGN_Voltage_error_count = 0;
|
|
IGN_Voltage_error_flag = 2;
|
|
}
|
|
}
|
|
else if (adval >= 323 && adval <= 574)
|
|
{
|
|
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 = 500;
|
|
ucIgnStus = IGN_OFF;
|
|
}
|
|
void CAN_RX_Data_Handle(void)
|
|
{
|
|
|
|
VehicleSpeedRaw = CAN_403.Msg_Bit.VCU_VehSpd1;
|
|
VehicleSpeedRaw <<= 8;
|
|
VehicleSpeedRaw |= CAN_403.Msg_Bit.VCU_VehSpd2;
|
|
VehicleSpeedRaw <<= 2;
|
|
VehicleSpeedRaw |= CAN_403.Msg_Bit.VCU_VehSpd3;
|
|
|
|
VehicleSpeed = VehicleSpeedRaw>>4;
|
|
}
|
|
|
|
|
|
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; // 设置正常模式
|
|
}
|
|
}
|
|
|
|
void LED_Light_Ctrl(void)
|
|
{
|
|
|
|
}
|
|
|
|
|
|
/*****************diagnostic******************/
|
|
|
|
void getIGNVoltage(unsigned char* data)
|
|
{
|
|
data[0] = (uint8_t)SupplyVoltage;
|
|
}
|