1444 lines
42 KiB
Plaintext
1444 lines
42 KiB
Plaintext
#include "main.h"
|
||
#include "CFont.h"
|
||
|
||
#pragma DATA_SECTION(CommandBus,"ZONE6_COM");
|
||
#pragma DATA_SECTION(DataBus,"ZONE6_DAT");
|
||
|
||
volatile Uint16 CommandBus, DataBus;
|
||
const Uint16 uiBitMask[8] = { 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 };
|
||
int8 cNumBuffer[7] = { 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20 };
|
||
int8 *pNumBuffer = cNumBuffer;
|
||
|
||
COledOperValue OledOperValue;
|
||
|
||
static void CPageApu1(void);
|
||
static void CPageApu2(void);
|
||
static void CPageMenu1(void);
|
||
static void CPageMenu2(void);
|
||
static void CPageTemp(void);
|
||
static void CPageSensor1(void);
|
||
static void CPageSensor2(void);
|
||
static void CPageSensor3(void);
|
||
static void CPageSensor4(void);
|
||
static void CPageWarning1(void);
|
||
static void CPageWarning2(void);
|
||
static void CPageFault1(void);
|
||
static void CPageFault2(void);
|
||
static void CPageFault3(void);
|
||
static void CPageFault4(void);
|
||
static void CPageFault5(void);
|
||
static void CPageFault6(void);
|
||
static void CPageAlarmReset(void);
|
||
static void CPagePassword(void);
|
||
static void CPageMaintenence(void);
|
||
static void CPageKeyTest(void);
|
||
static void CPageShutdown(void);
|
||
Uint16 CStrLen(const int8 *s);
|
||
void CInitOledModule(void);
|
||
void CDrawChar(Uint16 x, Uint16 y, Uint16 ch, Uint16 type);
|
||
void CInitProgress(void);
|
||
void CDrawStr(Uint16 x, Uint16 y, int8* str, Uint16 len);
|
||
void CTextAlign(int8 *buffer, const int8 *str);
|
||
static inline void CPutPixel(Uint16 x, Uint16 y, Uint16 Color);
|
||
void CDrawBox(Uint16 x, Uint16 y, Uint16 w, Uint16 h);
|
||
void CDrawLine(Uint16 x1, Uint16 y1, Uint16 x2, Uint16 y2);
|
||
void CLcdWrite(Uint16 Data, Uint16 Command);
|
||
void CSetDrawRegion(Uint16 x1, Uint16 y1, Uint16 x2, Uint16 y2);
|
||
void CSetPageAddress(Uint16 Address);
|
||
void CSetColumnAddress(Uint16 x);
|
||
void COledWrite(Uint16 Data, Uint16 Command);
|
||
void CInitOledStructure(void);
|
||
static void CStrncpy(int8 *pTarget, const int8 *pSource, Uint16 Size);
|
||
void CStrncat(int8 *pTarget, const int8 *pSource, Uint16 Size);
|
||
void CDecToString(int16 Data, int8 *Array, Uint16 ArrayLen);
|
||
static void CFloatToString(float32 Data, int8 *Array, Uint16 ArrayLen);
|
||
static void CLineFocus(Uint16 isFocus);
|
||
static void CHourToString(int32 num, int8 *str);
|
||
void CAddLineIndent(int8 *buffer, const int8 *str);
|
||
static const int8* CGetApuStateString(eApuOperIdx idx);
|
||
static void CDrawTitleBox(Uint16 TitleLen);
|
||
static void CDrawCenteredLine(Uint16 y, const int8* text);
|
||
|
||
static const CPageHandler PageTable[OLED_PAGE_MAX] =
|
||
{
|
||
{ OLED_PAGE_APU1, CPageApu1 },
|
||
{ OLED_PAGE_APU2, CPageApu2 },
|
||
{ OLED_PAGE_MENU1, CPageMenu1 },
|
||
{ OLED_PAGE_MENU2, CPageMenu2 },
|
||
{ OLED_PAGE_TEMP, CPageTemp },
|
||
{ OLED_PAGE_SENSOR1, CPageSensor1 },
|
||
{ OLED_PAGE_SENSOR2, CPageSensor2 },
|
||
{ OLED_PAGE_SENSOR3, CPageSensor3 },
|
||
{ OLED_PAGE_SENSOR4, CPageSensor4 },
|
||
{ OLED_PAGE_WARNING1, CPageWarning1 },
|
||
{ OLED_PAGE_WARNING2, CPageWarning2 },
|
||
{ OLED_PAGE_FAULT1, CPageFault1 },
|
||
{ OLED_PAGE_FAULT2, CPageFault2 },
|
||
{ OLED_PAGE_FAULT3, CPageFault3 },
|
||
{ OLED_PAGE_FAULT4, CPageFault4 },
|
||
{ OLED_PAGE_FAULT5, CPageFault5 },
|
||
{ OLED_PAGE_FAULT6, CPageFault6 },
|
||
{ OLED_PAGE_RESET_ALARM, CPageAlarmReset },
|
||
{ OLED_PAGE_PASSWORD, CPagePassword },
|
||
{ OLED_PAGE_MAINTENENCE, CPageMaintenence },
|
||
{ OLED_PAGE_KEY_TEST, CPageKeyTest },
|
||
{ OLED_PAGE_SHUTDOWN, CPageShutdown }
|
||
};
|
||
|
||
static void CDrawPageTitle(const int8* title, const int8* pageNumStr)
|
||
{
|
||
CStrncpy(OledOperValue.cStrBuff[OLED_ROW_0], title, CStrLen(title));
|
||
CDrawStr(10U, OLED_LINE_TITLE, OledOperValue.cStrBuff[OLED_ROW_0], CStrLen((const int8*)OledOperValue.cStrBuff[OLED_ROW_0]));
|
||
|
||
CDrawTitleBox(CStrLen((const int8*)OledOperValue.cStrBuff[OLED_ROW_0]) * 6U);
|
||
|
||
if (pageNumStr != NULL)
|
||
{
|
||
CStrncpy(OledOperValue.cStrBuff[OLED_ROW_0], pageNumStr, CStrLen(pageNumStr));
|
||
CDrawStr(100U, OLED_LINE_TITLE, OledOperValue.cStrBuff[OLED_ROW_0], CStrLen(OledOperValue.cStrBuff[OLED_ROW_0]));
|
||
}
|
||
}
|
||
|
||
static void CDrawPageLine(Uint16 row, const int8* label, const int8* valueStr, const int8* unitStr)
|
||
{
|
||
Uint16 drawY = 0U;
|
||
|
||
switch(row)
|
||
{
|
||
case OLED_ROW_1: drawY = OLED_LINE_1; break;
|
||
case OLED_ROW_2: drawY = OLED_LINE_2; break;
|
||
case OLED_ROW_3: drawY = OLED_LINE_3; break;
|
||
case OLED_ROW_4: drawY = OLED_LINE_4; break;
|
||
default: return; // Invalid row
|
||
}
|
||
|
||
CStrncpy(OledOperValue.cStrBuff[row], label, CStrLen(label));
|
||
|
||
if (valueStr != NULL)
|
||
{
|
||
CStrncat(OledOperValue.cStrBuff[row], valueStr, CStrLen(valueStr));
|
||
}
|
||
|
||
if (unitStr != NULL)
|
||
{
|
||
CStrncat(OledOperValue.cStrBuff[row], unitStr, CStrLen(unitStr));
|
||
}
|
||
|
||
CDrawStr(0U, drawY, OledOperValue.cStrBuff[row], CStrLen(OledOperValue.cStrBuff[row]));
|
||
}
|
||
|
||
static void CDrawPageLineFloat(Uint16 row, const int8* label, float32 value, const int8* unitStr)
|
||
{
|
||
CFloatToString(value, pNumBuffer, sizeof(cNumBuffer));
|
||
CDrawPageLine(row, label, pNumBuffer, unitStr);
|
||
}
|
||
|
||
static void CDrawPageLineInt(Uint16 row, const int8* label, int32 value, const int8* unitStr)
|
||
{
|
||
CDecToString((int16)value, pNumBuffer, sizeof(cNumBuffer));
|
||
CDrawPageLine(row, label, pNumBuffer, unitStr);
|
||
}
|
||
|
||
static void CDrawTwoStatusLine(Uint16 row, const int8* label1, Uint16 status1, const int8* label2, Uint16 status2)
|
||
{
|
||
Uint16 drawY = 0U;
|
||
const int8* statusStr1 = (status1 == 1U) ? (const int8*)"1" : (const int8*)"0";
|
||
const int8* statusStr2 = (status2 == 1U) ? (const int8*)"1" : (const int8*)"0";
|
||
|
||
switch(row)
|
||
{
|
||
case OLED_ROW_1: drawY = OLED_LINE_1; break;
|
||
case OLED_ROW_2: drawY = OLED_LINE_2; break;
|
||
case OLED_ROW_3: drawY = OLED_LINE_3; break;
|
||
case OLED_ROW_4: drawY = OLED_LINE_4; break;
|
||
default: return;
|
||
}
|
||
|
||
// Label 1
|
||
CStrncpy(OledOperValue.cStrBuff[row], label1, CStrLen(label1));
|
||
|
||
// Status 1
|
||
CStrncat(OledOperValue.cStrBuff[row], statusStr1, CStrLen(statusStr1));
|
||
|
||
// Spacing
|
||
CStrncat(OledOperValue.cStrBuff[row], (const int8*)" ", 7U);
|
||
|
||
// Label 2
|
||
CStrncat(OledOperValue.cStrBuff[row], label2, CStrLen(label2));
|
||
|
||
// Status 2
|
||
CStrncat(OledOperValue.cStrBuff[row], statusStr2, CStrLen(statusStr2));
|
||
|
||
CDrawStr(0U, drawY, OledOperValue.cStrBuff[row], CStrLen(OledOperValue.cStrBuff[row]));
|
||
}
|
||
static void CPageApu1(void)
|
||
{
|
||
const int8 *cTemp = "";
|
||
float32 fTemp;
|
||
|
||
// TITLE
|
||
CDrawPageTitle("APU Status", "1/2");
|
||
|
||
// LINE 1
|
||
fTemp = Rx220.GcuData.DcVoltage;
|
||
CDrawPageLineFloat(OLED_ROW_1, "DC Voltage ", fTemp, " V");
|
||
|
||
// LINE 2
|
||
fTemp = Rx220.GcuData.DcCurrent;
|
||
CDrawPageLineFloat(OLED_ROW_2, "DC Current ", fTemp, " A");
|
||
|
||
// LINE 3
|
||
fTemp = (Rx220.GcuData.DcVoltage * Rx220.GcuData.DcCurrent);
|
||
CDrawPageLineFloat(OLED_ROW_3, "Power ", fTemp, " kW");
|
||
|
||
// LINE 4
|
||
cTemp = CGetApuStateString((eApuOperIdx)GeneralOperValue.uiApuState);
|
||
CStrncpy(OledOperValue.cStrBuff[OLED_ROW_4], "Status", CStrLen((const int8*)"Status"));
|
||
CAddLineIndent(OledOperValue.cStrBuff[OLED_ROW_4], cTemp);
|
||
CStrncat(OledOperValue.cStrBuff[OLED_ROW_4], cTemp, CStrLen(cTemp));
|
||
CDrawStr(0U, OLED_LINE_4, OledOperValue.cStrBuff[OLED_ROW_4], CStrLen(OledOperValue.cStrBuff[OLED_ROW_4]));
|
||
}
|
||
|
||
static void CPageApu2(void)
|
||
{
|
||
int16 iTemp;
|
||
|
||
// TITLE
|
||
CDrawPageTitle("APU Status", "2/2");
|
||
|
||
// LINE 1
|
||
iTemp = CGetEngineActualRpm();
|
||
CDrawPageLineInt(OLED_ROW_1, "ENG.RPM ", (int32)iTemp, " rpm");
|
||
|
||
// LINE 2
|
||
iTemp = CGetEngCoolantTemperature();
|
||
CDrawPageLineInt(OLED_ROW_2, "Coolant ", (int32)iTemp, " ¡É");
|
||
|
||
// LINE 3
|
||
iTemp = Rx320.EcuData.ActualTorque;
|
||
CDrawPageLineInt(OLED_ROW_3, "Torque ", (int32)iTemp, " %");
|
||
|
||
// LINE 4
|
||
CHourToString((int32)GeneralOperValue.ulTotalOperationHour, pNumBuffer);
|
||
CDrawPageLine(OLED_ROW_4, "ENG.Hour ", pNumBuffer, " Hr");
|
||
}
|
||
static void CPageMenu1(void)
|
||
{
|
||
// TITLE
|
||
CDrawPageTitle("Menu", "1/2");
|
||
|
||
// LINE 1
|
||
CLineFocus((OledOperValue.uiFocusLine == 0U) ? 1U : 0U);
|
||
CDrawPageLine(OLED_ROW_1, "1. APU Status ", NULL, NULL);
|
||
|
||
// LINE 2
|
||
CLineFocus((OledOperValue.uiFocusLine == 1U) ? 1U : 0U);
|
||
CDrawPageLine(OLED_ROW_2, "2. Temperature ", NULL, NULL);
|
||
|
||
// LINE 3
|
||
CLineFocus((OledOperValue.uiFocusLine == 2U) ? 1U : 0U);
|
||
CDrawPageLine(OLED_ROW_3, "3. Sensor ", NULL, NULL);
|
||
|
||
// LINE 4
|
||
CLineFocus((OledOperValue.uiFocusLine == 3U) ? 1U : 0U);
|
||
CDrawPageLine(OLED_ROW_4, "4. Warning ", NULL, NULL);
|
||
}
|
||
|
||
static void CPageMenu2(void)
|
||
{
|
||
// TITLE
|
||
CDrawPageTitle("Menu", "2/2");
|
||
|
||
// LINE 1
|
||
CLineFocus((OledOperValue.uiFocusLine == 0U) ? 1U : 0U);
|
||
CDrawPageLine(OLED_ROW_1, "5. Fault ", NULL, NULL);
|
||
|
||
// LINE 2
|
||
CLineFocus((OledOperValue.uiFocusLine == 1U) ? 1U : 0U);
|
||
CDrawPageLine(OLED_ROW_2, "6. Alarm Reset ", NULL, NULL);
|
||
|
||
// LINE 3
|
||
CLineFocus((OledOperValue.uiFocusLine == 2U) ? 1U : 0U);
|
||
CDrawPageLine(OLED_ROW_3, "7. Maintenence ", NULL, NULL);
|
||
}
|
||
|
||
static void CPageTemp(void)
|
||
{
|
||
int16 iTemp;
|
||
|
||
// TITLE
|
||
CDrawPageTitle("Temperature", "1/1");
|
||
|
||
// LINE 1
|
||
iTemp = Rx221.GcuData.PcbTemperature - 40;
|
||
CDrawPageLineInt(OLED_ROW_1, "PCB Temp. ", (int32)iTemp, " ¡É");
|
||
|
||
// LINE 2
|
||
iTemp = Rx221.GcuData.FetTemperature - 40;
|
||
CDrawPageLineInt(OLED_ROW_2, "FET Temp. ", (int32)iTemp, " ¡É");
|
||
|
||
// LINE 3
|
||
iTemp = Rx221.GcuData.GenTemperature1 - 40;
|
||
CDrawPageLineInt(OLED_ROW_3, "Gen.Temp1. ", (int32)iTemp, " ¡É");
|
||
|
||
// LINE4
|
||
iTemp = Rx221.GcuData.GenTemperature2 - 40;
|
||
CDrawPageLineInt(OLED_ROW_4, "Gen.Temp2. ", (int32)iTemp, " ¡É");
|
||
}
|
||
static void CPageSensor1(void)
|
||
{
|
||
float32 fTemp;
|
||
|
||
// TITLE
|
||
CDrawPageTitle("Apu Sensor", "1/4");
|
||
|
||
// LINE 1
|
||
fTemp = (Adc_EngineHeater_I.fLpfValue < 0.0f) ? 0.0f : Adc_EngineHeater_I.fLpfValue;
|
||
CDrawPageLineFloat(OLED_ROW_1, "EngineHeater", fTemp, " A");
|
||
|
||
// LINE 2
|
||
fTemp = (Adc_GlowPlug_I.fLpfValue < 0.0f) ? 0.0f : Adc_GlowPlug_I.fLpfValue;
|
||
CDrawPageLineFloat(OLED_ROW_2, "GlowPlug ", fTemp, " A");
|
||
|
||
// LINE 3
|
||
fTemp = (Adc_Solenoid_I.fLpfValue < 0.0f) ? 0.0f : Adc_Solenoid_I.fLpfValue;
|
||
CDrawPageLineFloat(OLED_ROW_3, "Solenoid ", fTemp, " A");
|
||
|
||
// LINE 4
|
||
fTemp = (Adc_FuelPump_I.fLpfValue < 0.0f) ? 0.0f : Adc_FuelPump_I.fLpfValue;
|
||
CDrawPageLineFloat(OLED_ROW_4, "FuelPump ", fTemp, " A");
|
||
}
|
||
|
||
static void CPageSensor2(void)
|
||
{
|
||
float32 fTemp;
|
||
|
||
// TITLE
|
||
CDrawPageTitle("Apu Sensor", "2/4");
|
||
|
||
// LINE 1
|
||
fTemp = (Adc_CoolantPump_I.fLpfValue < 0.0f) ? 0.0f : Adc_CoolantPump_I.fLpfValue;
|
||
CDrawPageLineFloat(OLED_ROW_1, "CoolantPump ", fTemp, " A");
|
||
|
||
// LINE 2
|
||
fTemp = (Adc_Fan1_I.fLpfValue < 0.0f) ? 0.0f : Adc_Fan1_I.fLpfValue;
|
||
CDrawPageLineFloat(OLED_ROW_2, "Fan1 ", fTemp, " A");
|
||
|
||
// LINE 3
|
||
fTemp = (Adc_Fan2_I.fLpfValue < 0.0f) ? 0.0f : Adc_Fan2_I.fLpfValue;
|
||
CDrawPageLineFloat(OLED_ROW_3, "Fan2 ", fTemp, " A");
|
||
}
|
||
|
||
static void CPageSensor3(void)
|
||
{
|
||
int16 iTemp;
|
||
|
||
// TITLE
|
||
CDrawPageTitle("ECU Sensor", "3/4");
|
||
|
||
// LINE 1
|
||
iTemp = Rx321.EcuData.BarometicPressure;
|
||
CDrawPageLineInt(OLED_ROW_1, "Barometric ", (int32)iTemp, " mb");
|
||
|
||
// LINE 2
|
||
iTemp = Rx321.EcuData.Fan1Speed;
|
||
CDrawPageLineInt(OLED_ROW_2, "Fan1 Speed ", (int32)iTemp, " %");
|
||
|
||
// LINE 3
|
||
iTemp = Rx321.EcuData.Fan2Speed;
|
||
CDrawPageLineInt(OLED_ROW_3, "Fan2 Speed ", (int32)iTemp, " %");
|
||
|
||
// LINE 4
|
||
iTemp = Rx321.EcuData.CoolantPumpSpeed;
|
||
CDrawPageLineInt(OLED_ROW_4, "C.Pump Speed ", (int32)iTemp, " %");
|
||
}
|
||
|
||
static void CPageSensor4(void)
|
||
{
|
||
int16 iTemp;
|
||
|
||
// TITLE
|
||
CDrawPageTitle("GCU Sensor", "4/4");
|
||
|
||
// LINE 1
|
||
iTemp = Rx220.GcuData.Rpm;
|
||
CDrawPageLineInt(OLED_ROW_1, "GEN.RPM ", (int32)iTemp, " rpm");
|
||
}
|
||
static void CDrawPageLineStatus(Uint16 row, const int8* label, Uint16 status)
|
||
{
|
||
const int8* statusStr = (status == 1U) ? (const int8*)"1" : (const int8*)"0";
|
||
CDrawPageLine(row, label, statusStr, NULL);
|
||
}
|
||
|
||
static void CPageWarning1(void)
|
||
{
|
||
// TITLE
|
||
CDrawPageTitle("Warning", "1/2");
|
||
|
||
// LINE 1
|
||
CDrawTwoStatusLine(OLED_ROW_1, "PCBOT:", Rx210.GcuWarning.bit.PcbOverHeat, "FETOT:", Rx210.GcuWarning.bit.FetOverHeat);
|
||
|
||
// LINE 2
|
||
CDrawTwoStatusLine(OLED_ROW_2, "GEOT1:", Rx210.GcuWarning.bit.GenOverHeat1, "GEOT2:", Rx210.GcuWarning.bit.GenOverHeat2);
|
||
|
||
// LINE 3
|
||
CDrawTwoStatusLine(OLED_ROW_3, "ENGOT:", Rx310.EcuWarning.bit.EngineOverHeat, "L-OIL:", Rx310.EcuWarning.bit.LowOilLevel);
|
||
|
||
// LINE 4
|
||
CDrawTwoStatusLine(OLED_ROW_4, "INTOT:", Rx310.EcuWarning.bit.IntakeOverHeat, "INTLP:", Rx310.EcuWarning.bit.IntakeLoPressure);
|
||
}
|
||
|
||
static void CPageWarning2(void)
|
||
{
|
||
// TITLE
|
||
CDrawPageTitle("Warning", "2/2");
|
||
|
||
// LINE 1
|
||
CDrawTwoStatusLine(OLED_ROW_1, "ENGLT:", Rx310.EcuWarning.bit.EngineLoTemperature, "ENGSF:", Rx310.EcuWarning.bit.EngineSensor);
|
||
|
||
// LINE 2
|
||
CDrawPageLineStatus(OLED_ROW_2, "DEFAC:", Rx310.EcuWarning.bit.DefaltValueActive);
|
||
}
|
||
static void CPageFault1(void)
|
||
{
|
||
// TITLE
|
||
CDrawPageTitle("Apu Fault", "1/6");
|
||
|
||
// LINE 1
|
||
CDrawTwoStatusLine(OLED_ROW_1, "CARCT:", FaultBitValue.bit.CarCommTimeout, "GCUCT:", FaultBitValue.bit.GcuCommTimeout);
|
||
|
||
// LINE 2
|
||
CDrawTwoStatusLine(OLED_ROW_2, "ECUCT:", FaultBitValue.bit.EcuCommTimeOut, "RPMER:", FaultBitValue.bit.RpmError);
|
||
|
||
// LINE 3
|
||
CDrawTwoStatusLine(OLED_ROW_3, "EHLOC:", FaultBitValue.bit.EngineHeatOverCurrent, "GPLOC:", FaultBitValue.bit.GlowPlugOverCurrent);
|
||
|
||
// LINE 4
|
||
CDrawTwoStatusLine(OLED_ROW_4, "SOLOC:", FaultBitValue.bit.SolenoidOverCurrent, "FPLOC:", FaultBitValue.bit.FuelPumpOverCurrent);
|
||
}
|
||
|
||
static void CPageFault2(void)
|
||
{
|
||
// TITLE
|
||
CDrawPageTitle("Apu Fault", "2/6");
|
||
|
||
// LINE 1
|
||
CDrawTwoStatusLine(OLED_ROW_1, "CPLOC:", FaultBitValue.bit.CoolantPumpOverCurrent, "F1LOC:", FaultBitValue.bit.Fan1OverCurrent);
|
||
|
||
// LINE 2
|
||
CDrawTwoStatusLine(OLED_ROW_2, "F2LOC:", FaultBitValue.bit.Fan2OverCurrent, "EHLLO:", FaultBitValue.bit.EngineHeatOpen);
|
||
|
||
// LINE 3
|
||
CDrawTwoStatusLine(OLED_ROW_3, "GPLLO:", FaultBitValue.bit.GlowPlugOpen, "SOLLO:", FaultBitValue.bit.SolenoidOpen);
|
||
|
||
// LINE 4
|
||
CDrawTwoStatusLine(OLED_ROW_4, "FPLLO:", FaultBitValue.bit.FuelPumpOpen, "CPLLO:", FaultBitValue.bit.CoolantPumpOpen);
|
||
}
|
||
|
||
static void CPageFault3(void)
|
||
{
|
||
// TITLE
|
||
CDrawPageTitle("Apu Fault", "3/6");
|
||
|
||
// LINE 1
|
||
CDrawTwoStatusLine(OLED_ROW_1, "F1LLO:", FaultBitValue.bit.Fan1Open, "F2LLO:", FaultBitValue.bit.Fan2Open);
|
||
}
|
||
|
||
static void CPageFault4(void)
|
||
{
|
||
// TITLE
|
||
CDrawPageTitle("Gcu Fault", "4/6");
|
||
|
||
// LINE 1
|
||
CDrawTwoStatusLine(OLED_ROW_1, "HTRIP:", Rx210.GcuFault.bit.HwTrip, "HIGBT:", Rx210.GcuFault.bit.HwIgbt);
|
||
|
||
// LINE 2
|
||
CDrawTwoStatusLine(OLED_ROW_2, "HDCOV:", Rx210.GcuFault.bit.HwDc, "GNOCU:", Rx210.GcuFault.bit.GenOverCurrentU);
|
||
|
||
// LINE 3
|
||
CDrawTwoStatusLine(OLED_ROW_3, "GNOCV:", Rx210.GcuFault.bit.GenOverCurrentV, "GNOCW:", Rx210.GcuFault.bit.GenOverCurrentW);
|
||
|
||
// LINE 4
|
||
CDrawTwoStatusLine(OLED_ROW_4, "SDCOV:", Rx210.GcuFault.bit.DcOverVoltage, "SDCOC:", Rx210.GcuFault.bit.DcOverCurrent);
|
||
}
|
||
|
||
static void CPageFault5(void)
|
||
{
|
||
// TITLE
|
||
CDrawPageTitle("Gcu Fault", "5/6");
|
||
|
||
// LINE 1
|
||
CDrawTwoStatusLine(OLED_ROW_1, "SMOOC:", Rx210.GcuFault.bit.CrankningOverCurrent, "PCBOT:", Rx210.GcuFault.bit.PcbOverHeat);
|
||
|
||
// LINE 2
|
||
CDrawTwoStatusLine(OLED_ROW_2, "FETOT:", Rx210.GcuFault.bit.FetOverHeat, "GW1OT:", Rx210.GcuFault.bit.GenTempOverHeat1);
|
||
|
||
// LINE 3
|
||
CDrawTwoStatusLine(OLED_ROW_3, "GW2OT:", Rx210.GcuFault.bit.GenTempOverHeat2, "GENOS:", Rx210.GcuFault.bit.GenOverSpeed);
|
||
|
||
// LINE 4
|
||
CDrawTwoStatusLine(OLED_ROW_4, "RSICF:", Rx210.GcuFault.bit.ResolverIC, "RSPRT:", Rx210.GcuFault.bit.ResolverParity);
|
||
}
|
||
|
||
static void CPageFault6(void)
|
||
{
|
||
// TITLE
|
||
CDrawPageTitle("Ecu Fault", "6/6");
|
||
|
||
// LINE 1
|
||
CDrawTwoStatusLine(OLED_ROW_1, "OILMS:", Rx310.EcuFault.bit.OilPressureMissing, "INTOT:", Rx310.EcuFault.bit.IntakeOverHeat);
|
||
|
||
// LINE 2
|
||
CDrawTwoStatusLine(OLED_ROW_2, "ENGOT:", Rx310.EcuFault.bit.EngineOverHeat, "ACTUA:", Rx310.EcuFault.bit.Actuator);
|
||
|
||
// LINE 3
|
||
CDrawTwoStatusLine(OLED_ROW_3, "RPMSG:", Rx310.EcuFault.bit.RpmSignal, "ENGSF:", Rx310.EcuFault.bit.EngineStartFail);
|
||
}
|
||
static void CDrawAlarmBox(void)
|
||
{
|
||
CDrawLine(5U, 10U, 122U, 10U); // Top
|
||
CDrawLine(5U, 10U, 5U, 58U); // Left
|
||
CDrawLine(5U, 59U, 122U, 59U); // Bottom
|
||
CDrawLine(122U, 10U, 122U, 58U); // Right
|
||
}
|
||
|
||
static void CDrawPostStatusLine(Uint16 row, const int8* l1, Uint16 s1, const int8* l2, Uint16 s2, const int8* l3, Uint16 s3)
|
||
{
|
||
const int8* s1Str = (s1 == 0U) ? (const int8*)"P" : (const int8*)"F";
|
||
Uint16 y = 0U;
|
||
|
||
// Label 1 + Status 1
|
||
CStrncpy(OledOperValue.cStrBuff[row], l1, CStrLen(l1));
|
||
CStrncat(OledOperValue.cStrBuff[row], s1Str, 1U);
|
||
|
||
// Label 2 + Status 2
|
||
if (l2 != NULL)
|
||
{
|
||
CStrncat(OledOperValue.cStrBuff[row], (const int8*)" ", 2U);
|
||
CStrncat(OledOperValue.cStrBuff[row], l2, CStrLen(l2));
|
||
CStrncat(OledOperValue.cStrBuff[row], (s2 == 0U) ? (const int8*)"P" : (const int8*)"F", 1U);
|
||
}
|
||
|
||
// Label 3 + Status 3
|
||
if (l3 != NULL)
|
||
{
|
||
CStrncat(OledOperValue.cStrBuff[row], (const int8*)" ", 2U);
|
||
CStrncat(OledOperValue.cStrBuff[row], l3, 13U);
|
||
CStrncat(OledOperValue.cStrBuff[row], (s3 == 0U) ? (const int8*)"P" : (const int8*)"F", 1U);
|
||
}
|
||
|
||
CTextAlign(OledOperValue.cAlignBuffer, OledOperValue.cStrBuff[row]);
|
||
|
||
switch(row)
|
||
{
|
||
case OLED_ROW_2: y = OLED_LINE_2; break;
|
||
case OLED_ROW_3: y = OLED_LINE_3; break;
|
||
case OLED_ROW_4: y = OLED_LINE_4; break;
|
||
default: break;
|
||
}
|
||
CDrawStr(0U, y, OledOperValue.cAlignBuffer, CStrLen(OledOperValue.cAlignBuffer));
|
||
}
|
||
static void CPageAlarmReset(void)
|
||
{
|
||
const int8 *cTemp = "";
|
||
|
||
// LINE 1
|
||
CDrawCenteredLine(OLED_LINE_1, "Reset all faults?");
|
||
|
||
// LINE 2
|
||
CDrawCenteredLine(OLED_LINE_2, "(no clear warnings)");
|
||
|
||
// LINE 3
|
||
cTemp = (OledOperValue.uiResetAnswer == 1U) ? (int8*)"YES" : (int8*)" NO";
|
||
CDrawCenteredLine(OLED_LINE_3 + 5U, cTemp);
|
||
|
||
// BOX
|
||
CDrawAlarmBox();
|
||
}
|
||
static void CPagePassword(void)
|
||
{
|
||
const int8 *cTemp = "";
|
||
int8 maskBuffer[16];
|
||
int16 iTemp[2] = { 0, '\0' };
|
||
|
||
// TITLE
|
||
CDrawPageTitle("Input Password", NULL);
|
||
|
||
switch (OledOperValue.uiFocusDigit)
|
||
{
|
||
case OLED_PASS_DIGIT_1:
|
||
{
|
||
iTemp[0] = GeneralOperValue.uiPassword[OLED_PASS_DIGIT_1] + '0';
|
||
cTemp = (int8*)iTemp;
|
||
CStrncpy(maskBuffer, "[", 2);
|
||
CStrncat(maskBuffer, cTemp, 1);
|
||
CStrncat(maskBuffer, "][*][*][*]", 10);
|
||
break;
|
||
}
|
||
case OLED_PASS_DIGIT_2:
|
||
{
|
||
iTemp[0] = GeneralOperValue.uiPassword[OLED_PASS_DIGIT_2] + '0';
|
||
cTemp = (int8*)iTemp;
|
||
CStrncpy(maskBuffer, "[*][", 4);
|
||
CStrncat(maskBuffer, cTemp, 1);
|
||
CStrncat(maskBuffer, "][*][*]", 7);
|
||
break;
|
||
}
|
||
case OLED_PASS_DIGIT_3:
|
||
{
|
||
iTemp[0] = GeneralOperValue.uiPassword[OLED_PASS_DIGIT_3] + '0';
|
||
cTemp = (int8*)iTemp;
|
||
CStrncpy(maskBuffer, "[*][*][", 7);
|
||
CStrncat(maskBuffer, cTemp, 1);
|
||
CStrncat(maskBuffer, "][*]", 4);
|
||
break;
|
||
}
|
||
default:
|
||
{
|
||
iTemp[0] = GeneralOperValue.uiPassword[OLED_PASS_DIGIT_4] + '0';
|
||
cTemp = (int8*)iTemp;
|
||
CStrncpy(maskBuffer, "[*][*][*][", 10);
|
||
CStrncat(maskBuffer, cTemp, 1);
|
||
CStrncat(maskBuffer, "]", 1);
|
||
break;
|
||
}
|
||
}
|
||
|
||
CTextAlign(OledOperValue.cAlignBuffer, maskBuffer);
|
||
CDrawStr(0U, OLED_LINE_2, OledOperValue.cAlignBuffer, CStrLen(OledOperValue.cAlignBuffer));
|
||
}
|
||
static void CPageMaintenence(void)
|
||
{
|
||
const int8 *cTemp = "";
|
||
|
||
// TITLE
|
||
CDrawPageTitle("Maintenence", "1/1");
|
||
|
||
// LINE 1
|
||
CLineFocus((OledOperValue.uiFocusLine == OLED_LINE_FOCUS_1) ? 1U : 0U);
|
||
cTemp = (GeneralOperValue.Maintenence.ManualCranking > 0U) ? (int8*)"ON " : (int8*)"OFF";
|
||
CDrawPageLine(OLED_ROW_1, "Manual Cranking ", cTemp, NULL);
|
||
|
||
// LINE 2
|
||
CLineFocus((OledOperValue.uiFocusLine == OLED_LINE_FOCUS_2) ? 1U : 0U);
|
||
cTemp = (GeneralOperValue.Maintenence.LampTest > 0U) ? (int8*)"ON " : (int8*)"OFF";
|
||
CDrawPageLine(OLED_ROW_2, "Lamp Test ", cTemp, NULL);
|
||
|
||
// LINE 3
|
||
CLineFocus((OledOperValue.uiFocusLine == OLED_LINE_FOCUS_3) ? 1U : 0U);
|
||
CDrawPageLine(OLED_ROW_3, "Switch Test ", NULL, NULL);
|
||
}
|
||
static void CDrawCenteredLine(Uint16 y, const int8* text)
|
||
{
|
||
CStrncpy(OledOperValue.cStrBuff[OLED_ROW_0], text, CStrLen(text));
|
||
CTextAlign(OledOperValue.cAlignBuffer, OledOperValue.cStrBuff[OLED_ROW_0]);
|
||
CDrawStr(0U, y, OledOperValue.cAlignBuffer, CStrLen(OledOperValue.cAlignBuffer));
|
||
}
|
||
|
||
static void CDrawKeyTestBox(void)
|
||
{
|
||
CDrawLine(0U, 0U, 125U, 0U); // Top
|
||
CDrawLine(0U, 0U, 0U, 22U); // Left
|
||
CDrawLine(0U, 23U, 2U, 25U); // Left diag
|
||
CDrawLine(3U, 25U, 123U, 25U); // Bottom
|
||
CDrawLine(124U, 25U, 126U, 23U); // Right diag
|
||
CDrawLine(126U, 0U, 126U, 22U); // Right
|
||
}
|
||
|
||
static void CDrawKeyStatusLine(Uint16 row, const int8* l1, Uint16 s1, const int8* l2, Uint16 s2, const int8* l3, Uint16 s3)
|
||
{
|
||
const int8* s1Str = (s1 == 1U) ? (const int8*)"1" : (const int8*)"0";
|
||
|
||
// Label 1 + Status 1
|
||
CStrncpy(OledOperValue.cStrBuff[row], l1, CStrLen(l1));
|
||
CStrncat(OledOperValue.cStrBuff[row], s1Str, 1U);
|
||
|
||
// Label 2 + Status 2
|
||
if (l2 != NULL)
|
||
{
|
||
CStrncat(OledOperValue.cStrBuff[row], (const int8*)" ", 1U);
|
||
CStrncat(OledOperValue.cStrBuff[row], l2, CStrLen(l2));
|
||
CStrncat(OledOperValue.cStrBuff[row], (s2 == 1U) ? (const int8*)"1" : (const int8*)"0", 1U);
|
||
}
|
||
|
||
// Label 3 + Status 3
|
||
if (l3 != NULL)
|
||
{
|
||
CStrncat(OledOperValue.cStrBuff[row], (const int8*)" ", 1U);
|
||
CStrncat(OledOperValue.cStrBuff[row], l3, CStrLen(l3));
|
||
CStrncat(OledOperValue.cStrBuff[row], (s3 == 1U) ? (const int8*)"1" : (const int8*)"0", 1U);
|
||
}
|
||
|
||
// Determine Y based on row
|
||
Uint16 y = 0U;
|
||
switch(row) {
|
||
case OLED_ROW_2: y = OLED_LINE_2; break;
|
||
case OLED_ROW_3: y = OLED_LINE_3; break;
|
||
case OLED_ROW_4: y = OLED_LINE_4; break;
|
||
default: break;
|
||
}
|
||
CDrawStr(0U, y, OledOperValue.cStrBuff[row], CStrLen(OledOperValue.cStrBuff[row]));
|
||
}
|
||
static void CPageKeyTest(void)
|
||
{
|
||
// TITLE1
|
||
CDrawCenteredLine(OLED_LINE_TITLE + 2U, "Key input Test");
|
||
|
||
// TITLE2
|
||
CDrawCenteredLine(OLED_LINE_1 - 1U, "(Back to Up&Down)");
|
||
|
||
// BOX
|
||
CDrawKeyTestBox();
|
||
|
||
// LINE 2
|
||
// " Stat:" + Status
|
||
// This is special indentation.
|
||
// I can reuse CDrawKeyStatusLine if I pass proper label.
|
||
// " Stat:" is 19 chars.
|
||
CDrawKeyStatusLine(OLED_ROW_2, " Stat:", GPIO_KEY_START(), NULL, 0, NULL, 0);
|
||
|
||
// LINE 3
|
||
// " Up:" + s + " " + "Entr:" + s + " " + "Powr:" + s
|
||
CDrawKeyStatusLine(OLED_ROW_3, " Up:", GPIO_KEY_UP(), "Entr:", GPIO_KEY_ENTER(), "Powr:", GPIO_KEY_POWER());
|
||
|
||
// LINE 4
|
||
// "Down:" + s + " " + "Menu:" + s + " " + "Emgc:" + s
|
||
CDrawKeyStatusLine(OLED_ROW_4, "Down:", GPIO_KEY_DOWN(), "Menu:", GPIO_KEY_MENU(), "Emgc:", GPIO_KEY_EMERGENCY());
|
||
}
|
||
static void CPageShutdown(void)
|
||
{
|
||
// LINE 1
|
||
CDrawCenteredLine(OLED_LINE_1, "System");
|
||
|
||
// LINE 2
|
||
CDrawCenteredLine(OLED_LINE_2, "Shutting down...");
|
||
}
|
||
void CSetPage(Uint16 PageNum)
|
||
{
|
||
int16 i;
|
||
|
||
if (OledOperValue.uiOldPageNum != PageNum)
|
||
{
|
||
COledBufferReset();
|
||
OledOperValue.uiOldPageNum = PageNum;
|
||
}
|
||
|
||
for (i = 0; i < OLED_PAGE_MAX; i++)
|
||
{
|
||
if (OledOperValue.uiPageNum == i)
|
||
{
|
||
CLineFocus(0U);
|
||
PageTable[i].pAction(); // CPageHandler ÂüÁ¶
|
||
}
|
||
}
|
||
}
|
||
|
||
void COledBufferReset(void)
|
||
{
|
||
(void) memset(OledOperValue.uiBuff, 0, sizeof(int8) * OLED_WIDTH * OLED_PAGE);
|
||
(void) memset(OledOperValue.cStrBuff, 0, sizeof(int8) * TXT_LINE_LEN * TXT_MAX_LEN);
|
||
}
|
||
|
||
static void CDrawTitleBox(Uint16 TitleLen)
|
||
{
|
||
CDrawLine(8U, 0U, 8U, 9U); // ¿ÞÂÊ
|
||
CDrawLine(8U, 10U, 10U, 12U); // ¿ÞÂÊ ¸ð¼¸®
|
||
CDrawLine(11U, 12U, (TitleLen + 9U), 12U); // ¾Æ·¡ÂÊ
|
||
CDrawLine((TitleLen + 10U), 12U, (TitleLen + 12U), 10U); // ¿À¸¥ÂÊ ¸ð¼¸®
|
||
CDrawLine((TitleLen + 12U), 0U, (TitleLen + 12U), 9U); // ¿À¸¥ÂÊ
|
||
|
||
if (OledOperValue.uiPageNum != OLED_PAGE_PASSWORD)
|
||
{
|
||
// ¼ºê ŸÀÌƲ ¹Ú½º
|
||
CDrawLine(98U, 0U, 98U, 9U); // ¿ÞÂÊ
|
||
CDrawLine(98U, 10U, 100U, 12U); // ¿ÞÂÊ ¸ð¼¸®
|
||
CDrawLine(101U, 12U, 118U, 12U); // ¾Æ·¡ÂÊ
|
||
CDrawLine(119U, 12U, 121U, 10U); // ¿À¸¥ÂÊ ¸ð¼¸®
|
||
CDrawLine(121U, 0U, 121U, 9U); // ¿À¸¥ÂÊ
|
||
}
|
||
}
|
||
|
||
void COledReflash(Uint16 x, Uint16 y, Uint16 width, Uint16 height)
|
||
{
|
||
Uint16 i, j;
|
||
|
||
for (j = y / 8; j < (y + height) / 8; j++)
|
||
{
|
||
for (i = x; i < (x + width); i++)
|
||
{
|
||
CSetPageAddress(j);
|
||
CSetColumnAddress(i);
|
||
COledWrite(OledOperValue.uiBuff[i][j], MODE_DATA);
|
||
}
|
||
}
|
||
}
|
||
|
||
void CInitOled(void)
|
||
{
|
||
Uint16 uiPageNum;
|
||
int16 i;
|
||
|
||
CInitOledModule();
|
||
|
||
for(uiPageNum = 0; uiPageNum < 8; uiPageNum++)
|
||
{
|
||
COledWrite((Uint16)(0xB0 | uiPageNum), MODE_COMMAND);
|
||
|
||
for(i = 0; i < OLED_WIDTH; i++)
|
||
{
|
||
COledWrite(0x00, MODE_DATA);
|
||
}
|
||
}
|
||
|
||
CInitProgress();
|
||
}
|
||
|
||
void CInitProgress(void)
|
||
{
|
||
OledOperValue.Color.TxtColor = 1U;
|
||
|
||
CTextAlign(OledOperValue.cAlignBuffer, "K2 APU");
|
||
CDrawStr(0, OLED_LINE_TITLE, OledOperValue.cAlignBuffer, CStrLen(OledOperValue.cAlignBuffer));
|
||
|
||
CDrawBox(OLED_LOAD_PROGRESS_X, OLED_LOAD_PROGRESS_Y, OLED_LOAD_PROGRESS_W, OLED_LOAD_PROGRESS_H);
|
||
|
||
(void) memset(OledOperValue.cAlignBuffer, 0, sizeof(char) * TXT_MAX_LEN);
|
||
|
||
CTextAlign(OledOperValue.cAlignBuffer, "Initializing System");
|
||
CDrawStr(0, OLED_LINE_2, OledOperValue.cAlignBuffer, CStrLen(OledOperValue.cAlignBuffer));
|
||
}
|
||
|
||
void CAddLineIndent(int8 *buffer, const int8 *str)
|
||
{
|
||
Uint16 i;
|
||
Uint16 uiSpaceNeeded = (TXT_MAX_LEN - 1) - CStrLen(buffer) - CStrLen(str);
|
||
|
||
if (uiSpaceNeeded > 0)
|
||
{
|
||
for (i = 0U; i < uiSpaceNeeded; i++)
|
||
{
|
||
CStrncat(buffer, " ", 1);
|
||
}
|
||
}
|
||
}
|
||
|
||
void CTextAlign(int8 *buffer, const int8 *str)
|
||
{
|
||
Uint16 uiIndent, uiLen, i, j;
|
||
|
||
uiLen = 0;
|
||
i = 0;
|
||
|
||
while (str[i] != '\0') // strÀº int8* À̹ǷÎ, int8 ŸÀÔÀÇ ³Î Á¾·á °ª(0) ãÀ½
|
||
{
|
||
uiLen++;
|
||
i++;
|
||
}
|
||
|
||
if (uiLen >= TXT_MAX_LEN)
|
||
{
|
||
uiIndent = 0;
|
||
}
|
||
else
|
||
{
|
||
uiIndent = ((TXT_MAX_LEN - 1U) - uiLen) / 2U;
|
||
}
|
||
|
||
if ((uiIndent > 0U) && (uiIndent < TXT_MAX_LEN)) // ¸®¼Ò½º °úµµ ¼Òºñ ¹æÁö
|
||
{
|
||
for (i = 0U; i < uiIndent; i++)
|
||
{
|
||
buffer[i] = (int8)' ';
|
||
}
|
||
|
||
for (j = 0U; j < uiLen; j++)
|
||
{
|
||
buffer[i + j] = str[j];
|
||
}
|
||
}
|
||
|
||
buffer[i + uiLen] = 0;
|
||
}
|
||
|
||
void CDrawBox(Uint16 x, Uint16 y, Uint16 w, Uint16 h)
|
||
{
|
||
CDrawLine(x, y, w, y); // Àº¯
|
||
CDrawLine(x, (y + 1U), x, (y + h)); // ÁÂÃø ¸·´ë
|
||
CDrawLine(x, (y + h), w, (y + h)); // ¾Æ·§ º¯
|
||
CDrawLine(w, (y + 1U), w, (y + h - 1U)); // ¿ìÃø ¸·´ë
|
||
}
|
||
|
||
void CSetDrawRegion(Uint16 x1, Uint16 y1, Uint16 x2, Uint16 y2)
|
||
{
|
||
if (x2 > OledOperValue.Point.X2)
|
||
{
|
||
OledOperValue.Point.X2 = x2;
|
||
}
|
||
if (y2 > OledOperValue.Point.Y2)
|
||
{
|
||
OledOperValue.Point.Y2 = y2;
|
||
}
|
||
}
|
||
|
||
void CDrawLine(Uint16 x1, Uint16 y1, Uint16 x2, Uint16 y2)
|
||
{
|
||
Uint16 tmp = 0, x = 0, y = 0, dx = 0, dy = 0, swapxy = 0;
|
||
Uint16 loop_end = 0;
|
||
Uint16 minor_limit = 0; // º¸Á¶Ãà(y) ÇÑ°è°ª
|
||
int16 err = 0, ystep = 0;
|
||
|
||
dx = x2 - x1;
|
||
|
||
dy = (y1 > y2) ? (y1 - y2) : (y2 - y1);
|
||
|
||
if (dy > dx)
|
||
{
|
||
swapxy = 1;
|
||
tmp = dx; dx = dy; dy = tmp;
|
||
tmp = x1; x1 = y1; y1 = tmp;
|
||
tmp = x2; x2 = y2; y2 = tmp;
|
||
|
||
loop_end = OLED_HEIGHT - 1;
|
||
minor_limit = OLED_WIDTH - 1;
|
||
}
|
||
else
|
||
{
|
||
loop_end = OLED_WIDTH - 1;
|
||
minor_limit = OLED_HEIGHT - 1;
|
||
}
|
||
|
||
if (x2 > loop_end)
|
||
{
|
||
x2 = loop_end;
|
||
}
|
||
|
||
err = dx >> 1;
|
||
ystep = (y2 > y1) ? 1 : -1;
|
||
y = y1;
|
||
|
||
if (swapxy == 0)
|
||
{
|
||
for(x = x1; x <= x2; x++)
|
||
{
|
||
if (y > minor_limit) break;
|
||
|
||
CPutPixel(x, y, OledOperValue.Color.TxtColor);
|
||
|
||
err -= (Uint16) dy;
|
||
if ( err < 0 )
|
||
{
|
||
y += (Uint16) ystep;
|
||
err += (Uint16) dx;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
for(x = x1; x <= x2; x++)
|
||
{
|
||
if (y > minor_limit) break;
|
||
|
||
CPutPixel(y, x, OledOperValue.Color.TxtColor);
|
||
|
||
err -= (Uint16) dy;
|
||
if ( err < 0 )
|
||
{
|
||
y += (Uint16) ystep;
|
||
err += (Uint16) dx;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
static inline void CPutPixel(Uint16 x, Uint16 y, Uint16 Color)
|
||
{
|
||
Uint16 uiPage = y / 8U;
|
||
Uint16 uiOffset = y % 8U;
|
||
|
||
if (x >= OLED_WIDTH || y >= OLED_HEIGHT)
|
||
{
|
||
x = OLED_WIDTH;
|
||
y = OLED_HEIGHT;
|
||
}
|
||
else
|
||
{
|
||
if (x < OLED_WIDTH)
|
||
{
|
||
if (Color)
|
||
{
|
||
OledOperValue.uiBuff[x][uiPage] |= (0x01U << uiOffset);
|
||
}
|
||
else
|
||
{
|
||
OledOperValue.uiBuff[x][uiPage] &= (Uint16) ~(0x01U << uiOffset);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
void CSetPageAddress(Uint16 Address)
|
||
{
|
||
COledWrite((Uint16)(Address | 0xB0), MODE_COMMAND);
|
||
}
|
||
|
||
void CSetColumnAddress(Uint16 x)
|
||
{
|
||
Uint16 HighAddress;
|
||
Uint16 LowAddress;
|
||
|
||
x += 0; // ER_OLEDM024-1G is +2, ER_OLEDM024-2G is +0
|
||
HighAddress = ((x >> 4) & 0x0F) | 0x10;
|
||
LowAddress = x & 0x0F;
|
||
|
||
COledWrite(LowAddress, MODE_COMMAND);
|
||
COledWrite(HighAddress, MODE_COMMAND);
|
||
}
|
||
|
||
void CInitXintf(void)
|
||
{
|
||
/* for All Zones Timing for all zones based on XTIMCLK = SYSCLKOUT (150MHz) */
|
||
EALLOW;
|
||
XintfRegs.XINTCNF2.bit.XTIMCLK = 1;
|
||
XintfRegs.XINTCNF2.bit.WRBUFF = 0; /* No write buffering */
|
||
XintfRegs.XINTCNF2.bit.CLKOFF = 0; /* XCLKOUT is enabled */
|
||
XintfRegs.XINTCNF2.bit.CLKMODE = 1; /* XCLKOUT = XTIMCLK */
|
||
|
||
/* Zone write timing */
|
||
XintfRegs.XTIMING6.bit.XWRLEAD = 1;
|
||
XintfRegs.XTIMING6.bit.XWRACTIVE = 13;
|
||
XintfRegs.XTIMING6.bit.XWRTRAIL = 1;
|
||
|
||
/* Zone read timing */
|
||
XintfRegs.XTIMING6.bit.XRDLEAD = 1;
|
||
XintfRegs.XTIMING6.bit.XRDACTIVE = 13;
|
||
XintfRegs.XTIMING6.bit.XRDTRAIL = 1;
|
||
|
||
XintfRegs.XTIMING6.bit.X2TIMING = 1;
|
||
XintfRegs.XTIMING6.bit.USEREADY = 1;
|
||
XintfRegs.XTIMING6.bit.READYMODE = 1;
|
||
XintfRegs.XTIMING6.bit.XSIZE = 3;
|
||
|
||
GpioCtrlRegs.GPCMUX1.bit.GPIO79 = 3; // OLED_D0 XD0
|
||
GpioCtrlRegs.GPCMUX1.bit.GPIO78 = 3; // OLED_D1 XD1
|
||
GpioCtrlRegs.GPCMUX1.bit.GPIO77 = 3; // OLED_D2 XD2
|
||
GpioCtrlRegs.GPCMUX1.bit.GPIO76 = 3; // OLED_D3 XD3
|
||
GpioCtrlRegs.GPCMUX1.bit.GPIO75 = 3; // OLED_D4 XD4
|
||
GpioCtrlRegs.GPCMUX1.bit.GPIO74 = 3; // OLED_D5 XD5
|
||
GpioCtrlRegs.GPCMUX1.bit.GPIO73 = 3; // OLED_D6 XD6
|
||
GpioCtrlRegs.GPCMUX1.bit.GPIO72 = 3; // OLED_D7 XD7
|
||
|
||
GpioCtrlRegs.GPAMUX2.bit.GPIO28 = 3; // OLED_CS_C XZCS6
|
||
GpioCtrlRegs.GPBMUX1.bit.GPIO38 = 3; // OLED_WR_C XWE0
|
||
GpioCtrlRegs.GPBMUX1.bit.GPIO40 = 3; // OLED_A0_C XWE1
|
||
|
||
EDIS;
|
||
}
|
||
|
||
void CDrawStr(Uint16 x, Uint16 y, int8* str, Uint16 len)
|
||
{
|
||
Uint16 i;
|
||
|
||
if ((len > 0U) && (len < TXT_MAX_LEN)) // ¸®¼Ò½º °úµµ ¼Òºñ ¹æÁö
|
||
{
|
||
for(i = 0; i < len; i++)
|
||
{
|
||
if (str[i] & 0x80)
|
||
{
|
||
CDrawChar(x, y, (Uint16)((str[i] << 8) | str[i + 1]), TXT_TYPE_ETC);
|
||
i++;
|
||
x += TXT_ENG_WIDTH * 2U;
|
||
}
|
||
else
|
||
{
|
||
CDrawChar(x, y, (Uint16)str[i], TXT_TYPE_ENG);
|
||
x += TXT_ENG_WIDTH;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
void CDrawChar(Uint16 x, Uint16 y, Uint16 ch, Uint16 type)
|
||
{
|
||
const Uint16* pFontData;
|
||
Uint16 uiFontIndex = 0;
|
||
Uint16 i, j;
|
||
Uint16 uiCharWidth;
|
||
|
||
if (type == 0) // Eng Char
|
||
{
|
||
uiCharWidth = TXT_ENG_WIDTH;
|
||
ch -= 0x20U; // font offset
|
||
pFontData = EngFontTable[ch];
|
||
}
|
||
else
|
||
{
|
||
uiCharWidth = TXT_ENG_WIDTH * 2U;
|
||
ch = (ch == 0xA1C9U) ? 0x00U : ch;
|
||
pFontData = EtcFontTable[ch];
|
||
}
|
||
|
||
CSetDrawRegion(x, y, (x + TXT_ENG_WIDTH), (y + TXT_ENG_HEIGHT));
|
||
|
||
for(j = 0; j < TXT_ENG_HEIGHT; j++)
|
||
{
|
||
for(i = 0; i < uiCharWidth; i++)
|
||
{
|
||
if (pFontData[uiFontIndex / 8] & uiBitMask[uiFontIndex % 8])
|
||
{
|
||
CPutPixel((x + i), (y + j), OledOperValue.Color.TxtColor);
|
||
}
|
||
else
|
||
{
|
||
CPutPixel((x + i), (y + j), OledOperValue.Color.BgColor);
|
||
}
|
||
uiFontIndex++;
|
||
}
|
||
}
|
||
}
|
||
|
||
void CInitOledModule(void)
|
||
{
|
||
GPIO_OLED_RESET(1U);
|
||
DELAY_US(2000L);
|
||
GPIO_OLED_RESET(0U);
|
||
DELAY_US(2000L);
|
||
GPIO_OLED_RESET(1U);
|
||
DELAY_US(2000L);
|
||
|
||
COledWrite(0xFD, MODE_COMMAND); // Command Lock
|
||
COledWrite(0x12, MODE_COMMAND); //
|
||
COledWrite(0xAE, MODE_COMMAND); // oled off
|
||
COledWrite(0xA1, MODE_COMMAND); // 1U segment column address high to low
|
||
|
||
COledWrite(0xC8, MODE_COMMAND); // COM output scan from high to low
|
||
|
||
COledWrite(0x81, MODE_COMMAND); // 1U contrast
|
||
COledWrite(0xFF, MODE_COMMAND);
|
||
|
||
COledWrite(0xAF, MODE_COMMAND); // oled on
|
||
|
||
CInitOledStructure();
|
||
OledOperValue.uiProgressValue = OLED_LOAD_PROGRESS_X + 1;
|
||
}
|
||
|
||
void COledWrite(Uint16 Data, Uint16 Command)
|
||
{
|
||
if (Command == MODE_COMMAND)
|
||
{
|
||
CommandBus = Data;
|
||
}
|
||
else
|
||
{
|
||
DataBus = Data;
|
||
}
|
||
}
|
||
|
||
void CInitOledStructure(void)
|
||
{
|
||
(void) memset(&OledOperValue, 0, sizeof(COledOperValue));
|
||
|
||
OledOperValue.uiResetAnswer = 1U;
|
||
}
|
||
|
||
void CInitKeyOperValue(void)
|
||
{
|
||
(void) memset(&KeyOperValue, 0, sizeof(CKeyOperValue));
|
||
}
|
||
|
||
Uint16 CStrLen(const int8 *s)
|
||
{
|
||
// ¿øº» Æ÷ÀÎÅÍÀÇ ½ÃÀÛ ÁÖ¼Ò¸¦ ÀúÀåÇÕ´Ï´Ù.
|
||
const int8 *p = s;
|
||
|
||
// Æ÷ÀÎÅÍ°¡ ³Î Á¾·á ¹®ÀÚ('\0', Áï ASCII 0)¸¦ °¡¸®Å°Áö ¾ÊÀ» ¶§±îÁö Æ÷ÀÎÅ͸¦ Áõ°¡½Ãŵ´Ï´Ù.
|
||
// ¹®ÀÚ¿Àº ¿¬¼ÓµÈ ¸Þ¸ð¸® °ø°£¿¡ ÀúÀåµÇ¾î ÀÖ½À´Ï´Ù.
|
||
while (*p != '\0')
|
||
{
|
||
p++;
|
||
}
|
||
|
||
// ÃÖÁ¾ ÁÖ¼Ò(³Î ¹®ÀÚ ´ÙÀ½)¿Í ½ÃÀÛ ÁÖ¼ÒÀÇ Â÷ÀÌ°¡ ¹®ÀÚ¿ÀÇ ±æÀÌ°¡ µË´Ï´Ù.
|
||
return (Uint16)(p - s);
|
||
}
|
||
|
||
static void CStrncpy(int8 *pTarget, const int8 *pSource, Uint16 Size)
|
||
{
|
||
Uint16 i;
|
||
|
||
for (i = 0; i < Size; i++)
|
||
{
|
||
pTarget[i] = pSource[i];
|
||
}
|
||
pTarget[i] = '\0';
|
||
}
|
||
|
||
void CStrncat(int8 *pTarget, const int8 *pSource, Uint16 Size)
|
||
{
|
||
Uint16 i;
|
||
Uint16 uiTargetSize;
|
||
|
||
uiTargetSize = (Uint16)CStrLen(pTarget);
|
||
|
||
if ((uiTargetSize + Size) < TXT_MAX_LEN)
|
||
{
|
||
for (i = 0; i < Size; i++)
|
||
{
|
||
pTarget[uiTargetSize + i] = pSource[i];
|
||
}
|
||
|
||
pTarget[uiTargetSize + i] = '\0';
|
||
}
|
||
}
|
||
|
||
void CDecToString(int16 Data, int8 *Array, Uint16 ArrayLen)
|
||
{
|
||
Uint16 uiSign = 0U, uiSignLocate = 0U, i;
|
||
Uint16 x, y;
|
||
int32 lData = (int32) Data * 10;
|
||
int8 cTmp[5] = { 0x00, 0x00, 0x00, 0x00, 0x00 };
|
||
|
||
for (i = 0; i < ArrayLen; i++)
|
||
{
|
||
Array[i] = ' ';
|
||
}
|
||
|
||
if (lData < 0)
|
||
{
|
||
// Ç¥½ÃÇÒ ¼ýÀÚ°¡ À½¼öÀÎ °æ¿ì
|
||
uiSign = 1U;
|
||
lData = -lData;
|
||
}
|
||
|
||
while (lData > 0U)
|
||
{
|
||
cTmp[x++] = (lData % 10) + '0';
|
||
lData /= 10U;
|
||
}
|
||
|
||
if (x == 0) // ¼öÄ¡°¡ 0ÀÇ °æ¿ì.
|
||
{
|
||
y = 3U;
|
||
Array[y++] = '0';
|
||
}
|
||
else
|
||
{
|
||
y = 5 - x; // Ãâ·Â µÇ´Â ¹®ÀÚÀÇ Á¤·ÄÀ» À§ÇÔ.
|
||
x = x - 1; // ¸¶Áö¸·À¸·Î ÀúÀåµÈ ¹öÆÛ À妽ºÀÇ °ªÀº »©ÁÜ.
|
||
|
||
if (y < 1)
|
||
{
|
||
uiSignLocate = 0U;
|
||
}
|
||
else
|
||
{
|
||
if ((y >= 1) && (y <= 5))
|
||
{
|
||
uiSignLocate = (Uint16)(y - 1); // '-' ºÎÈ£¸¦ Ç¥½ÃÇÒ ÀÚ¸®
|
||
}
|
||
}
|
||
|
||
if (uiSign == 1U) // '-' ºÎÈ£ Ç¥½Ã À§Ä¡ ÁöÁ¤Çϱâ À§ÇÔ.
|
||
{
|
||
if ((uiSignLocate > 0U) && (uiSignLocate < 6U))
|
||
{
|
||
Array[uiSignLocate] = '-';
|
||
}
|
||
}
|
||
else
|
||
{
|
||
Array[uiSignLocate] = ' ';
|
||
}
|
||
|
||
while (x > 0)
|
||
{
|
||
Array[y++] = cTmp[x--];
|
||
}
|
||
}
|
||
Array[y] = '\0'; // End of string.
|
||
}
|
||
|
||
static void CFloatToString(float32 Data, int8 *Array, Uint16 ArrayLen)
|
||
{
|
||
Uint16 x = 0U, y = 0U, i;
|
||
int16 iTemp = (int16)(Data * 10);
|
||
int8 cTmp[4] = { 0x00, 0x00, 0x00, 0x00 };
|
||
|
||
for (i = 0; i < ArrayLen; i++)
|
||
{
|
||
Array[i] = ' ';
|
||
}
|
||
|
||
while (iTemp > 0U)
|
||
{
|
||
cTmp[x++] = (iTemp % 10) + '0';
|
||
iTemp /= 10U;
|
||
}
|
||
|
||
if (x == 0U) // ¼öÄ¡°¡ 0.0ÀÏ °æ¿ì.
|
||
{
|
||
y = 3U;
|
||
Array[y++] = '0';
|
||
Array[y++] = '.';
|
||
Array[y++] = '0';
|
||
}
|
||
else
|
||
{
|
||
if (x == 1U)
|
||
{
|
||
y = 3U;
|
||
Array[y++] = '0';
|
||
Array[y++] = '.';
|
||
Array[y++] = cTmp[0];
|
||
}
|
||
else
|
||
{
|
||
y = 5U - x; // Ãâ·Â µÇ´Â ¹®ÀÚÀÇ Á¤·ÄÀ» À§ÇÔ.
|
||
x = x - 1U; // ¸¶Áö¸·À¸·Î ÀúÀåµÈ ¹öÆÛ À妽ºÀÇ °ªÀº »©ÁÜ.
|
||
|
||
while (x > 0U)
|
||
{
|
||
Array[y++] = cTmp[x--];
|
||
if (x == 0U)
|
||
{
|
||
Array[y++] = '.';
|
||
Array[y++] = cTmp[0];
|
||
}
|
||
}
|
||
}
|
||
}
|
||
Array[y] = '\0'; // End of string.
|
||
}
|
||
|
||
void CInitializePage(void)
|
||
{
|
||
if (AdcOperValue.uiOffsetAdjustStart == 0U)
|
||
{
|
||
CDrawLine((Uint16)(OledOperValue.uiProgressValue + 1U), (Uint16)(OLED_LOAD_PROGRESS_Y + 2U), (Uint16)(OledOperValue.uiProgressValue + 1U), (Uint16)(OLED_LOAD_PROGRESS_Y + 8U));
|
||
if (OledOperValue.uiProgressValue < OLED_LOAD_PROGRESS_W - 3) // -3Àº ÇÁ·Î±×·¡½º ¹ÙÀÇ Á¿ìÃø 1Çȼ¿ °ø°£ ÁÜ.
|
||
{
|
||
OledOperValue.uiProgressValue++;
|
||
}
|
||
else
|
||
{
|
||
OledOperValue.uiProgressDone = 1U;
|
||
}
|
||
}
|
||
}
|
||
|
||
void CDisplayPostFail(void)
|
||
{
|
||
CDrawCenteredLine(OLED_LINE_TITLE, "Power On Self-Test");
|
||
CDrawCenteredLine(OLED_LINE_1, "(P:PASS F:FAIL)");
|
||
|
||
// LINE 2
|
||
CDrawPostStatusLine(OLED_ROW_2, "EHT:", PowerOnCheckValue.EngineHeaterSensor, "GPL:", PowerOnCheckValue.GlowPlugSensor, "SOL:", PowerOnCheckValue.SolenoidSensor);
|
||
|
||
// LINE 3
|
||
CDrawPostStatusLine(OLED_ROW_3, "FUP:", PowerOnCheckValue.FuelPumpSensor, "CLP:", PowerOnCheckValue.CoolantPumpSensor, "FN1:", PowerOnCheckValue.Fan1Sensor);
|
||
|
||
// LINE 4
|
||
// Only FN2
|
||
CDrawPostStatusLine(OLED_ROW_4, "FN2:", PowerOnCheckValue.Fan2Sensor, NULL, 0, NULL, 0);
|
||
}
|
||
static void CLineFocus(Uint16 isFocus)
|
||
{
|
||
if (isFocus == 1U)
|
||
{
|
||
OledOperValue.Color.TxtColor = 0U;
|
||
OledOperValue.Color.BgColor = 1U;
|
||
}
|
||
else
|
||
{
|
||
OledOperValue.Color.TxtColor = 1U;
|
||
OledOperValue.Color.BgColor = 0U;
|
||
}
|
||
}
|
||
|
||
void CReversString(int8 *str, int16 length)
|
||
{
|
||
Uint16 i = 0U;
|
||
Uint16 end = length - 1U;
|
||
int8 temp;
|
||
|
||
while (i < end)
|
||
{
|
||
temp = str[i];
|
||
str[i] = str[end];
|
||
str[end] = temp;
|
||
i++;
|
||
end--;
|
||
}
|
||
}
|
||
|
||
static void CHourToString(int32 num, int8 *str)
|
||
{
|
||
Uint16 i = 0U;
|
||
Uint16 end;
|
||
Uint32 temp = num; // ÀԷ¹ÞÀº °ª (¿¹: 1234567 -> "12345.67")
|
||
|
||
// 1. ¼Ò¼öÁ¡ µÑ° ÀÚ¸® (100ºÐÀÇ 1)
|
||
str[i++] = (temp % 10) + '0';
|
||
temp = temp / 10;
|
||
|
||
// 2. ¼Ò¼öÁ¡ ù° ÀÚ¸® (10ºÐÀÇ 1)
|
||
str[i++] = (temp % 10) + '0';
|
||
temp = temp / 10;
|
||
|
||
// 3. ¼Ò¼öÁ¡ »ðÀÔ
|
||
str[i++] = '.';
|
||
|
||
// 4. Á¤¼öºÎ º¯È¯
|
||
// ÀÔ·ÂÀÌ 0À̾ ÃÖ¼Ò "0"Àº ÂïÈ÷µµ·Ï do-while »ç¿ë
|
||
do
|
||
{
|
||
str[i++] = (temp % 10) + '0';
|
||
temp = temp / 10;
|
||
}
|
||
while (temp != 0);
|
||
|
||
// 5. °ø¹é ä¿ì±â (ÀÚ¸®¼ö ¸ÂÃã)
|
||
// Á¤¼ö5ÀÚ¸® + Á¡1ÀÚ¸® + ¼Ò¼ö2ÀÚ¸® = ÃÑ 8ÀÚ¸®
|
||
while (i < 8U)
|
||
{
|
||
str[i++] = ' ';
|
||
}
|
||
|
||
str[i] = '\0'; // ¹®ÀÚ¿ ³¡ ¾Ë¸²
|
||
|
||
end = i - 1U;
|
||
i = 0U;
|
||
|
||
while (i < end)
|
||
{
|
||
int8 swapTemp = str[i];
|
||
str[i] = str[end];
|
||
str[end] = swapTemp;
|
||
i++;
|
||
end--;
|
||
}
|
||
}
|
||
|
||
static const int8* CGetApuStateString(eApuOperIdx idx)
|
||
{
|
||
// À妽º¿Í 1:1 ¸ÅĪµÇ´Â ¹®ÀÚ¿ ¹è¿ Á¤ÀÇ staticÀ» »ç¿ëÇÏ¿© ÇÔ¼ö È£Ãâ ¶§¸¶´Ù ¹è¿À» ´Ù½Ã »ý¼ºÇÏÁö ¾Êµµ·Ï ÇÔ
|
||
static const int8* strTable[] =
|
||
{
|
||
"BOOT", // 0: APU_OPER_IDX_BOOT
|
||
"INIT", // 1: APU_OPER_IDX_INITIAL
|
||
"POST", // 2: APU_OPER_IDX_POST
|
||
"EMERGENCY", // 3: APU_OPER_IDX_EMERGENCY
|
||
"STANDBY", // 4: APU_OPER_IDX_STANDBY
|
||
"START_CHECK", // 5: APU_OPER_IDX_START_CHECK
|
||
"PREHEAT", // 6: APU_OPER_IDX_ACTIVE_ENG_HEAT
|
||
"CRANKING", // 7: APU_OPER_IDX_CRANKING
|
||
"WARM_UP", // 8: APU_OPER_IDX_ENG_WARMING_UP
|
||
"CHECK_OPER", // 9: APU_OPER_IDX_CHECK_OPERATION
|
||
"GENERATING", // 10: APU_OPER_IDX_SET_GCU_GEN_START
|
||
"STABLED", // 11: APU_OPER_IDX_ENG_START_DONE
|
||
"STOP", // 12: APU_OPER_IDX_ENG_STOP_NORMAL
|
||
"COOLDOWN" // 13: APU_OPER_IDX_ENG_STOP_COOLDOWN
|
||
};
|
||
|
||
return strTable[idx];
|
||
}
|