hosu9690/K2_DCU
Template
1
0
Fork 0
Code Issues Pull Requests 1 Packages Projects Releases Wiki Activity

first commit

Browse Source
This commit is contained in:
HosuKim
2026-04-14 00:43:29 +09:00
commit 28740cdb3b
10 changed files with 7476 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1436
Source/Comm.c Normal file
View File

File diff suppressed because it is too large Load Diff

696
Source/Comm.h Normal file
View File

@@ -0,0 +1,696 @@
#ifndef SOURCE_COMM_H_
#define SOURCE_COMM_H_
typedef struct ClassCommCheck
{
Uint16 CarComputer;
Uint16 Gcu;
Uint16 Ecu;
} CCommCheck;
typedef struct ClassTx100
{
/* BYTE 0~1 */
Uint16 Heartbit;
/* BYTE 2~4 Reserved */
/* BYTE 5 */
Uint16 VersionMajor;
/* BYTE 6 */
Uint16 VersionMinor;
/* BYTE 7 */
Uint16 VersionPatch;
} CTx100;
typedef struct ClassTx101
{
/* BYTE 0 */
Uint16 PlayState; // 0~3 bit
/* BYTE 1 */
Uint16 DcuState; // bit 0:AlarmOccured, 1:Emergency, 2:PowerSwitch, 3:EcuFailSafe
/* BYTE 2~7 Reserved */
} CTx101;
typedef struct ClassTx102
{
/* BYTE 0 */
Uint16 GcuCommand; // bit 0~3:PlayCommand, 4:FaultReset, 5:Emergency
/* BYTE 1~7 Reserved */
} CTx102;
typedef struct ClassTx103
{
/* BYTE 0 */
Uint16 EngineStart;
/* BYTE 1 */
Uint16 EngineStop;
/* BYTE 2 */
Uint16 FaultReset;
/* BYTE 3 Reserved */
/* BYTE 4~5 */
Uint16 RpmSetpoint;
/* BYTE 6 */
Uint16 ActiveOverride;
/* BYTE 7 */
Uint16 EmergencyStop;
} CTx103;
typedef struct ClassTx110
{
/* BYTE 0~3 */
Uint16 DcuFaultB0;
Uint16 DcuFaultB1;
Uint16 DcuFaultB2;
Uint16 DcuFaultB3;
/* BYTE 4~7 - Reserved */
} CTx110;
typedef struct ClassTx120
{
/* BYTE 0 */
Uint16 AuxTotal; // bit 0:EngineHeater, 1:GlowPlug, 2:Solenoid, 3:FuelPump, 4:CoolantPump, 5:Fan1, 6:Fan2
/* BYTE 1~7 - Reserved */
} CTx120;
typedef struct ClassTx121
{
/* BYTE 0~1 */
Uint16 EngHeatVoltage;
/* BYTE 2~3 */
Uint16 EngHeatCurrent;
/* BYTE 4~5 */
Uint16 GlowPlugVoltage;
/* BYTE 6~7 */
Uint16 GlowPlugCurrent;
} CTx121;
typedef struct ClassTx122
{
/* BYTE 0~1 */
Uint16 SolenoidVoltage;
/* BYTE 2~3 */
Uint16 SolenoidCurrent;
/* BYTE 4~5 */
Uint16 FuelPumpVoltage;
/* BYTE 6~7 */
Uint16 FuelPumpCurrent;
} CTx122;
typedef struct ClassTx123
{
/* BYTE 0~1 */
Uint16 CoolantPumpVoltage;
/* BYTE 2~3 */
Uint16 CoolantPumpCurrent;
/* BYTE 4~5 */
Uint16 Fan1Voltage;
/* BYTE 6~7 */
Uint16 Fan1Current;
} CTx123;
typedef struct ClassTx124
{
/* BYTE 0~1 */
Uint16 Fan2Voltage;
/* BYTE 2~3 */
Uint16 Fan2Current;
/* BYTE 4~7 - Reserved */
} CTx124;
typedef struct ClassRx200
{
/* BYTE 0~1 */
Uint16 HeartBit;
/* BYTE 2~4 - Reserved */
/* BYTE 5 */
Uint16 VersionMajor;
/* BYTE 6 */
Uint16 VersionMinor;
/* BYTE 7 */
Uint16 VersionPatch;
} CRx200;
typedef struct ClassRx201
{
/* BYTE 0 */
Uint16 PlayState; // 0:3 bit PlayState
/* BYTE 1 */
Uint16 State; // bit 0:AlarmOccured, 1:Shutdown
/* BYTE 2~7 - Reserved */
} CRx201;
typedef struct ClassRx210
{
/* BYTE 0~1 */
/*
* bit description
* 0:PcbOverHeat
* 1:FetOverHeat
* 2:GenOverHeat1
* 3:GenOverHeat2
*/
Uint16 GcuWarning;
/* BYTE 2~3 */
/*
* bit description
* 0:HwTrip
* 1:HwIgbt
* 2:HwDc
* 3:GenOverCurrentU
* 4:GenOverCurrentV
* 5:GenOverCurrentW
* 6:DcOverVoltage
* 7:DcOverCurrent
*
* 8:CrankningOverCurrent
* 9:PcbOverHeat
* 10:FetOverHeat
* 11:GenTempOverHeat1
* 12:GenTempOverHeat2
* 13:GenOverSpeed
* 14:ResolverIC
* 15:ResolverParity
*/
Uint16 GcuFault;
/* BYTE 4~7 - Reserved*/
} CRx210;
typedef struct ClassRx220
{
/* BYTE 0~1 */
Uint16 DcVoltage;
/* BYTE 2~3 */
Uint16 DcCurrent;
/* BYTE 4~5 */
Uint16 Rpm;
/* BYTE 6~7 */
Uint16 Power;
} CRx220;
typedef struct ClassRx221
{
/* BYTE 0 */
Uint16 PcbTemperature;
/* BYTE 1 */
Uint16 FetTemperature;
/* BYTE 2 */
Uint16 GenTemperature1;
/* BYTE 3 */
Uint16 GenTemperature2;
/* BYTE 4~7 - Reserved */
} CRx221;
typedef struct ClassRx300
{
/* BYTE 0 */
Uint16 VersionMajor;
/* BYTE 1 */
Uint16 VersionMinor;
/* BYTE 2 */
Uint16 VersionPatch;
/* BYTE 3~7 - Reserved */
} CRx300;
typedef struct ClassRx301
{
/* BYTE 0 */
/*
* bit description
* 0:AlarmOccured
* 1~3:PlayState
* 4:OverrideActive
* 5:GlowPlugActive
* 6:HeaterActive
* 7:OilPressureMissing
*/
Uint16 State;
/* BYTE 1~7 - Reserved */
} CRx301;
typedef struct ClassRx310
{
/* BYTE 0 */
/*
* bit description
* 0:EngineOverHeat
* 1:Reserved
* 2:LoOilPressure
* 3:IntakeOverHeat
* 4:IntakeLoPressure
* 5:EngineLoTemperature
* 6:EngineSensor
* 7:DefaltValueActive
*/
Uint16 EcuWarning;
/* BYTE 1 - Reserved */
/* BYTE 2 */
/*
* bit description
* 0:OilPressureMissing
* 1:IntakeOverHeat
* 2:EngineOverHeat
* 3:Actuator
* 4:RpmSignal
* 5:EngineStartFail
* 6:Reserved
* 7:Reserved
*/
Uint16 EcuFault;
/* BYTE 3~7 - Reserved */
} CRx310;
typedef struct ClassRx320
{
/* BYTE 0~1 */
Uint16 ActualRpm;
/* BYTE 2~3 */
Uint16 SetRpm;
/* BYTE 4 */
Uint16 ActualTorque;
/* BYTE 5 */
Uint16 SetTorque;
/* BYTE 6~7 */
Uint16 SystemVoltage;
} CRx320;
typedef struct ClassRx321
{
/* BYTE 0 */
Uint16 CoolantTemperature;
/* BYTE 1 */
Uint16 Fan1Speed;
/* BYTE 2 */
Uint16 Fan2Speed;
/* BYTE 3 */
Uint16 CoolantPumpSpeed;
/* BYTE 4~5 */
Uint16 BarometricPressure;
/* BYTE 6~7 - Reserved */
} CRx321;
typedef struct ClassRx322
{
/* BYTE 0~1 */
Uint16 TotalOperTimeL : 16;
/* BYTE 2~3 */
Uint16 TotalOperTimeH : 16;
/* BYTE 4~7 - Reserved*/
} CRx322;
typedef struct ClassTx700
{
/* BYTE 0~1 */
Uint16 HeartBit;
/* BYTE 2 */
Uint16 DCUversionMajor;
/* BYTE 3 */
Uint16 DCUversionMinor;
/* BYTE 4 */
Uint16 GCUversionMajor;
/* BYTE 5 */
Uint16 GCUversionMinor;
/* BYTE 6 */
Uint16 ECUversionMajor;
/* BYTE 7 */
Uint16 ECUversionMinor;
} CTx700;
typedef struct ClassTx701
{
/* BYTE 0 */
Uint16 DcuPlayState; // bit 0~3:PlayState
/* BYTE 1 */
/*
* bit description
* 0:DcuAlarmOccured
* 1:DcuEmergencyStop
* 2:PowerSwitchPush
* 3:EcuFailSafe
*/
Uint16 DcuState;
/* BYTE 2 */
Uint16 GcuPlayState; // bit 0~2:GcuPlayState
/* BYTE 3 */
/*
* bit description
* 0:GcuAlarmOccured
* 1:GcuShutdown
*/
Uint16 GcuState;
/* BYTE 4 */
/*
* bit description
* 0:EcuAlarmOccured
* 1~3:EcuPlayState
* 4:ActiveOverride
* 5:ActiveGlowPlug
* 6:ActiveEngHeater
* 7:OilPressureMissing
*/
Uint16 EcuState;
/* BYTE 5~7 - Reserved */
} CTx701;
typedef struct ClassTx710
{
/* BYTE 0 - GCU Warning */
/*
* bit description
* 0:PcbOverHeat
* 1:FetOverHeat
* 2:Winding1OverHeat
* 3:Winding2OverHeat
*/
Uint16 GcuWarning;
/* BYTE 1 - ECU Warning */
/*
* bit description
* 0:EngineOverHeat
* 1:Reserved
* 2:LoOilPressure
* 3:IntakeOverHeat
* 4:IntakeLoPressure
* 5:EngineLoTemperature
* 6:EngineSensorFault
* 7:DefaultValueActive
*/
Uint16 EcuWarning;
/* BYTE 2~7 - Reserved */
} CTx710;
typedef struct ClassTx720
{
/* BYTE 0~3 - DCU Fault */
Uint16 DcuFault0;
Uint16 DcuFault1;
Uint16 DcuFault2;
Uint16 DcuFault3;
/* BYTE 4~5 - GCU Fault */
Uint16 GcuFault0;
Uint16 GcuFault1;
/* BYTE 6 - Reserved */
/* BYTE 7 */
Uint16 EcuFault;
} CTx720;
typedef struct ClassTx730
{
/* BYTE 0 */
/*
* bit description
* 0:EngineHeater
* 1:GlowPlug
* 2:Solenoid
* 3:FuelPump
* 4:CoolantPump
* 5:Fan1
* 6:Fan2
* 7:Reserved
*/
Uint16 AuxState;
/* BYTE 1~7 - Reserved */
} CTx730;
typedef struct ClassTx731
{
/* BYTE 0~1 */
Uint16 EngineHeaterVoltage;
/* BYTE 2~3 */
Uint16 EngineHeaterCurrent;
/* BYTE 4~5 */
Uint16 GlowPlugVoltage;
/* BYTE 6~7 */
Uint16 GlowPlugCurrent;
} CTx731;
typedef struct ClassTx732
{
/* BYTE 0~1 */
Uint16 SolenoidVoltage;
/* BYTE 2~3 */
Uint16 SolenoidCurrent;
/* BYTE 4~5 */
Uint16 FuelPumpVoltage;
/* BYTE 6~7 */
Uint16 FuelPumpCurrent;
} CTx732;
typedef struct ClassTx733
{
/* BYTE 0~1 */
Uint16 CoolantPumpVoltage;
/* BYTE 2~3 */
Uint16 CoolantPumpCurrent;
/* BYTE 4~5 */
Uint16 Fan1Voltage;
/* BYTE 6~7 */
Uint16 Fan1Current;
} CTx733;
typedef struct ClassTx734
{
/* BYTE 0~1 */
Uint16 Fan2Voltage;
/* BYTE 2~3 */
Uint16 Fan2Current;
/* BYTE 4~7 - Reserved */
} CTx734;
typedef struct ClassTx740
{
/* BYTE 0~1 */
Uint16 Voltage;
/* BYTE 2~3 */
Uint16 Current;
/* BYTE 4~5 */
Uint16 Rpm;
/* BYTE 6~7 */
Uint16 Power;
} CTx740;
typedef struct ClassTx741
{
/* BYTE 0 */
Uint16 PcbTemperature;
/* BYTE 1 */
Uint16 FetTemperature;
/* BYTE 2 */
Uint16 Winding1Temperature;
/* BYTE 3 */
Uint16 Winding2Temperature;
/* BYTE 4~7 - Reserved */
} CTx741;
typedef struct ClassTx750
{
/* BYTE 0~1 */
Uint16 ActualRpm;
/* BYTE 2~3 */
Uint16 SetRpm;
/* BYTE 4 */
Uint16 ActualTorque;
/* BYTE 5 */
Uint16 SetTorque;
/* BYTE 6~7 */
Uint16 SystemVoltage;
} CTx750;
typedef struct ClassTx751
{
/* BYTE 0 */
Uint16 CoolantTemperature;
/* BYTE 1 */
Uint16 Fan1Speed;
/* BYTE 2 */
Uint16 Fan2Speed;
/* BYTE 3 */
Uint16 CoolantPumpSpeed;
/* BYTE 4~5 */
Uint16 Barometric;
/* BYTE 6~7 - Reserved */
} CTx751;
typedef struct ClassTx752
{
/* BYTE 0~1 */
Uint16 OperationTimeL;
/* BYTE 2~3 */
Uint16 OperationTimeH;
/* BYTE 4~7 - Reserved */
} CTx752;
interrupt void CECanInterruptA(void);
interrupt void CECanInterruptB(void);
void CSendECanDataA(void);
void CSendECanDataB(void);
void CInitEcan(void);
extern CCommCheck CommCheck;
extern CRx200 Rx200;
extern CRx210 Rx210;
extern CRx220 Rx220;
extern CRx221 Rx221;
extern CRx300 Rx300;
extern CRx301 Rx301;
extern CRx310 Rx310;
extern CRx320 Rx320;
extern CRx321 Rx321;
extern CRx322 Rx322;
typedef struct ClassRx400
{
struct
{
Uint16 BYTE0 : 8;
Uint16 BYTE1 : 8;
Uint16 BYTE2 : 8;
Uint16 BYTE3 : 8;
Uint16 BYTE4 : 8;
Uint16 BYTE5 : 8;
Uint16 BYTE6 : 8;
Uint16 BYTE7 : 8;
} Bytes;
struct
{
Uint16 EngineHeater : 1;
Uint16 GlowPlug : 1;
Uint16 Solenoid : 1;
Uint16 FuelPump : 1;
Uint16 CoolantPump : 1;
Uint16 Fan1 : 1;
Uint16 Fan2 : 1;
Uint16 AuxTestStart : 1;
Uint16 rsvd_padding : 8;
} AuxControl;
} CRx400;
extern CRx400 Rx400;
#endif /* SOURCE_COMM_H_ */

1979
Source/Display.c Normal file
View File

File diff suppressed because it is too large Load Diff

156
Source/Display.h Normal file
View File

@@ -0,0 +1,156 @@
#ifndef SOURCE_DISPLAY_H_
#define SOURCE_DISPLAY_H_
#define ZONE6_DAT *(volatile Uint16*)0x00100001
#define ZONE6_COM *(volatile Uint16*)0x00100000
#define OLED_WIDTH (128U) // ER-OLEDM024 Vertical Pixel 0~127
#define OLED_HEIGHT (64U)
#define OLED_PAGE (8U) // ER-OLEDM024 Page 0~7
#define TXT_ENG_WIDTH (6U)
#define TXT_ENG_HEIGHT (12U)
#define TXT_TYPE_ENG (0U)
#define TXT_TYPE_ETC (1U)
#define TXT_MAX_LEN (22U)
#define TXT_LINE_LEN (5U)
#define OLED_LOAD_PROGRESS_X (14U)
#define OLED_LOAD_PROGRESS_Y (52U)
#define OLED_LOAD_PROGRESS_W (114U)
#define OLED_LOAD_PROGRESS_H (10U)
#define MODE_COMMAND (0U)
#define MODE_DATA (1U)
#define DIR_UP (1U)
#define DIR_DOWN (0U)
typedef signed char int8;
typedef unsigned char Uint8;
typedef enum
{
IDX_OLED_LINE_TITLE = 0U,
IDX_OLED_LINE_1 = 14U,
IDX_OLED_LINE_2 = 27U,
IDX_OLED_LINE_3 = 40U,
IDX_OLED_LINE_4 = 53U
} E_IDX_OLED_LINE;
typedef enum
{
IDX_OLED_ROW_0 = 0U,
IDX_OLED_ROW_1,
IDX_OLED_ROW_2,
IDX_OLED_ROW_3,
IDX_OLED_ROW_4
} E_IDX_OLED_ROW;
typedef enum
{
IDX_OLED_PASS_DIGIT_1 = 0U,
IDX_OLED_PASS_DIGIT_2,
IDX_OLED_PASS_DIGIT_3,
IDX_OLED_PASS_DIGIT_4
} E_IDX_OLED_PASS;
typedef enum
{
IDX_OLED_PAGE_APU1 = 0U, // 0
IDX_OLED_PAGE_APU2, // 1
IDX_OLED_PAGE_MENU1, // 2
IDX_OLED_PAGE_MENU2, // 3
IDX_OLED_PAGE_TEMP, // 4
IDX_OLED_PAGE_SENSOR1, // 5
IDX_OLED_PAGE_SENSOR2, // 6
IDX_OLED_PAGE_SENSOR3, // 7
IDX_OLED_PAGE_SENSOR4, // 8
IDX_OLED_PAGE_WARNING1, // 9
IDX_OLED_PAGE_WARNING2, // 10
IDX_OLED_PAGE_FAULT1, // 11
IDX_OLED_PAGE_FAULT2, // 12
IDX_OLED_PAGE_FAULT3, // 13
IDX_OLED_PAGE_FAULT4, // 14
IDX_OLED_PAGE_FAULT5, // 15
IDX_OLED_PAGE_FAULT6, // 16
IDX_OLED_PAGE_FAULT7, // 17
IDX_OLED_PAGE_RESET_ALARM, // 18
IDX_OLED_PAGE_PASSWORD, // 19
IDX_OLED_PAGE_MAINTENANCE, // 20
IDX_OLED_PAGE_VERSION, // 21
IDX_OLED_PAGE_KEY_TEST, // 21
IDX_OLED_PAGE_SHUTDOWN, // 23
IDX_OLED_PAGE_MAX
} E_IDX_OLED_PAGE;
typedef enum
{
IDX_OLED_MENU_APU = 0U, // 0
IDX_OLED_MENU_TEMP, // 1
IDX_OLED_MENU_SENSOR, // 2
IDX_OLED_MENU_WARNING, // 3
} E_IDX_OLED_MENU1;
typedef enum
{
IDX_OLED_MENU_FAULT = 0U, // 0
IDX_OLED_MENU_RESET, // 1
IDX_OLED_MENU_DEBUG // 2
} E_IDX_OLED_MENU2;
typedef enum
{
IDX_OLED_LINE_FOCUS_1 = 0U,
IDX_OLED_LINE_FOCUS_2,
IDX_OLED_LINE_FOCUS_3,
IDX_OLED_LINE_FOCUS_4
} E_IDX_OLED_LINE_FOCUS;
typedef struct ClassPageHandler
{
Uint16 uiPage;
void (*pAction) (void); // PageTable 참조
} CPageHandler;
typedef struct ClassOledOperValue
{
Uint16 uiBuff[OLED_WIDTH][OLED_PAGE];
Uint16 uiPageNum;
Uint16 uiOldPageNum;
Uint16 uiFocusLine;
Uint16 uiPrevFocusLine;
Uint16 uiFocusDigit;
Uint16 uiProgressValue;
Uint16 uiProgressDone;
Uint16 uiResetAlarmAnswer;
Uint16 uiResetHourAnswer;
int8 cStrBuff[TXT_LINE_LEN][TXT_MAX_LEN];
int8 cAlignBuffer[TXT_MAX_LEN];
struct
{
Uint16 TxtColor;
Uint16 BgColor;
} Color;
struct
{
Uint16 X;
Uint16 Y;
} Point;
} COledOperValue;
void CInitXintf(void);
void CInitOled(void);
void COledReflash(Uint16 x, Uint16 y, Uint16 width, Uint16 height);
void CDisplayPostFail(void);
void CSetPage(Uint16 PageNum);
void CInitKeyOperValue(void);
void CInitializePage(void);
void COledBufferReset(void);
void CDisplayAntiNoiseRefresh(void);
extern COledOperValue OledOperValue;
#endif /* SOURCE_DISPLAY_H_ */

647
Source/Oper.c Normal file
View File

@@ -0,0 +1,647 @@
/* ========================================================================= */
/* 1. Includes */
/* ========================================================================= */
#include "main.h"
/* ========================================================================= */
/* 2. Local Macros & Constants (내부 전용 매크로 및 상수) */
/* ========================================================================= */
#define ENGINE_MAXIMUM_SPEED (2800U)
#define ENGINE_OPERATION_SPEED (2400U)
#define ENGINE_DIFF_SPEED (400U) // 2800 - 2400
// IDLE_SEQ_MOD
#define RPM_RAMP_START (1500U)
#define RPM_RAMP_END (2400U)
#define RPM_RAMP_RANGE (RPM_RAMP_END - RPM_RAMP_START) // 900
#define TIME_RAMP_UP (TIME_1SEC * 3UL) // 3초
#define LED_OFF (0U)
#define LED_ON (1U)
#define LED_BLINK (2U)
/* ========================================================================= */
/* 3. Local Typedefs & Structures (내부 전용 사용자 정의 자료형) */
/* ========================================================================= */
// No Code
/* ========================================================================= */
/* 4. Internal Linkage Function Declarations (내부 동작용 Static 함수 선언) */
/* ========================================================================= */
static void CInitialStandby(void);
static void CEmergencyStop(void);
static void CProcessApuStateReady(void);
static void CProcessApuStatePreheat(void);
static void CProcessApuStateCranking(void);
static void CProcessApuStateRetryCranking(void);
static void CProcessApuStateEngineIdle(void);
static void CProcessApuStateGenerating(void);
static void CProcessApuStateCooldown(void);
static void CProcessApuStateStopping(void);
static void CProcessApuStateTransition(void); // 비상/시동/정지 전이 판별용
static void CSetEngineActualRpm(Uint16 Rpm);
static float32 CGetGcuLoadPower(void);
static Uint16 CDynamicRpmControl(void);
static void CLedControl(Uint16 idx, Uint16 state);
/* ========================================================================= */
/* 5. Global Variables & Structure Initialization (전역 변수 및 구조체 초기화) */
/* ========================================================================= */
// No Code
/* ========================================================================= */
/* Function Definitions */
/* ========================================================================= */
static void CProcessApuStateReady(void)
{
// 냉각수 펌프 및 냉각팬 시작
CSetAuxCtrlPin(IDX_CS_COOLANT_PUMP, 1U);
CSetAuxCtrlPin(IDX_CS_FAN1, 1U);
CSetAuxCtrlPin(IDX_CS_FAN2, 1U);
// ECU 동작 명령 송신, 2400 RPM 설정
CSetEcuCommand((Uint16)IDX_ECU_CMD_START);
GeneralOperValue.uiApuState = (Uint16)IDX_APU_OPER_PREHEAT;
}
static void CProcessApuStatePreheat(void)
{
if (((Rx301.State >> 1U) & 0x07U) == (Uint16)IDX_ECU_STAT_STARTING)
{
GeneralOperValue.uiApuState = (Uint16)IDX_APU_OPER_CRANKING;
}
else
{
// PRE HEAT 상태가 60초 이상 지속 될 경우 알람처리
if (CSoftWaitCountProcedure(SOFTTIMER_WAIT_PREHEAT, TIME_60SEC) == (Uint16)TIME_OVER)
{
// 알람처리를 할지 무기한 대기 할 지 검토 필요
}
}
}
static void CProcessApuStateCranking(void)
{
CSetGcuCommand((Uint16)IDX_GCU_CMD_CRANKING);
if (((Rx301.State >> 1U) & 0x07U) == (Uint16)IDX_ECU_STAT_IDLE)
{
CSetGcuCommand((Uint16)IDX_GCU_CMD_STOP_CRANKING);
GeneralOperValue.uiApuState = (Uint16)IDX_APU_OPER_ENGINE_IDLE;
GeneralOperValue.uiRetryCrankingCount = 0U;
CSoftWaitCountClear(SOFTTIMER_WAIT_CRANKING);
}
else
{
// 10초간 시동 시도 → 5초 동안 휴식 → 3회 반복
if (CSoftWaitCountProcedure(SOFTTIMER_WAIT_CRANKING, TIME_10SEC) == (Uint16)TIME_OVER)
{
CSetGcuCommand((Uint16)IDX_GCU_CMD_STOP_CRANKING);
GeneralOperValue.uiApuState = (Uint16)IDX_APU_OPER_RETRY_CRANKING;
CSoftWaitCountClear(SOFTTIMER_WAIT_RETRY_CRANKING);
}
}
}
static void CProcessApuStateRetryCranking(void)
{
if (GeneralOperValue.uiRetryCrankingCount < 3U)
{
// 5초 대기 후 재시도
if (CSoftWaitCountProcedure(SOFTTIMER_WAIT_RETRY_CRANKING, (TIME_1SEC * 5UL)) == (Uint16)TIME_OVER)
{
GeneralOperValue.uiRetryCrankingCount++;
GeneralOperValue.uiApuState = (Uint16)IDX_APU_OPER_CRANKING;
CSoftWaitCountClear(SOFTTIMER_WAIT_CRANKING);
}
}
else
{
ulDcuTotalAlarm = (1UL << (Uint32)(Uint16)IDX_FAULT_DCU_CRANKING_FAIL);
}
}
static void CProcessApuStateEngineIdle(void)
{
#if 0 // '0' - 기존 코드, '1' - IDLE_SEQ_MOD
if (((Rx301.State >> 1U) & 0x07U) == (Uint16)IDX_ECU_STAT_OPERATION)
{
// 보조엔진제어기의 상태가 OPERATION이고 보조엔진의 속도가 2300 RPM 이상 5초 유지 시 발전상태로 전환
if (CGetEngineActualRpm() >= (ENGINE_OPERATION_SPEED - 100U)) // 2300 RPM
{
if (CSoftWaitCountProcedure(SOFTTIMER_WAIT_OPERATION, TIME_5SEC) == (Uint16)TIME_OVER)
{
GeneralOperValue.uiApuState = (Uint16)IDX_APU_OPER_GENERATING;
}
}
else
{
CSoftWaitCountClear(SOFTTIMER_WAIT_OPERATION);
}
}
#else
if (((Rx301.State >> 1U) & 0x07U) == (Uint16)IDX_ECU_STAT_OPERATION)
{
// ECU OPERATION 확인 즉시 발전 상태로 전환 (RPM Ramp는 CProcessApuStateGenerating에서 수행)
GeneralOperValue.ulRampStartClock = 0UL;
GeneralOperValue.uiApuState = (Uint16)IDX_APU_OPER_GENERATING;
}
#endif
}
static void CProcessApuStateGenerating(void)
{
#if 0 // '0' - 기존 코드, '1' - IDLE_SEQ_MOD
CSetGcuCommand((Uint16)IDX_GCU_CMD_GENERATING); // 발전 명령 송신
GeneralOperValue.uiDynamicRPM = CDynamicRpmControl();
CSetEngineActualRpm(GeneralOperValue.uiDynamicRPM); // RPM 가변 제어 시작
#else
Uint32 ulElapsed;
Uint16 uiRampRpm;
CSetGcuCommand((Uint16)IDX_GCU_CMD_GENERATING);
if (GeneralOperValue.uiRampComplete == 1U)
{
GeneralOperValue.uiDynamicRPM = CDynamicRpmControl();
CSetEngineActualRpm(GeneralOperValue.uiDynamicRPM);
}
else
{
if (GeneralOperValue.ulRampStartClock == 0UL)
{
GeneralOperValue.ulRampStartClock = CGetSoftClock();
CSetEngineActualRpm(RPM_RAMP_START);
}
else
{
ulElapsed = (CGetSoftClock() + SYSTEM_10MIN_TIME - GeneralOperValue.ulRampStartClock) % SYSTEM_10MIN_TIME;
if (ulElapsed < TIME_RAMP_UP)
{
uiRampRpm = (Uint16)(RPM_RAMP_START + (Uint16)(((Uint32)RPM_RAMP_RANGE * ulElapsed) / TIME_RAMP_UP));
CSetEngineActualRpm(uiRampRpm);
}
else
{
GeneralOperValue.uiRampComplete = 1U;
GeneralOperValue.uiDynamicRPM = CDynamicRpmControl();
CSetEngineActualRpm(GeneralOperValue.uiDynamicRPM);
}
}
}
#endif
}
static void CProcessApuStateCooldown(void)
{
Uint16 IsRpmZero;
Uint16 IsTimeout;
// 쿨다운: 발전 중지 -> 엔진 IDLE로 변경
CSetGcuCommand((Uint16)IDX_GCU_CMD_STOP);
CSetEcuCommand((Uint16)IDX_ECU_CMD_STOP);
IsRpmZero = (CGetEngineActualRpm() == 0U) ? 1U : 0U;
IsTimeout = (CSoftWaitCountProcedure(SOFTTIMER_WAIT_AFTER_COOLDOWN, TIME_60SEC) == 1U) ? 1U : 0U;
if ((IsRpmZero == 1U) || (IsTimeout == 1U))
{
GeneralOperValue.uiApuState = (Uint16)IDX_APU_OPER_STOPPING;
}
}
static void CProcessApuStateStopping(void)
{
if (GeneralOperValue.uiApuState == (Uint16)IDX_APU_OPER_STOPPING)
{
CInitialStandby();
GeneralOperValue.uiApuState = (Uint16)IDX_APU_OPER_STANDBY;
}
}
static void CProcessApuStateTransition(void)
{
if (GeneralOperValue.uiApuState == (Uint16)IDX_APU_OPER_EMERGENCY)
{
GeneralOperValue.uiApuState = (Uint16)IDX_APU_OPER_STANDBY;
CInitialStandby();
}
if (GeneralOperValue.uiApuState == (Uint16)IDX_APU_OPER_STANDBY)
{
if (KeyOperValue.KeyList.EngineStartStop == 1U)
{
GeneralOperValue.uiRetryCrankingCount = 0U;
if ((GeneralOperValue.Conection.Gcu == 1U) && (GeneralOperValue.Conection.Ecu == 1U))
{
GeneralOperValue.uiApuState = (Uint16)IDX_APU_OPER_READY;
}
else
{
CommCheck.Gcu = (GeneralOperValue.Conection.Gcu == 0U) ? COMM_TIME_OUT_COUNT : 0U;
CommCheck.Ecu = (GeneralOperValue.Conection.Ecu == 0U) ? COMM_TIME_OUT_COUNT : 0U;
}
}
}
else
{
if ((GeneralOperValue.uiApuState >= (Uint16)IDX_APU_OPER_READY) && (GeneralOperValue.uiApuState <= (Uint16)IDX_APU_OPER_GENERATING))
{
if (KeyOperValue.KeyList.EngineStartStop == 0U)
{
if (GeneralOperValue.uiApuState == (Uint16)IDX_APU_OPER_GENERATING)
{
GeneralOperValue.uiApuState = (Uint16)IDX_APU_OPER_COOLDOWN;
}
else
{
GeneralOperValue.uiApuState = (Uint16)IDX_APU_OPER_STOPPING;
}
}
}
}
}
void CApuOperProcedure(void)
{
// 입력 신호 Lo Active
Uint16 EngineHeaterSig = (GPIO_ENGINE_HEATER_ACTIVE() == false) ? 1U : 0U;
Uint16 FuelPumpSig = (GPIO_FUEL_PUMP_ACTIVE() == false) ? 1U : 0U;
Uint16 GlowPlugSig = (GPIO_GLOW_PLUG_ACTIVE() == false) ? 1U : 0U;
Uint16 SolenoidSig = (GPIO_SOLENOID_ACTIVE() == false) ? 1U : 0U;
Uint16 FailSafeSig = (GPIO_FAIL_SAFE_READ() == false) ? 1U : 0U;
// 비상 상황 체크
if ((GeneralOperValue.uiFaultOccured > 0U) || (KeyOperValue.KeyList.Emergency == 1U) || (FailSafeSig == 1U))
{
GeneralOperValue.uiApuState = (Uint16)IDX_APU_OPER_EMERGENCY;
CEmergencyStop();
}
else
{
// 외부 조작에 의한 상태 변경 확인
CProcessApuStateTransition();
// ECU Aux Bypass 제어
if (GeneralOperValue.uiApuState > (Uint16)IDX_APU_OPER_STANDBY)
{
CSetAuxCtrlPin(IDX_CS_ENG_HEATER, EngineHeaterSig);
CSetAuxCtrlPin(IDX_CS_GLOW_PLUG, GlowPlugSig);
CSetAuxCtrlPin(IDX_CS_SOLENOID, SolenoidSig);
CSetAuxCtrlPin(IDX_CS_FUEL_PUMP, FuelPumpSig);
}
// 각 상태별 동작 수행
switch (GeneralOperValue.uiApuState)
{
case (Uint16)IDX_APU_OPER_READY:
{
CProcessApuStateReady();
break;
}
case (Uint16)IDX_APU_OPER_PREHEAT:
{
CProcessApuStatePreheat();
break;
}
case (Uint16)IDX_APU_OPER_CRANKING:
{
CProcessApuStateCranking();
break;
}
case (Uint16)IDX_APU_OPER_RETRY_CRANKING:
{
CProcessApuStateRetryCranking();
break;
}
case (Uint16)IDX_APU_OPER_ENGINE_IDLE:
{
CProcessApuStateEngineIdle();
break;
}
case (Uint16)IDX_APU_OPER_GENERATING:
{
CProcessApuStateGenerating();
break;
}
case (Uint16)IDX_APU_OPER_COOLDOWN:
{
CProcessApuStateCooldown();
break;
}
default:
{
CProcessApuStateStopping();
break;
}
}
}
}
static Uint16 CDynamicRpmControl(void)
{
float32 TargetRPM;
Uint16 ReturnRpm;
if (GeneralOperValue.uiApuState == (Uint16)IDX_APU_OPER_GENERATING)
{
// 0.0kW~17.0kW 부하량에 따라 목표 RPM 실시간 계산
TargetRPM = (float32)ENGINE_OPERATION_SPEED + ((CGetGcuLoadPower() * 0.058823F) * (float32)ENGINE_DIFF_SPEED); // 0.058823 = 1/17kw
ReturnRpm = (Uint16)((float32)(TargetRPM + 0.5F)); // 소수점 반올림
}
else
{
// 발전 상태가 아닐 때는 기본 2400 RPM 반환
ReturnRpm = ENGINE_OPERATION_SPEED;
}
ReturnRpm = (ENGINE_MAXIMUM_SPEED > ReturnRpm) ? ReturnRpm : ENGINE_MAXIMUM_SPEED;
return ReturnRpm;
}
static void CInitialStandby(void)
{
CSetGcuCommand((Uint16)IDX_GCU_CMD_STOP);
CSetEcuCommand((Uint16)IDX_ECU_CMD_STOP);
COffChipSelect();
CSoftWaitCountClear(SOFTTIMER_WAIT_CRANKING);
CSoftWaitCountClear(SOFTTIMER_WAIT_RETRY_CRANKING);
CSoftWaitCountClear(SOFTTIMER_WAIT_PREHEAT);
CSoftWaitCountClear(SOFTTIMER_WAIT_PREHEAT);
CSoftWaitCountClear(SOFTTIMER_WAIT_OPERATION);
CSoftWaitCountClear(SOFTTIMER_WAIT_AFTER_COOLDOWN);
GeneralOperValue.uiEmergency = 0U;
GeneralOperValue.ulRampStartClock = 0UL; // IDLE_SEQ_MOD
GeneralOperValue.uiRampComplete = 0U; // IDLE_SEQ_MOD
GpioDataRegs.GPBCLEAR.bit.GPIO55 = 1U; // GPIO_FAULT_CMD
}
static void CEmergencyStop(void)
{
KeyOperValue.KeyList.EngineStartStop = 0U; // 비상정지 상황에서는 시동/정지 키 초기화
CSetGcuCommand((Uint16)IDX_GCU_CMD_STOP);
CSetEcuCommand((Uint16)IDX_ECU_CMD_EMERGENCY);
COffChipSelect();
CSoftWaitCountClear(SOFTTIMER_WAIT_CRANKING);
CSoftWaitCountClear(SOFTTIMER_WAIT_RETRY_CRANKING);
CSoftWaitCountClear(SOFTTIMER_WAIT_AFTER_COOLDOWN);
GeneralOperValue.uiEmergency = 1U;
GeneralOperValue.ulRampStartClock = 0UL; // IDLE_SEQ_MOD
GeneralOperValue.uiRampComplete = 0U; // IDLE_SEQ_MOD
GpioDataRegs.GPBSET.bit.GPIO55 = 1U; //GPIO_FAULT_CMD
}
static void CSetEngineActualRpm(Uint16 Rpm)
{
GeneralOperValue.EcuCommand.RpmSetPoint = Rpm;
}
Uint16 CGetEngineActualRpm(void)
{
return (Uint16)Rx320.ActualRpm;
}
static float32 CGetGcuLoadPower(void)
{
float32 power = ((float32)Rx220.Power * 0.1F);
// 범위를 0.0 ~ 17.0 으로 제한
if (power > 17.0F)
{
power = 17.0F;
}
else
{
if (power < 0.0F)
{
power = 0.0;
}
}
return power;
}
Uint16 CGetGeneratorRpm(void)
{
return Rx220.Rpm;
}
void CSetGcuCommand(Uint16 Command)
{
GeneralOperValue.GcuCommand.PlayCmd = Command;
}
void CSetEcuCommand(Uint16 Command)
{
if ((Command == (Uint16)IDX_ECU_CMD_STOP) || (Command == (Uint16)IDX_ECU_CMD_EMERGENCY))
{
GeneralOperValue.EcuCommand.EngineStart = 0U;
GeneralOperValue.EcuCommand.EngineStop = 1U;
CSetEngineActualRpm(0U);
}
else
{
// [ECU_OPER_CMD_START]
GeneralOperValue.EcuCommand.EngineStart = 1U;
GeneralOperValue.EcuCommand.EngineStop = 0U;
#if 0 // RPM 테스트
CSetEngineActualRpm(Rx400.SetRPM.PCAN_RPM);
#else
//CSetEngineActualRpm(2400U);
CSetEngineActualRpm(1500U); // Target Idle
#endif
}
}
int16 CGetEngCoolantTemperature(void)
{
return (int16) Rx321.CoolantTemperature - 40; // 온도 오프셋 -40도
}
void CDebugModeProcedure(void)
{
if (GeneralOperValue.Maintenance.ManualCranking == 1U)
{
if (GeneralOperValue.uiFaultOccured == 0U)
{
// 알람이 없을 경우만 동작 하도록 함.
CSetGcuCommand((Uint16)IDX_GCU_CMD_CRANKING);
}
}
else
{
CSetGcuCommand((Uint16)IDX_GCU_CMD_STOP);
}
if (GeneralOperValue.Maintenance.LampTest == 1U)
{
CLedControl(0U, 1U);
CLedControl(1U, 1U);
CLedControl(2U, 1U);
}
else
{
CLedControl(0U, 0U);
CLedControl(1U, 0U);
CLedControl(2U, 0U);
}
if (GeneralOperValue.Maintenance.KeyTest == 1U)
{
Uint16 uiKeyUp = (GPIO_KEY_UP() == 0U) ? 1U : 0U;
Uint16 uiKeyDn = (GPIO_KEY_DOWN() == 0U) ? 1U : 0U;
if ((uiKeyUp == 1U) && (uiKeyDn == 1U))
{
GeneralOperValue.Maintenance.KeyTest = 0U;
OledOperValue.uiPageNum = (Uint16)IDX_OLED_PAGE_MAINTENANCE;
}
}
}
void CLedControlProcedure(void)
{
static const CLedPattern APU_LED_TABLE[] = // LED 룩업 테이블
{
// FAULT, OPER, STOP
{LED_OFF, LED_OFF, LED_ON }, // 0: BOOT
{LED_OFF, LED_OFF, LED_ON }, // 1: INITIAL
{LED_OFF, LED_OFF, LED_ON }, // 2: POST
{LED_ON, LED_OFF, LED_ON }, // 3: EMERGENCY
{LED_OFF, LED_OFF, LED_ON }, // 4: STANDBY
// --- OPER 깜빡임 구간 (준비~예열) ---
{LED_OFF, LED_BLINK, LED_OFF }, // 5: READY
{LED_OFF, LED_BLINK, LED_OFF }, // 6: PREPARE_START
{LED_OFF, LED_BLINK, LED_OFF }, // 7: CRANKING
{LED_OFF, LED_BLINK, LED_OFF }, // 8: RETRY_CRANKING
{LED_OFF, LED_BLINK, LED_OFF }, // 9: ENGINE_WARM_UP
{LED_OFF, LED_ON, LED_OFF }, // 10: GENERATING (정상 운전)
// --- STOP 깜빡임 구간 (APU 정지 시) ---
{LED_OFF, LED_ON, LED_BLINK }, // 11: COOLDOWN (STOP 깜빡임, OPER는 켜둠)
{LED_OFF, LED_ON, LED_BLINK } // 12: STOPPING (COOLDWON이 순식간에 지나가기 때문에 점멸로 수정)
};
CLedPattern TargetLeds = {0, 0, 0};
Uint64 SoftClock = CGetSoftClock();
Uint16 IsBlinkOn = ((SoftClock % 10000U) < 5000U) ? 1U : 0U; // 0.5s 점멸을 위함
Uint16 WarningValue = 0U;
TargetLeds = APU_LED_TABLE[GeneralOperValue.uiApuState];
// 발전상태에서 경고 발생시 FAULT LED 깜빡이도록 설정
if (GeneralOperValue.uiApuState == (Uint16)IDX_APU_OPER_GENERATING)
{
WarningValue = ((((Uint16)Rx210.GcuWarning & (Uint16)MASK_LOW_NIBBLE) | ((Uint16)Rx310.EcuWarning & 0xFDU)) > 0U) ? 1U : 0U;
}
// 비상정지 상태가 아닌 경우에만 경고비트에 점멸 대응
if ((GeneralOperValue.uiApuState != (Uint16)IDX_APU_OPER_EMERGENCY) && (WarningValue == 1U))
{
TargetLeds.Fault = (Uint16)LED_BLINK;
}
// FAULT LED 제어
if (TargetLeds.Fault == (Uint16)LED_BLINK)
{
CLedControl(0U, IsBlinkOn);
}
else
{
CLedControl(0U, TargetLeds.Fault);
}
// OPERATION LED 제어
if (TargetLeds.Operation == (Uint16)LED_BLINK)
{
CLedControl(1U, IsBlinkOn);
}
else
{
CLedControl(1U, TargetLeds.Operation);
}
// STOP LED 제어
if (TargetLeds.Stop == (Uint16)LED_BLINK)
{
CLedControl(2U, IsBlinkOn);
}
else
{
CLedControl(2U, TargetLeds.Stop);
}
}
static void CLedControl(Uint16 idx, Uint16 state)
{
/*
* idx
* 0 : FAULT LED
* 1 : OPER LED
* 2 : STOP LED
*/
if (idx == 0U)
{
// GPIO_CPU_LED_FAULT
if (state == 0U)
{
GpioDataRegs.GPACLEAR.bit.GPIO14 = 1U;
}
else
{
GpioDataRegs.GPASET.bit.GPIO14 = 1U;
}
}
else if (idx == 1U)
{
// GPIO_CPU_LED_OPERATION
if (state == 0U)
{
GpioDataRegs.GPACLEAR.bit.GPIO13 = 1U;
}
else
{
GpioDataRegs.GPASET.bit.GPIO13 = 1U;
}
}
else
{
// GPIO_CPU_LED_STOP
if (state == 0U)
{
GpioDataRegs.GPACLEAR.bit.GPIO12 = 1U;
}
else
{
GpioDataRegs.GPASET.bit.GPIO12 = 1U;
}
}
}

63
Source/Oper.h Normal file
View File

@@ -0,0 +1,63 @@
#ifndef SOURCE_OPER_H_
#define SOURCE_OPER_H_
typedef struct ClassLedPattern
{
Uint16 Fault;
Uint16 Operation;
Uint16 Stop;
} CLedPattern;
typedef enum
{
IDX_APU_OPER_BOOT = 0U, // 0 부팅
IDX_APU_OPER_INITIAL, // 1 하드웨어 초기화
IDX_APU_OPER_POST, // 2 자체 진단
IDX_APU_OPER_EMERGENCY, // 3 비상 정지
IDX_APU_OPER_STANDBY, // 4 대기
IDX_APU_OPER_READY, // 5 준비 상태
IDX_APU_OPER_PREHEAT, // 6 연료 펌프 구동 및 예열
IDX_APU_OPER_CRANKING, // 7 스타터 모터 구동
IDX_APU_OPER_RETRY_CRANKING, // 8 시동 재시도
IDX_APU_OPER_ENGINE_IDLE, // 9 시동 성공 후 RPM 안정화 대기
IDX_APU_OPER_GENERATING, // 10 발전 시작
IDX_APU_OPER_COOLDOWN, // 11 엔진 냉각(정지 시)
IDX_APU_OPER_STOPPING, // 12 연료 펌프 및 솔레노이드, 냉각팬 차단
} E_IDX_APU_OPER;
typedef enum
{
IDX_ECU_STAT_STANDBY = 0U, // 0
IDX_ECU_STAT_STARTING, // 1
IDX_ECU_STAT_IDLE, // 2
IDX_ECU_STAT_OPERATION, // 3
IDX_ECU_STAT_DERATING, // 4
IDX_ECU_STAT_COOLDOWN, // 5
IDX_ECU_STAT_STOP // 6
} E_IDX_ECU_STAT;
typedef enum
{
IDX_GCU_CMD_STOP = 0U, // 0
IDX_GCU_CMD_CRANKING, // 1
IDX_GCU_CMD_STOP_CRANKING, // 2
IDX_GCU_CMD_GENERATING // 3
} E_IDX_GCU_CMD;
typedef enum
{
IDX_ECU_CMD_STOP = 0U, // 0
IDX_ECU_CMD_START, // 1
IDX_ECU_CMD_EMERGENCY // 2
} E_IDX_ECU_CMD;
void CApuOperProcedure(void);
void CDebugModeProcedure(void);
void CLedControlProcedure(void);
int16 CGetEngCoolantTemperature(void);
Uint16 CGetGeneratorRpm(void);
Uint16 CGetEngineActualRpm(void);
void CSetGcuCommand(Uint16 Command);
void CSetEcuCommand(Uint16 Command);
#endif /* SOURCE_OPER_H_ */

1296
Source/State.c Normal file
View File

File diff suppressed because it is too large Load Diff

219
Source/State.h Normal file
View File

@@ -0,0 +1,219 @@
#ifndef SOURCE_STATE_H_
#define SOURCE_STATE_H_
#define COMM_TIME_OUT_COUNT (3000U) // 3sec
typedef enum
{
IDX_ADC_ENGINE_HEATER_V = 0U, // 0
IDX_ADC_GLOW_PLUG_V, // 1
IDX_ADC_SOLENOID_V, // 2
IDX_ADC_FUEL_PUMP_V, // 3
IDX_ADC_COOLANT_PUMP_V, // 4
IDX_ADC_FAN1_V, // 5
IDX_ADC_FAN2_V, // 6
IDX_ADC_ENGINE_HEATER_I, // 7
IDX_ADC_GLOW_PLUG_I, // 8
IDX_ADC_SOLENOID_I, // 9
IDX_ADC_FUEL_PUMP_I, // 10
IDX_ADC_COOLANT_PUMP_I, // 11
IDX_ADC_FAN1_I, // 12
IDX_ADC_FAN2_I, // 13
IDX_ADC_MAX
} E_IDX_ADC;
typedef enum
{
IDX_WARNING_GCU_PCB_OT = 0U,
IDX_WARNING_GCU_FET_OT,
IDX_WARNING_GCU_WINDING1_OH,
IDX_WARNING_GCU_WINDING2_OH,
IDX_WARNING_GCU_MAX
} E_IDX_WARNING_GCU;
typedef enum
{
IDX_WARNING_ECU_ENGINE_OH = 0U,
IDX_WARNING_ECU_RESERVED,
IDX_WARNING_ECU_LO_OIL_PRESS,
IDX_WARNING_ECU_INTAKE_OH,
IDX_WARNING_ECU_INTAKE_LO_PRESS,
IDX_WARNING_ECU_ENGINE_LO_TEMP,
IDX_WARNING_ECU_ENGINE_SENSOR,
IDX_WARNING_ECU_DEFAULT_ACTIVE,
IDX_WARNING_ECU_MAX
} E_IDX_WARNING_ECU;
typedef enum
{
IDX_FAULT_DCU_CAR_COMM = 0U, // 0
IDX_FAULT_DCU_GCU_COMM, // 1
IDX_FAULT_DCU_ECU_COMM, // 2
IDX_FAULT_DCU_RPM_ERR, // 3
IDX_FAULT_DCU_ENGINE_HEAT_OC, // 4
IDX_FAULT_DCU_GLOW_PLUG_OC, // 5
IDX_FAULT_DCU_SOLENOID_OC, // 6
IDX_FAULT_DCU_FUEL_PUMP_OC, // 7
IDX_FAULT_DCU_COOLANT_PUMP_OC, // 8
IDX_FAULT_DCU_FAN1_OC, // 9
IDX_FAULT_DCU_FAN2_OC, // 10
IDX_FAULT_DCU_ENGINE_HEAT_UV, // 11
IDX_FAULT_DCU_ENGINE_HEAT_OV, // 12
IDX_FAULT_DCU_GLOW_PLUG_UV, // 13
IDX_FAULT_DCU_GLOW_PLUG_OV, // 14
IDX_FAULT_DCU_SOLENOID_UV, // 15
IDX_FAULT_DCU_SOLENOID_OV, // 16
IDX_FAULT_DCU_FUEL_PUMP_UV, // 17
IDX_FAULT_DCU_FUEL_PUMP_OV, // 18
IDX_FAULT_DCU_COOLANT_PUMP_UV, // 19
IDX_FAULT_DCU_COOLANT_PUMP_OV, // 20
IDX_FAULT_DCU_FAN1_UV, // 21
IDX_FAULT_DCU_FAN1_OV, // 22
IDX_FAULT_DCU_FAN2_UV, // 23
IDX_FAULT_DCU_FAN2_OV, // 24
IDX_FAULT_DCU_CRANKING_FAIL, // 25
IDX_FAULT_DCU_MAX
} E_IDX_DCU_FAULT;
typedef enum
{
IDX_FAULT_GCU_HWTRIP = 0U, // 0
IDX_FAULT_GCU_HWIGBT, // 1
IDX_FAULT_GCU_HW_DC, // 2
IDX_FAULT_GCU_GEN_OCU, // 3
IDX_FAULT_GCU_GEN_OCV, // 4
IDX_FAULT_GCU_GEN_OCW, // 5
IDX_FAULT_GCU_DC_OV, // 6
IDX_FAULT_GCU_DC_OC, // 7
IDX_FAULT_GCU_CRANK_OC, // 8
IDX_FAULT_GCU_PCB_OT, // 9
IDX_FAULT_GCU_FET_OT, // 10
IDX_FAULT_GCU_WINDING1_OH, // 11
IDX_FAULT_GCU_WINDING2_OH, // 12
IDX_FAULT_GCU_GEN_OS, // 13
IDX_FAULT_GCU_RES_IC, // 14
IDX_FAULT_GCU_RES_PRTY, // 15
IDX_FAULT_GCU_MAX
} E_IDX_GCU_FAULT;
typedef enum
{
IDX_FAULT_ECU_OIL_MS = 0U, // 0
IDX_FAULT_ECU_INT_OH, // 1
IDX_FAULT_ECU_ENG_OH, // 2
IDX_FAULT_ECU_ACTUATOR, // 3
IDX_FAULT_ECU_RPM_SIG, // 4
IDX_FAULT_ECU_ENG_SF, // 5
IDX_FAULT_MAX
} E_IDX_ECU_FAULT;
typedef enum
{
IDX_KEY_MAIN_POWER = 0U, // 0
IDX_KEY_ARR_UP, // 1
IDX_KEY_ARR_DOWN, // 2
IDX_KEY_ENTER, // 3
IDX_KEY_MENU, // 4
IDX_KEY_ENG_START_STOP, // 5
IDX_KEY_EMERGENCY, // 6
IDX_KEY_REMOTE_START, // 7
IDX_KEY_REMOTE_STOP, // 8
IDX_KEY_REMOTE_EMERGENCY, // 9
IDX_KEY_BATTLE_MODE, // 10
IDX_KEY_MAX // 11
} E_IDX_KEY;
typedef struct ClassKeyHandler
{
E_IDX_KEY eKey;
void (*pAction) (void);
} CKeyHandler;
typedef struct ClassAdcOperValue
{
Uint16 uiAdcOffsetIndex;
Uint16 uiOffsetAdjustStart;
} CAdcOperValue;
typedef struct ClassAdcCalcValue
{
float32 fLpfValue;
float32 fSampledValue;
float32 fSampledSum;
float32 fTempAdcOffset;
float32 fGain;
float32 fOffset;
Uint16 uiSamplingCount;
int16 iAdcValue;
} CAdcCalcValue;
typedef struct ClassWarningOperValue
{
float32 fCheckLimit; // 경고 한계 값
Uint16 uiWarning; // 0: 정상, 1: 경고 발생 중
Uint16 uiDetectCount; // 경고 검출 카운터
Uint16 uiReleaseCount; // 경고 해제 카운터
Uint16 uiCheckTime;
} CWarningOperValue;
typedef struct ClassAlarmOperValue
{
float32 fCheckLimit;
float32 fFaultValue;
Uint16 uiCheck;
Uint16 uiCheckCount;
Uint16 uiCheckTime;
} CAlarmOperValue;
typedef struct ClassKeyList
{
Uint16 MainPower;
Uint16 ArrowUp;
Uint16 ArrowDown;
Uint16 Enter;
Uint16 Menu;
Uint16 EngineStartStop;
Uint16 Emergency;
Uint16 BattleMode;
} CKeyList;
typedef struct ClassKeyOperValue
{
Uint16 uiKeyWaitCount;
Uint16 uiPreviousKey;
Uint16 uiKeyWait;
CKeyList KeyList;
} CKeyOperValue;
extern CAdcCalcValue Adc_EngineHeater_V;
extern CAdcCalcValue Adc_GlowPlug_V;
extern CAdcCalcValue Adc_Solenoid_V;
extern CAdcCalcValue Adc_FuelPump_V;
extern CAdcCalcValue Adc_CoolantPump_V;
extern CAdcCalcValue Adc_Fan1_V;
extern CAdcCalcValue Adc_Fan2_V;
extern CAdcCalcValue Adc_EngineHeater_I;
extern CAdcCalcValue Adc_GlowPlug_I;
extern CAdcCalcValue Adc_Solenoid_I;
extern CAdcCalcValue Adc_FuelPump_I;
extern CAdcCalcValue Adc_CoolantPump_I;
extern CAdcCalcValue Adc_Fan1_I;
extern CAdcCalcValue Adc_Fan2_I;
extern CAdcOperValue AdcOperValue;
extern CKeyOperValue KeyOperValue;
extern Uint32 ulDcuTotalAlarm;
extern Uint32 ulGcuTotalAlarm;
extern Uint32 ulEcuTotalAlarm;
interrupt void CAdcInterrupt(void);
void CAlarmProcedure(void);
void CInitAdc(void);
void CKeyCheckProcedure(void);
void CKeyWaitCount(void);
void CDisplayAlarmPopup(void);
#endif /* SOURCE_STATE_H_ */

730
Source/main.c Normal file
View File

@@ -0,0 +1,730 @@
/* ========================================================================= */
/* 1. Includes */
/* ========================================================================= */
#include "main.h"
/* ========================================================================= */
/* 2. Local Macros & Constants (내부 전용 매크로 및 상수) */
/* ========================================================================= */
// No Code
/* ========================================================================= */
/* 3. Local Typedefs & Structures (내부 전용 사용자 정의 자료형) */
/* ========================================================================= */
// No Code
/* ========================================================================= */
/* 4. Internal Linkage Function Declarations (내부 동작용 Static 함수 선언) */
/* ========================================================================= */
static void CInitSystem(void);
static void COledDisplay(void);
static void CInitGeneralOperValue(void);
static void CInitGpio(void);
static void CSystemConfigure(void);
static void CMappingInterrupt(void);
static void CProcessSoftTimer(void);
static void CShutdownProcedure(void);
static Uint16 CPowerOnCheck(void);
static void CSoftTimerWorkProcess(void);
static Uint16 CIsStatusSoftTimer(Uint16 uiTimerIndex);
static void CReloadSoftTimer(Uint16 uiTimerIndex);
static void CInitSoftTimers(void);
static void CInitSoftTimer(void);
static void CConfigSoftTimer(Uint16 TimerIndex, Uint32 Delay);
static void CStartSoftTimer(Uint16 uiTimerIndex);
static Uint16 CSoftClockTimeOut(Uint32 ulStartClock, Uint32 ulTimeOutClock);
static void CInitI2C(void);
/* ========================================================================= */
/* 5. Global Variables & Structure Initialization (전역 변수 및 구조체 초기화) */
/* ========================================================================= */
Uint16 PowerOnCheckSensor[(Uint16)IDX_SENSOR_MAX] = { 0U };
CGeneralOperValue GeneralOperValue;
static CSoftTimer SoftTimer[TIMER_MAX];
static CWaitTimer WaitTimer[SOFTTIMER_WAIT_MAX];
static Uint32 ulSoftClock;
/* ========================================================================= */
/* Function Definitions */
/* ========================================================================= */
int main(void)
{
GeneralOperValue.uiApuState = (Uint16)IDX_APU_OPER_BOOT;
CInitSystem();
CInitOled();
GeneralOperValue.uiApuState = (Uint16)IDX_APU_OPER_INITIAL;
AdcOperValue.uiOffsetAdjustStart = 1U; // AD 보정 시작
for ( ; ; )
{
CShutdownProcedure();
CSoftTimerWorkProcess();
if (GeneralOperValue.uiApuState == (Uint16)IDX_APU_OPER_INITIAL)
{
if (OledOperValue.uiProgressDone == 1U)
{
if (CSoftWaitCountProcedure(SOFTTIMER_WAIT_INIT, TIME_1SEC) == (Uint16)TIME_OVER)
{
COledBufferReset();
GeneralOperValue.uiApuState = (Uint16)IDX_APU_OPER_POST; // Adc 보정완료 이 후 POST 시작
}
}
}
else if (GeneralOperValue.uiApuState == (Uint16)IDX_APU_OPER_POST)
{
if (GeneralOperValue.uiSelfTestCheck == 0U)
{
GeneralOperValue.uiSelfTestCheck = 1U; // 한번만 체크하기 위함
GeneralOperValue.uiSelfTestPass = CPowerOnCheck(); // 1 : 정상, 0 : 비정상
}
else
{
if (GeneralOperValue.uiSelfTestPass == 1U) // 1 : 정상
{
COledBufferReset();
GeneralOperValue.uiApuState = (Uint16)IDX_APU_OPER_STANDBY;
}
}
}
else
{
#ifdef AUX_TEST
if (Rx400.AuxControl.AuxTestStart == 1U)
{
CSetAuxCtrlPin(IDX_CS_ENG_HEATER, (Rx400.AuxControl.EngineHeater != 0U) ? 1U : 0U);
CSetAuxCtrlPin(IDX_CS_GLOW_PLUG, (Rx400.AuxControl.GlowPlug != 0U) ? 1U : 0U);
CSetAuxCtrlPin(IDX_CS_SOLENOID, (Rx400.AuxControl.Solenoid != 0U) ? 1U : 0U);
CSetAuxCtrlPin(IDX_CS_FUEL_PUMP, (Rx400.AuxControl.FuelPump != 0U) ? 1U : 0U);
CSetAuxCtrlPin(IDX_CS_COOLANT_PUMP, (Rx400.AuxControl.CoolantPump != 0U) ? 1U : 0U);
CSetAuxCtrlPin(IDX_CS_FAN1, (Rx400.AuxControl.Fan1 != 0U) ? 1U : 0U);
CSetAuxCtrlPin(IDX_CS_FAN2, (Rx400.AuxControl.Fan2 != 0U) ? 1U : 0U);
}
// 정비 모드가 꺼져있어야 시퀀스 동작.
else if (GeneralOperValue.uiMaintenance == 0U)
#else
if (GeneralOperValue.uiMaintenance == 0U)
#endif
{
if (KeyOperValue.KeyList.MainPower == 0U) // 전원 스위치를 눌러서 shutdown 상태면 프로시저 OFF
{
CApuOperProcedure(); // 엔진 운영 프로시저
CLedControlProcedure(); // LED 제어 프로시저
}
}
else
{
CDebugModeProcedure();
}
}
}
}
static void CSoftTimerWorkProcess(void)
{
Uint16 ui01msExcute;
Uint16 ui10msExcute;
Uint16 ui100msExcute;
ui01msExcute = CIsStatusSoftTimer(TIMER_01MS);
ui10msExcute = CIsStatusSoftTimer(TIMER_10MS);
ui100msExcute = CIsStatusSoftTimer(TIMER_100MS);
if (ui01msExcute == (Uint16)SOFTTIMER_TIME_OVER)
{
CReloadSoftTimer(TIMER_01MS);
if (GeneralOperValue.uiApuState > (Uint16)IDX_APU_OPER_POST) // ADC 오프셋 보정 완료 후 감지
{
//CAlarmProcedure();
CDisplayAlarmPopup();
}
// (정비모드:키테스트)가 아니면 키 입력 처리 시작 함.
if (GeneralOperValue.Maintenance.KeyTest == 0U)
{
CKeyCheckProcedure();
CKeyWaitCount();
}
}
if (ui10msExcute == (Uint16)SOFTTIMER_TIME_OVER)
{
CReloadSoftTimer(TIMER_10MS);
CSendECanDataB();
COledDisplay();
}
if (ui100msExcute == (Uint16)SOFTTIMER_TIME_OVER)
{
CReloadSoftTimer(TIMER_100MS);
CSendECanDataA();
CDisplayAntiNoiseRefresh();
}
}
static void COledDisplay(void)
{
static Uint16 RefeshDelay = 0U;
// 부트 상태 이 후 프로그래스바 화면 표시용
if (GeneralOperValue.uiApuState == (Uint16)IDX_APU_OPER_INITIAL)
{
CInitializePage();
}
else
{
if (RefeshDelay == 0U) // 10ms 주기를 위함
{
// POST 상태 표시 용
if (GeneralOperValue.uiApuState == (Uint16)IDX_APU_OPER_POST)
{
CDisplayPostFail();
}
else
{
// POST 이 후 화면 표시용
CSetPage(OledOperValue.uiPageNum);
}
}
RefeshDelay = (RefeshDelay + 1U) % 10U;
}
COledReflash(0, 0, OLED_WIDTH, OLED_HEIGHT);
}
void CSoftWaitCountClear(Uint16 Index)
{
WaitTimer[Index].ulCountSoftClock = 0U;
WaitTimer[Index].uiSoftCountTarget = 0U;
}
static Uint16 CIsStatusSoftTimer(Uint16 uiTimerIndex)
{
Uint16 isRunning = 1U;
if (SoftTimer[uiTimerIndex].iStart != -1)
{
if (SoftTimer[uiTimerIndex].iStart == 1)
{
if (SoftTimer[uiTimerIndex].ulDecreaseValue == 0U)
{
isRunning = (Uint16)SOFTTIMER_TIME_OVER; // Success
}
else
{
isRunning = (Uint16)SOFTTIMER_RUNNING;
}
}
}
return isRunning;
}
static void CReloadSoftTimer(Uint16 uiTimerIndex)
{
if (SoftTimer[uiTimerIndex].iTimer != -1)
{
SoftTimer[uiTimerIndex].ulDecreaseValue = SoftTimer[uiTimerIndex].ulSetValue;
}
}
Uint16 CSoftWaitCountProcedure(Uint16 uiIndex, Uint32 ulWaitTime)
{
Uint16 isCountOver = 0U;
switch (WaitTimer[uiIndex].uiSoftCountTarget)
{
case 0U:
{
WaitTimer[uiIndex].ulCountSoftClock = CGetSoftClock();
WaitTimer[uiIndex].uiSoftCountTarget = 1U;
break;
}
case 1U:
{
if (CSoftClockTimeOut(WaitTimer[uiIndex].ulCountSoftClock, ulWaitTime) == (Uint16)SOFTTIMER_TIME_OVER)
{
WaitTimer[uiIndex].uiSoftCountTarget = 2U;
}
break;
}
default:
{
WaitTimer[uiIndex].ulCountSoftClock = 0U;
WaitTimer[uiIndex].uiSoftCountTarget = 0U;
isCountOver = 1U;
break;
}
}
return isCountOver;
}
static Uint16 CSoftClockTimeOut(Uint32 ulStartClock, Uint32 ulTimeOutClock)
{
Uint16 isRunning = 1U;
Uint32 ulCpuClock = CGetSoftClock();
if (((ulCpuClock + SYSTEM_10MIN_TIME - ulStartClock) % SYSTEM_10MIN_TIME) >= ulTimeOutClock)
{
isRunning = 0U;
}
return isRunning;
}
Uint32 CGetSoftClock(void)
{
return ulSoftClock;
}
static void CInitSystem(void)
{
DINT;
IER = 0x0000;
IFR = 0x0000;
InitSysCtrl();
CInitGpio(); // GPIO Direction and mux
InitPieCtrl();
IER = 0x0000;
IFR = 0x0000;
InitPieVectTable();
InitCpuTimers();
ConfigCpuTimer(&CpuTimer0, 150.0F, 100.0F); // 100usec
CSystemConfigure();
EINT; // Enable Global interrupt INTM
ERTM; // Enable Global realtime interrupt DBGM
CpuTimer0Regs.TCR.all = 0x4001U; // Use write-only instruction to set TSS bit = 0
}
static void CInitGpio(void)
{
EALLOW;
// GPIO MUX Setting
GpioCtrlRegs.GPBMUX1.bit.GPIO32 = 0x1U; // SCL
GpioCtrlRegs.GPBMUX1.bit.GPIO33 = 0x1U; // SDA
GpioCtrlRegs.GPBPUD.bit.GPIO32 = 0x0U; // Enable pull-up (SDAA)
GpioCtrlRegs.GPBPUD.bit.GPIO33 = 0x0U; // Enable pull-up (SCLA)
GpioCtrlRegs.GPBQSEL1.bit.GPIO32 = 0x3U; // Asynch input (SDAA)
GpioCtrlRegs.GPBQSEL1.bit.GPIO33 = 0x3U; // Asynch input (SCLA)
// GPIO Direction Setting '1' Output, '0' Input
GpioCtrlRegs.GPADIR.bit.GPIO9 = 0U; // GPIO_FUEL_PUMP_SIG_C
GpioCtrlRegs.GPADIR.bit.GPIO10 = 0U; // GPIO_GLOW_PLUG_SIG_C
GpioCtrlRegs.GPADIR.bit.GPIO11 = 0U; // GPIO_STOP_SOLENOID_SIG_C
GpioCtrlRegs.GPADIR.bit.GPIO24 = 0U; // GPIO_ENGINE_HEATER_SIG_C
GpioCtrlRegs.GPADIR.bit.GPIO25 = 0U; // GPIO_FAIL_SAFE_ENABLE_C
GpioCtrlRegs.GPADIR.bit.GPIO29 = 0U; // CPU_SW_MODE_RESET
GpioCtrlRegs.GPADIR.bit.GPIO30 = 0U; // CPU_SW_MODE_ENT
GpioCtrlRegs.GPADIR.bit.GPIO31 = 0U; // CPU_SW_DOWN
GpioCtrlRegs.GPBDIR.bit.GPIO39 = 0U; // CPU_SW_UP
GpioCtrlRegs.GPBDIR.bit.GPIO54 = 0U; // GPIO_BATTLEMODE_CMD_CS
GpioCtrlRegs.GPBDIR.bit.GPIO56 = 0U; // GPIO_EMERGENCY_CMD_CS
GpioCtrlRegs.GPBDIR.bit.GPIO57 = 0U; // GPIO_STOP_CMD_CS
GpioCtrlRegs.GPBDIR.bit.GPIO58 = 0U; // GPIO_START_CMD_CS
GpioCtrlRegs.GPCDIR.bit.GPIO64 = 0U; // CPU_SW_EMERGENCY
GpioCtrlRegs.GPCDIR.bit.GPIO66 = 0U; // CPU_SW_START
GpioCtrlRegs.GPCDIR.bit.GPIO67 = 0U; // CPU_SW_PWR
GpioCtrlRegs.GPADIR.bit.GPIO12 = 1U; // GPIO_CPU_LED_SWITCH3
GpioCtrlRegs.GPADIR.bit.GPIO13 = 1U; // GPIO_CPU_LED_SWITCH2
GpioCtrlRegs.GPADIR.bit.GPIO14 = 1U; // GPIO_CPU_LED_SWITCH1
GpioCtrlRegs.GPADIR.bit.GPIO26 = 1U; // GPIO_FUEL_PUMP_CS
GpioCtrlRegs.GPADIR.bit.GPIO27 = 1U; // GPIO_GLOW_PLUG_CS
GpioCtrlRegs.GPADIR.bit.GPIO28 = 1U; // GPIO_OLED_CS
GpioCtrlRegs.GPBDIR.bit.GPIO37 = 1U; // GPIO_OLED_RESET
GpioCtrlRegs.GPBDIR.bit.GPIO48 = 1U; // GPIO_STOP_SOLENOID_CS
GpioCtrlRegs.GPBDIR.bit.GPIO49 = 1U; // GPIO_ENGINE_HEATER_CS
GpioCtrlRegs.GPBDIR.bit.GPIO50 = 1U; // GPIO_COOLING_FAN1_CS
GpioCtrlRegs.GPBDIR.bit.GPIO51 = 1U; // GPIO_COOLING_FAN2_CS
GpioCtrlRegs.GPBDIR.bit.GPIO52 = 1U; // GPIO_COOLING_PUMP_CS
GpioCtrlRegs.GPBDIR.bit.GPIO55 = 1U; // GPIO_FAULT_CMD_CS
GpioCtrlRegs.GPCDIR.bit.GPIO65 = 1U; // GPIO_POWER_HOLD
GpioCtrlRegs.GPCDIR.bit.GPIO68 = 1U; // GPIO_CPU_LED_COM_FAULT
GpioCtrlRegs.GPCDIR.bit.GPIO69 = 1U; // GPIO_CPU_LED_COM_RUN
GpioCtrlRegs.GPCDIR.bit.GPIO70 = 1U; // GPIO_CPU_LED_COM_STA
// GPAQSEL : 0b00 - Synchronize to SYSCLKOUT, 0b01 - Qualification 3 sample, 0b10 - Qualification 6 sample, 0b11 - Asynchronous
GpioCtrlRegs.GPAQSEL1.all = 0x0000U; // GPIO0-GPIO15 Synch to SYSCLKOUT
GpioCtrlRegs.GPAQSEL2.all = 0x0000U; // GPIO16-GPIO31 Synch to SYSCLKOUT
GpioCtrlRegs.GPBQSEL1.all = 0x0000U; // GPIO32-GPIO47 Synch to SYSCLKOUT
GpioCtrlRegs.GPBQSEL2.all = 0x0000U; // GPIO48-GPIO63 Synch to SYSCLKOUT
GpioCtrlRegs.GPAQSEL1.bit.GPIO9 = 1U; // 3 Clk Sampling
GpioCtrlRegs.GPAQSEL1.bit.GPIO10 = 1U; // 3 Clk Sampling
GpioCtrlRegs.GPAQSEL1.bit.GPIO11 = 1U; // 3 Clk Sampling
GpioCtrlRegs.GPAQSEL2.bit.GPIO24 = 1U; // 3 Clk Sampling
GpioCtrlRegs.GPAQSEL2.bit.GPIO25 = 1U; // 3 Clk Sampling
// Gpio Default Value Initial
GpioDataRegs.GPCSET.bit.GPIO65 = 1U; // GPIO_POWER_HOLD
GpioDataRegs.GPCSET.bit.GPIO68 = 1U; // GPIO_CPU_LED_COM_FAULT_N
GpioDataRegs.GPCSET.bit.GPIO69 = 1U; // GPIO_CPU_LED_COM_RUN_N
GpioDataRegs.GPCSET.bit.GPIO70 = 1U; // GPIO_CPU_LED_COM_STA_N
EDIS;
}
void COffChipSelect(void)
{
CSetAuxCtrlPin(IDX_CS_ENG_HEATER, 0U);
CSetAuxCtrlPin(IDX_CS_GLOW_PLUG, 0U);
CSetAuxCtrlPin(IDX_CS_SOLENOID, 0U);
CSetAuxCtrlPin(IDX_CS_FUEL_PUMP, 0U);
CSetAuxCtrlPin(IDX_CS_COOLANT_PUMP, 0U);
CSetAuxCtrlPin(IDX_CS_FAN1, 0U);
CSetAuxCtrlPin(IDX_CS_FAN2, 0U);
}
static interrupt void CMainTimer0Interrupt(void)
{
// Per 100uSec
DINT;
ulSoftClock = (ulSoftClock + 1U) % SYSTEM_10MIN_TIME;
CProcessSoftTimer();
// Do Something
AdcRegs.ADCTRL2.bit.SOC_SEQ1 = 0x01U; // Adc Read Start
PieCtrlRegs.PIEACK.all |= PIEACK_GROUP1;
EINT;
}
static void CSystemConfigure(void)
{
CMappingInterrupt();
CInitGeneralOperValue();
CInitAdc();
CInitEcan();
CInitI2C();
CInitXintf();
CInitSoftTimers();
CInitKeyOperValue();
}
static void CInitGeneralOperValue(void)
{
(void)memset(&GeneralOperValue, 0, sizeof(CGeneralOperValue));
GeneralOperValue.uiPassword[IDX_OLED_PASS_DIGIT_1] = 0;
GeneralOperValue.uiPassword[IDX_OLED_PASS_DIGIT_2] = 0;
GeneralOperValue.uiPassword[IDX_OLED_PASS_DIGIT_3] = 0;
GeneralOperValue.uiPassword[IDX_OLED_PASS_DIGIT_4] = 0;
GeneralOperValue.EcuCommand.EngineStop = 1U;
}
static void CMappingInterrupt(void)
{
EALLOW;
// Interrupt Vector Remapping
PieCtrlRegs.PIEIER1.bit.INTx7 = 0x1U; // TINT0
PieCtrlRegs.PIEIER1.bit.INTx6 = 0x1U; // ADC
PieCtrlRegs.PIEIER9.bit.INTx5 = 0x1U; // ECAN0INTA
PieCtrlRegs.PIEIER9.bit.INTx7 = 0x1U; // ECAN0INTB
PieVectTable.TINT0 = &CMainTimer0Interrupt;
PieVectTable.ECAN0INTA = &CECanInterruptA;
PieVectTable.ECAN0INTB = &CECanInterruptB;
PieVectTable.ADCINT = &CAdcInterrupt;
IER = (Uint16)((Uint16)M_INT1 | (Uint16)M_INT9);
EDIS;
}
static void CProcessSoftTimer(void)
{
Uint16 i;
for (i = 0U; i < (Uint16)TIMER_MAX; i++)
{
if (SoftTimer[i].iTimer != -1)
{
if (SoftTimer[i].iStart == 1)
{
if (SoftTimer[i].ulDecreaseValue > 0UL)
{
SoftTimer[i].ulDecreaseValue--;
}
}
}
}
}
static void CInitSoftTimers(void)
{
CInitSoftTimer();
CConfigSoftTimer(TIMER_01MS, TIME_01MS);
CConfigSoftTimer(TIMER_10MS, TIME_10MS);
CConfigSoftTimer(TIMER_20MS, TIME_20MS);
CConfigSoftTimer(TIMER_50MS, TIME_50MS);
CConfigSoftTimer(TIMER_100MS, TIME_100MS);
CConfigSoftTimer(TIMER_500MS, TIME_500MS);
CStartSoftTimer(TIMER_01MS);
CStartSoftTimer(TIMER_10MS);
CStartSoftTimer(TIMER_20MS);
CStartSoftTimer(TIMER_50MS);
CStartSoftTimer(TIMER_100MS);
CStartSoftTimer(TIMER_500MS);
}
static void CStartSoftTimer(Uint16 uiTimerIndex)
{
if (SoftTimer[uiTimerIndex].iTimer != -1)
{
SoftTimer[uiTimerIndex].iStart = 1;
}
}
static void CInitSoftTimer(void)
{
Uint16 i;
(void)memset(&SoftTimer, 0, sizeof(SoftTimer));
(void)memset(&WaitTimer, 0, sizeof(WaitTimer));
for (i = 0; i < (Uint16)TIMER_MAX; i++)
{
SoftTimer[i].iTimer = -1;
}
}
static void CConfigSoftTimer(Uint16 TimerIndex, Uint32 Delay)
{
SoftTimer[TimerIndex].iTimer = (int16) TimerIndex;
SoftTimer[TimerIndex].ulSetValue = Delay;
SoftTimer[TimerIndex].ulDecreaseValue = Delay;
SoftTimer[TimerIndex].iStart = 0;
}
static Uint16 CPowerOnCheck(void)
{
Uint16 result = 1U;
Uint16 uiTemp = 0U;
Uint16 i;
// Check EngineHeater V/I Sensor
uiTemp = ((Adc_EngineHeater_V.iAdcValue > SENSOR_LOW_LIMIT) && (Adc_EngineHeater_V.iAdcValue < SENSOR_HIGH_LIMIT)) ? 0U : 1U;
uiTemp |= ((Adc_EngineHeater_I.iAdcValue > SENSOR_LOW_LIMIT) && (Adc_EngineHeater_I.iAdcValue < SENSOR_HIGH_LIMIT)) ? 0U : 1U;
PowerOnCheckSensor[(Uint16)IDX_SENSOR_ENGINE_HEATER] = uiTemp;
// Check GlowPlug V/I Sensor
uiTemp = ((Adc_GlowPlug_V.iAdcValue > SENSOR_LOW_LIMIT) && (Adc_GlowPlug_V.iAdcValue < SENSOR_HIGH_LIMIT)) ? 0U : 1U;
uiTemp |= ((Adc_GlowPlug_I.iAdcValue > SENSOR_LOW_LIMIT) && (Adc_GlowPlug_I.iAdcValue < SENSOR_HIGH_LIMIT)) ? 0U : 1U;
PowerOnCheckSensor[(Uint16)IDX_SENSOR_GLOW_PLUG] = uiTemp;
// Check Solenoid V/I Sensor
uiTemp = ((Adc_Solenoid_V.iAdcValue > SENSOR_LOW_LIMIT) && (Adc_Solenoid_V.iAdcValue < SENSOR_HIGH_LIMIT)) ? 0U : 1U;
uiTemp |= ((Adc_Solenoid_I.iAdcValue > SENSOR_LOW_LIMIT) && (Adc_Solenoid_I.iAdcValue < SENSOR_HIGH_LIMIT)) ? 0U : 1U;
PowerOnCheckSensor[(Uint16)IDX_SENSOR_SOLENOID] = uiTemp;
// Check FuelPump V/I Sensor
uiTemp = ((Adc_FuelPump_V.iAdcValue > SENSOR_LOW_LIMIT) && (Adc_FuelPump_V.iAdcValue < SENSOR_HIGH_LIMIT)) ? 0U : 1U;
uiTemp |= ((Adc_FuelPump_I.iAdcValue > SENSOR_LOW_LIMIT) && (Adc_FuelPump_I.iAdcValue < SENSOR_HIGH_LIMIT)) ? 0U : 1U;
PowerOnCheckSensor[(Uint16)IDX_SENSOR_FUEL_PUMP] = uiTemp;
// Check CoolantPump V/I Sensor
uiTemp = ((Adc_CoolantPump_V.iAdcValue > SENSOR_LOW_LIMIT) && (Adc_CoolantPump_V.iAdcValue < SENSOR_HIGH_LIMIT)) ? 0U : 1U;
uiTemp |= ((Adc_CoolantPump_I.iAdcValue > SENSOR_LOW_LIMIT) && (Adc_CoolantPump_I.iAdcValue < SENSOR_HIGH_LIMIT)) ? 0U : 1U;
PowerOnCheckSensor[(Uint16)IDX_SENSOR_COOLANT_PUMP] = uiTemp;
// Check Fan1 V/I Sensor
uiTemp = ((Adc_Fan1_V.iAdcValue > SENSOR_LOW_LIMIT) && (Adc_Fan1_V.iAdcValue < SENSOR_HIGH_LIMIT)) ? 0U : 1U;
uiTemp |= ((Adc_Fan1_I.iAdcValue > SENSOR_LOW_LIMIT) && (Adc_Fan1_I.iAdcValue < SENSOR_HIGH_LIMIT)) ? 0U : 1U;
PowerOnCheckSensor[(Uint16)IDX_SENSOR_FAN1] = uiTemp;
// Check Fan2 V/I Sensor
uiTemp = ((Adc_Fan2_V.iAdcValue > SENSOR_LOW_LIMIT) && (Adc_Fan2_V.iAdcValue < SENSOR_HIGH_LIMIT)) ? 0U : 1U;
uiTemp |= ((Adc_Fan2_I.iAdcValue > SENSOR_LOW_LIMIT) && (Adc_Fan2_I.iAdcValue < SENSOR_HIGH_LIMIT)) ? 0U : 1U;
PowerOnCheckSensor[(Uint16)IDX_SENSOR_FAN2] = uiTemp;
for (i = 0U; i < (Uint16)IDX_SENSOR_MAX; i++)
{
if (PowerOnCheckSensor[i] > 0U)
{
result = 0U;
break;
}
}
return result; // '0' 정상
}
static void CInitI2C(void)
{
/* I2C 모듈 리셋 */
I2caRegs.I2CMDR.bit.IRS = 0U;
/*
* 1. I2C 프리스케일러 (I2CPSC) 설정
* SYSCLKOUT = 150MHz 기준
* 10MHz = 150MHz / (14 + 1) -> I2CPSC = 14
*/
I2caRegs.I2CPSC.all = 14U;
/*
* 2. I2C 마스터 클럭 (SCL) 설정
* 10MHz / 400kHz = 25 -> (I2CCLKL + 5) + (I2CCLKH + 5) = 25
*/
//I2caRegs.I2CCLKL = 45U; // 100kHz
//I2caRegs.I2CCLKH = 45U; // 100kHz
I2caRegs.I2CCLKL = 8U; // 400kHz
I2caRegs.I2CCLKH = 7U; // 400kHz
/*
* 3. I2C 핀 설정 (GPIO32/SDAA, GPIO33/SCLA)
*/
EALLOW;
GpioCtrlRegs.GPBPUD.bit.GPIO32 = 0U; /* Pull-up 활성화 (SDAA) */
GpioCtrlRegs.GPBPUD.bit.GPIO33 = 0U; /* Pull-up 활성화 (SCLA) */
GpioCtrlRegs.GPBQSEL1.bit.GPIO32 = 3U; /* 비동기 입력 설정 */
GpioCtrlRegs.GPBQSEL1.bit.GPIO33 = 3U; /* 비동기 입력 설정 */
GpioCtrlRegs.GPBMUX1.bit.GPIO32 = 1U; /* GPIO32를 SDAA로 설정 */
GpioCtrlRegs.GPBMUX1.bit.GPIO33 = 1U; /* GPIO33을 SCLA로 설정 */
EDIS;
/* I2C 모듈 활성화 (리셋 해제 및 기본 설정 적용) */
I2caRegs.I2CMDR.all = 0x0020U;
}
static void CShutdownProcedure(void)
{
if (KeyOperValue.KeyList.MainPower == 1U)
{
// 장치의 전원을 끄기 전 모든 제어상태를 정지 한다.
CSetGcuCommand((Uint16)IDX_GCU_CMD_STOP);
CSetEcuCommand((Uint16)IDX_ECU_CMD_EMERGENCY);
COffChipSelect();
if (GeneralOperValue.uiWriteEepromDataStart == 0U)
{
GeneralOperValue.uiWriteEepromDataStart = 1U;
}
// 최대 3초 경과 후 꺼짐
if (CSoftWaitCountProcedure(SOFTTIMER_WAIT_SHUTDOWN, (TIME_1SEC * 3U)) == (Uint16)TIME_OVER)
{
GpioDataRegs.GPCCLEAR.bit.GPIO65 = 1U; // GPIO_POWER_HOLD
}
}
}
void CUpdateFault(Uint32 *pData, Uint16 uiIdx, Uint16 uiCond)
{
Uint32 ulMask;
if (pData != NULL)
{
ulMask = 1UL << (Uint32)uiIdx;
*pData = (uiCond != 0U) ? (*pData | ulMask) : (*pData & ~ulMask);
}
}
Uint16 CIsBitSet(Uint32 ulData, Uint16 uiIdx)
{
Uint32 ulMask;
ulMask = 1UL << (Uint32)uiIdx;
return (((ulData & ulMask) != 0UL) ? 1U : 0U);
}
void DELAY_USEC(Uint32 ulMicroSeconds)
{
Uint32 ulDelayCount;
ulDelayCount = (Uint32)((float64)(((((float64)ulMicroSeconds * 1000.0L) / (float64)CPU_RATE) - 9.0L) / 5.0L));
DSP28x_usDelay(ulDelayCount);
}
void CSetAuxCtrlPin(E_AUX_CS_IDX eIdx, Uint16 uiState)
{
switch (eIdx)
{
case IDX_CS_ENG_HEATER:
{
if (uiState == 1U) { GpioDataRegs.GPBSET.bit.GPIO49 = 1U; }
else { GpioDataRegs.GPBCLEAR.bit.GPIO49 = 1U; }
break;
}
case IDX_CS_GLOW_PLUG:
{
if (uiState == 1U) { GpioDataRegs.GPASET.bit.GPIO27 = 1U; }
else { GpioDataRegs.GPACLEAR.bit.GPIO27 = 1U; }
break;
}
case IDX_CS_SOLENOID:
{
if (uiState == 1U) { GpioDataRegs.GPBSET.bit.GPIO48 = 1U; }
else { GpioDataRegs.GPBCLEAR.bit.GPIO48 = 1U; }
break;
}
case IDX_CS_FUEL_PUMP:
{
if (uiState == 1U) { GpioDataRegs.GPASET.bit.GPIO26 = 1U; }
else { GpioDataRegs.GPACLEAR.bit.GPIO26 = 1U; }
break;
}
case IDX_CS_COOLANT_PUMP:
{
if (uiState == 1U) { GpioDataRegs.GPBSET.bit.GPIO52 = 1U; }
else { GpioDataRegs.GPBCLEAR.bit.GPIO52 = 1U; }
break;
}
case IDX_CS_FAN1:
{
if (uiState == 1U) { GpioDataRegs.GPBSET.bit.GPIO50 = 1U; }
else { GpioDataRegs.GPBCLEAR.bit.GPIO50 = 1U; }
break;
}
default:
{
if (eIdx == IDX_CS_FAN2)
{
if (uiState == 1U) { GpioDataRegs.GPBSET.bit.GPIO51 = 1U; }
else { GpioDataRegs.GPBCLEAR.bit.GPIO51 = 1U; }
}
break;
}
}
}

254
Source/main.h Normal file
View File

@@ -0,0 +1,254 @@
#ifndef SOURCE_MAIN_H_
#define SOURCE_MAIN_H_
#include <String.h>
#include "DSP28x_Project.h"
#include "DSP2833x_Device.h"
#include "State.h"
#include "Oper.h"
#include "Display.h"
#include "Comm.h"
#define AUX_TEST
#define true (1U)
#define false (0U)
// Key Input Port (Lo Active)
#define GPIO_KEY_UP() (GpioDataRegs.GPBDAT.bit.GPIO39) // LOW Active
#define GPIO_KEY_DOWN() (GpioDataRegs.GPADAT.bit.GPIO31) // LOW Active
#define GPIO_KEY_ENTER() (GpioDataRegs.GPADAT.bit.GPIO30) // LOW Active
#define GPIO_KEY_MENU() (GpioDataRegs.GPADAT.bit.GPIO29) // LOW Active
#define GPIO_KEY_POWER() (GpioDataRegs.GPCDAT.bit.GPIO67) // LOW Active
#define GPIO_KEY_START() (GpioDataRegs.GPCDAT.bit.GPIO66) // LOW Active
#define GPIO_KEY_EMERGENCY() (GpioDataRegs.GPCDAT.bit.GPIO64) // LOW Active
#define GPIO_KEY_REMOTE_START() (GpioDataRegs.GPBDAT.bit.GPIO58) // LOW Active
#define GPIO_KEY_REMOTE_STOP() (GpioDataRegs.GPBDAT.bit.GPIO57) // LOW Active
#define GPIO_KEY_REMOTE_EMERGENCY() (GpioDataRegs.GPBDAT.bit.GPIO56) // LOW Active
// Read ChipSelect State
#define ENGINE_HEATER_OUT() (GpioDataRegs.GPBDAT.bit.GPIO49) // HIGH is Active
#define GLOW_PLUG_OUT() (GpioDataRegs.GPADAT.bit.GPIO27) // HIGH is Active
#define SOLENOID_OUT() (GpioDataRegs.GPBDAT.bit.GPIO48) // HIGH is Active
#define FUEL_PUMP_OUT() (GpioDataRegs.GPADAT.bit.GPIO26) // HIGH is Active
#define COOLANT_PUMP_OUT() (GpioDataRegs.GPBDAT.bit.GPIO52) // HIGH is Active
#define FAN1_OUT() (GpioDataRegs.GPBDAT.bit.GPIO50) // HIGH is Active
#define FAN2_OUT() (GpioDataRegs.GPBDAT.bit.GPIO51) // HIGH is Active
// Active Read From ECU
#define GPIO_ENGINE_HEATER_ACTIVE() (GpioDataRegs.GPADAT.bit.GPIO24) // LOW is Active
#define GPIO_GLOW_PLUG_ACTIVE() (GpioDataRegs.GPADAT.bit.GPIO10) // LOW is Active
#define GPIO_SOLENOID_ACTIVE() (GpioDataRegs.GPADAT.bit.GPIO11) // LOW is Active
#define GPIO_FUEL_PUMP_ACTIVE() (GpioDataRegs.GPADAT.bit.GPIO9) // LOW is Active
// Fail-Safe Enable(ECU HW Emergency)
#define GPIO_FAIL_SAFE_READ() (GpioDataRegs.GPADAT.bit.GPIO25) // LOW is Active
// Auxiliary Read all
#define STATUS_BIT_HEATER (0)
#define STATUS_BIT_GLOW (1)
#define STATUS_BIT_SOLENOID (2)
#define STATUS_BIT_FUEL (3)
#define STATUS_BIT_COOLANT (4)
#define STATUS_BIT_FAN1 (5)
#define STATUS_BIT_FAN2 (6)
#define GET_ALL_AUX_STATUS() \
( \
(GpioDataRegs.GPBDAT.bit.GPIO49 << STATUS_BIT_HEATER) | \
(GpioDataRegs.GPADAT.bit.GPIO27 << STATUS_BIT_GLOW) | \
(GpioDataRegs.GPBDAT.bit.GPIO48 << STATUS_BIT_SOLENOID) | \
(GpioDataRegs.GPADAT.bit.GPIO26 << STATUS_BIT_FUEL) | \
(GpioDataRegs.GPBDAT.bit.GPIO52 << STATUS_BIT_COOLANT) | \
(GpioDataRegs.GPBDAT.bit.GPIO50 << STATUS_BIT_FAN1) | \
(GpioDataRegs.GPBDAT.bit.GPIO51 << STATUS_BIT_FAN2) \
)
/* Comment Description
* [!] : 변경시 주의
* [?] : 결정이 필요
* [*] : 주의보다 더 엄중
*/
/* Firmware 버전 (Semantic Versioning) */
#define FIRMWARE_VERSION_MAJOR (0) // 하위버전과 호환 되지 않는 변화가 생길 때 증가, 대대적인 변화가 있을 때
#define FIRMWARE_VERSION_MINOR (1) // 하위버전과 호환 되면서 새로운 기능이 생길 때 증가, 기존 기능이 변경되거나 사용 방법이 변경 될 때
#define FIRMWARE_VERSION_PATCH (9) // 하위버전과 호환 되면서 버그 수정, 기능적으로 변경된것을 알아차리지 못할 정도의 소소한 변경이 있을 때
/* Version History
* [0.0.1] : DCU 프로젝트 생성
* [0.0.2] : DCU 펌웨어 탑재 성공
* [0.0.3] : OLED XINTF(BUS) 방식 드라이브단 구현
* [0.0.4] : OLED 표시 화면 구현
* [0.0.5] : CAN-B 확인 및 맵핑
* [0.0.6] : 시동 시퀀스 구현 및 정비 화면 수정
* [0.1.6] : Suter 보조엔진 시동 완료 시점
* [0.1.7] : 발전상태 전환 조건 추가 26-02-23
* [0.1.8] : 장치 운용시간 로직 추가(Eeprom 사용), define USE_EEPROM 26-03-16 <삭제>
* [0.1.9] : IPS 회로 변경으로 전압센싱 추가 및 고장 알람 비트 추가, CAN-A 채널 송신 데이터 추가 26-03-26
*/
#define MAINTENECE_PASSKEY {0,0,0,0}
#define ENABLED (1)
#define DISABLED (!ENABLED)
/*
* Bit mask
*/
#define MASK_LOW_NIBBLE (0x0FU)
#define MASK_HIGH_NIBBLE (0xF0U)
#define MASK_BYTE (0xFFU)
#define MASK_WORD (0xFFFFU)
#define MASK_6BIT (0x3FU)
#define MASK_26BIT (0x3FFFFFFUL)
/*
Timer Clock Per 100us
*/
#define SYSTEM_10MIN_TIME (6000000UL)
#define TIME_01MS (10UL)
#define TIME_10MS (100UL)
#define TIME_20MS (200UL)
#define TIME_50MS (500UL)
#define TIME_100MS (1000UL)
#define TIME_500MS (5000UL)
#define TIME_1SEC (10000UL)
#define TIME_5SEC (50000UL)
#define TIME_10SEC (100000UL)
#define TIME_60SEC (600000UL)
// 전압/전류센서 AdcRefValue 기준값 전압:2300, 전류:2250
#define SENSOR_LOW_LIMIT (2000) // 단선
#define SENSOR_HIGH_LIMIT (4000) // 단락
#define TIME_OVER (1U)
enum
{
TIMER_01MS = 0U,
TIMER_10MS,
TIMER_20MS,
TIMER_50MS,
TIMER_100MS,
TIMER_500MS,
TIMER_1SEC,
TIMER_MAX
};
enum
{
SOFTTIMER_TIME_OVER = 0U,
SOFTTIMER_RUNNING,
SOFTTIMER_PAUSE,
SOFTTIMER_DONT_EXIST
};
enum
{
SOFTTIMER_WAIT_INIT = 0U,
SOFTTIMER_WAIT_ALARM_RESET,
SOFTTIMER_WAIT_ENG_COOLDOWN,
SOFTTIMER_WAIT_PREHEAT,
SOFTTIMER_WAIT_CRANKING,
SOFTTIMER_WAIT_RETRY_CRANKING,
SOFTTIMER_WAIT_OPERATION,
SOFTTIMER_WAIT_SHUTDOWN,
SOFTTIMER_WAIT_AFTER_COOLDOWN,
SOFTTIMER_WAIT_MAX
};
typedef enum
{
IDX_CS_ENG_HEATER = 0,
IDX_CS_GLOW_PLUG,
IDX_CS_SOLENOID,
IDX_CS_FUEL_PUMP,
IDX_CS_COOLANT_PUMP,
IDX_CS_FAN1,
IDX_CS_FAN2,
IDX_CS_MAX
} E_AUX_CS_IDX;
typedef struct ClassSoftTimer
{
Uint32 ulSetValue;
Uint32 ulDecreaseValue;
int16 iTimer;
int16 iStart;
} CSoftTimer;
typedef struct ClassWaitTimer
{
Uint32 ulCountSoftClock;
Uint16 uiSoftCountTarget;
} CWaitTimer;
typedef enum
{
IDX_SENSOR_ENGINE_HEATER = 0U, // 0
IDX_SENSOR_GLOW_PLUG, // 1
IDX_SENSOR_SOLENOID, // 2
IDX_SENSOR_FUEL_PUMP, // 3
IDX_SENSOR_COOLANT_PUMP, // 4
IDX_SENSOR_FAN1, // 5
IDX_SENSOR_FAN2, // 6
IDX_SENSOR_MAX // 7
} E_IDX_SENSOR;
typedef struct ClassGeneralOperValue
{
Uint16 uiFaultOccured;
Uint16 uiDynamicRPM;
Uint16 uiPassword[4];
Uint16 uiSelfTestCheck;
Uint16 uiSelfTestPass;
Uint16 uiEmergency;
Uint16 uiApuStart;
Uint16 uiApuState;
Uint16 uiAlarmReset;
Uint16 uiMaintenance;
Uint16 uiRetryCrankingCount;
Uint16 uiWriteEepromDataStart;
Uint32 ulTotalOperationHour;
Uint32 ulRampStartClock; // IDLE_SEQ_MOD
Uint16 uiRampComplete; // IDLE_SEQ_MOD
struct
{
Uint16 PlayCmd;
} GcuCommand;
struct
{
Uint16 EngineStart;
Uint16 EngineStop;
Uint16 RpmSetPoint;
Uint16 ActiveOverride;
Uint16 EmergencyStop;
} EcuCommand;
struct
{
Uint16 CarComputer;
Uint16 Gcu;
Uint16 Ecu;
} Conection;
struct
{
Uint16 ManualCranking;
Uint16 LampTest;
Uint16 KeyTest;
} Maintenance;
} CGeneralOperValue;
extern CGeneralOperValue GeneralOperValue;
extern Uint16 PowerOnCheckSensor[IDX_SENSOR_MAX];
Uint16 CSoftWaitCountProcedure(Uint16 uiIndex, Uint32 ulWaitTime);
void COffChipSelect(void);
void CSoftWaitCountClear(Uint16 Index);
Uint32 CGetSoftClock(void);
void CUpdateFault(Uint32 *pData, Uint16 uiIdx, Uint16 uiCond);
void DELAY_USEC(Uint32 ulMicroSeconds);
Uint16 CIsBitSet(Uint32 ulData, Uint16 uiIdx);
void CSetAuxCtrlPin(E_AUX_CS_IDX eIdx, Uint16 uiState);
#endif /* SOURCE_MAIN_H_ */