private/hsb
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Fixed language problems. Menu is totally independent from constant strings now, all messages are taken from dedicated include file "MenuText.h"

Browse Source 
Makefile is adapted

Added "Dispay_writeCentered" function, which safes a lot of code

git-svn-id: https://svn.vbchaos.nl/svn/hsb/trunk@281 05563f52-14a8-4384-a975-3d1654cca0fa
This commit is contained in:
mmi
2017-11-17 13:51:41 +00:00
parent 462f98b302
commit 5e29b31c8c
9 changed files with 603 additions and 211 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/Makefile
View File

@@ -76,7 +76,7 @@ OLI_STM32_H107: export OBJ_DIR := obj_release/
OLI_STM32_H107: export OBJECTS := $(OBJECTS_GEN)
OLI_STM32_H107: export OBJECTS_MAIN := $(OBJECTS_MAIN)
OLI_STM32_H107: export CROSS_COMPILE := arm-none-eabi-
OLI_STM32_H107: export CCFLAGS := -c -O2 -Wall -Werror -g -lc -lm -fno-common -mcpu=cortex-m3 -mthumb $(PLATFORM) $(RELEASE_DEFINES) $(INCLUDES)
OLI_STM32_H107: export CCFLAGS := -c -O2 -Wall -Werror -g -lc -lm -fno-common -mcpu=cortex-m3 -mthumb $(PLATFORM) $(RELEASE_DEFINES) $(LANGUAGE) $(INCLUDES)
OLI_STM32_H107: export ASFLAGS := -g -mapcs-32
OLI_STM32_H107: export LDFLAGS := -g -nostartfiles -mcpu=cortex-m3 -mthumb -T$(LINKER_SCRIPTS_DIR)/$(LINKER_SCRIPT) -Wl,-Map=hsb_mrts_OLI_STM32_H107.map
OLI_STM32_H107: export LDARCHIVES := -L. -L$(STM32_STDPERIPH_ROOT) -L$(PLATFORM_DIR) -L$(HAL_DIR) -lhsb_mrts_OLI_STM32_H107 -lPlatform -lHAL -lSTM_StdPeriph

20
S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/Display.h
View File

@@ -261,6 +261,26 @@ extern ErrorStatus Display_backspace(struct Display* self);
extern ErrorStatus Display_write(struct Display* self, const char* buffer, size_t row, size_t column);
/** ----------------------------------------------------------------------------
* Display_writeCentered
* Puts a string on the specified row of the display in centered mode
*
* @param self The display object
* @param buffer String/message to write
* @param row The row to put the message to
*
* @return ErrorStatus SUCCESS if putting message to display was
* successful
* ERROR otherwise, especially
* - Message too long
* - Row outside display boundaries
*
* @todo
* -----------------------------------------------------------------------------
*/
extern ErrorStatus Display_writeCentered(struct Display* self, const char* buffer, unsigned int row);
/** ----------------------------------------------------------------------------
* Display_feedRefreshCounter
* Feeds the refresh counter for display content

314
S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/MenuText.h
View File

@@ -38,7 +38,319 @@
// -----------------------------------------------------------------------------
#define MENUTEXT_NUMBER_OF_LANGUAGES (2)
#define MENUTEXT_ENGLISH (0)
// DEFINE STRING LENGTH FOR DIFFERENT ENTRIES
#define MENUTEXT_ROW1_POPUP_MAX_LENGTH (17)
#define MENUTEXT_POPUP_MESSAGE_LENGTH (21)
// Repairscreen string length
#define MENUTEXT_REPAIRSCREEN_LENGTH (7)
#define MENUTEXT_PRESET_MAX_LENGTH (7)
#define MENUTEXT_CHANGEPIN_MAX_LENGTH (15)
// -----------------------
// WARNINGS
// -----------------------
static const char MenuText_WARNING[MENUTEXT_NUMBER_OF_LANGUAGES][MENUTEXT_ROW1_POPUP_MAX_LENGTH] =
{
{
"!!WARNING!!"
},
{
//FRENCH TBW
}
};
static const char MenuText_WARNING_COVER_OPEN[MENUTEXT_NUMBER_OF_LANGUAGES][MENUTEXT_POPUP_MESSAGE_LENGTH] =
{
{
"COVER OPEN"
},
{
//FRENCH TBW
}
};
// -----------------------
// ERRORS
// -----------------------
static const char MenuText_ERROR[MENUTEXT_NUMBER_OF_LANGUAGES][MENUTEXT_ROW1_POPUP_MAX_LENGTH] =
{
{
"!!ERROR!!"
},
{
//FRENCH TBW
}
};
static const char MenuText_ERROR_COVER_OPEN[MENUTEXT_NUMBER_OF_LANGUAGES][MENUTEXT_POPUP_MESSAGE_LENGTH] =
{
{
"COVER OPEN"
},
{
//FRENCH TBW
}
};
static const char MenuText_ERROR_PROCESS_FAILED[MENUTEXT_NUMBER_OF_LANGUAGES][MENUTEXT_POPUP_MESSAGE_LENGTH] =
{
{
"PROCESS FAILED"
},
{
//FRENCH TBW
}
};
static const char MenuText_ERROR_CRC_PIN[MENUTEXT_NUMBER_OF_LANGUAGES][MENUTEXT_POPUP_MESSAGE_LENGTH] =
{
{
"PIN CRC ERROR"
},
{
//FRENCH TBW
}
};
static const char MenuText_ERROR_CRC_PARAMETERS[MENUTEXT_NUMBER_OF_LANGUAGES][MENUTEXT_POPUP_MESSAGE_LENGTH] =
{
{
"PARAMETERS CRC ERROR"
},
{
//FRENCH TBW
}
};
static const char MenuText_ERROR_CRC_PRESETS[MENUTEXT_NUMBER_OF_LANGUAGES][MENUTEXT_POPUP_MESSAGE_LENGTH] =
{
{
"PRESETS CRC ERROR"
},
{
//FRENCH TBW
}
};
// -----------------------
// Common screen messages
// -----------------------
static const char MenuText_X_CONTINUE[MENUTEXT_NUMBER_OF_LANGUAGES][MENUTEXT_POPUP_MESSAGE_LENGTH] =
{
{
"Hit X to continue"
},
{
//FRENCH TBW
}
};
static const char MenuText_REPAIR_SCREEN[MENUTEXT_NUMBER_OF_LANGUAGES][4][MENUTEXT_REPAIRSCREEN_LENGTH] =
{
{
"total", // Indicates the total repair time
"remain", // Indicates the remaining repair time
"R", // Row identifier. DO NOT USE MORE THAN ONE LETTER! The number of the row (1,2,3) is attached dynamically
"ERROR" // Error identifier in case a ROW is in error-state. Will be written instead of the current voltage
},
{
//FRENCH TBW
}
};
static const char MenuText_REPAIR_SCREEN_INIT[MENUTEXT_NUMBER_OF_LANGUAGES][MENUTEXT_ROW1_POPUP_MAX_LENGTH] =
{
{
"Initialising" // Indicates start of a repair
},
{
//FRENCH TBW
}
};
static const char MenuText_PAUSE[MENUTEXT_NUMBER_OF_LANGUAGES][5][MENUTEXT_POPUP_MESSAGE_LENGTH] =
{
{
"REPAIR BUSY",
"Hit X to PAUSE",
"!!PAUSE!!",
"Hit ENT to continue",
"Hit X to RESET"
},
{
//FRENCH TBW
}
};
static const char MenuText_FINISH[MENUTEXT_NUMBER_OF_LANGUAGES][2][MENUTEXT_POPUP_MESSAGE_LENGTH] =
{
{
"REPAIR FINISHED",
"Hit ENT to continue",
},
{
//FRENCH TBW
}
};
static const char MenuText_PRINT_PRESET[MENUTEXT_NUMBER_OF_LANGUAGES][5][MENUTEXT_PRESET_MAX_LENGTH] =
{
{
"Preset",
"info",
"Start:",
"Time:",
"Volt:"
},
{
//FRENCH TBW
}
};
static const char MenuText_CHANGE_PIN[MENUTEXT_NUMBER_OF_LANGUAGES][2][MENUTEXT_CHANGEPIN_MAX_LENGTH] =
{
{
" New PIN:",
" Repeat PIN:"
},
{
//FRENCH TBW
}
};
static const char MenuText_INTERLOCK_STATUS[MENUTEXT_NUMBER_OF_LANGUAGES][3][MENUTEXT_POPUP_MESSAGE_LENGTH] =
{
{
"Cover Interlock is",
"closed",
"open"
},
{
//FRENCH TBW
}
};
static const char MenuText_CONFIRM_PIN[MENUTEXT_NUMBER_OF_LANGUAGES][2][MENUTEXT_POPUP_MESSAGE_LENGTH] =
{
{
"PIN OK",
"PIN DENIED"
},
{
//FRENCH TBW
}
};
static const char MenuText_CONFIRM_NEW_PIN[MENUTEXT_NUMBER_OF_LANGUAGES][2][MENUTEXT_POPUP_MESSAGE_LENGTH] =
{
{
"New PIN accepted",
"New PIN denied"
},
{
//FRENCH TBW
}
};
static const char MenuText_SAFE_PRESET[MENUTEXT_NUMBER_OF_LANGUAGES][MENUTEXT_POPUP_MESSAGE_LENGTH] =
{
{
"Preset saved"
},
{
//FRENCH TBW
}
};
static const char MenuText_SELECT_PRESET[MENUTEXT_NUMBER_OF_LANGUAGES][MENUTEXT_POPUP_MESSAGE_LENGTH - 3] =
{
{
"Selected preset:"
},
{
//FRENCH TBW
}
};
static const char MenuText_SAFE_CONSTANTS[MENUTEXT_NUMBER_OF_LANGUAGES][MENUTEXT_POPUP_MESSAGE_LENGTH] =
{
{
"Constants saved"
},
{
//FRENCH TBW
}
};
static const char MenuText_INSERT_PIN[MENUTEXT_NUMBER_OF_LANGUAGES][MENUTEXT_POPUP_MESSAGE_LENGTH] =
{
{
"Insert PIN"
},
{
//FRENCH TBW
}
};
static const char MenuText_VOLTAGE_IN_HEADER[MENUTEXT_NUMBER_OF_LANGUAGES][MENUTEXT_ROW1_POPUP_MAX_LENGTH] =
{
{
"Voltage input"
},
{
//FRENCH TBW
}
};
static const char MenuText_VOLTAGE_OUT_HEADER[MENUTEXT_NUMBER_OF_LANGUAGES][MENUTEXT_ROW1_POPUP_MAX_LENGTH] =
{
{
"Voltage output"
},
{
//FRENCH TBW
}
};
static const char MenuText_VOLTAGE_ROW[MENUTEXT_NUMBER_OF_LANGUAGES][5] =
{
{
"Row"
},
{
//FRENCH TBW
}
};
static const char MenuText_CONSTANTS_HEADER[MENUTEXT_NUMBER_OF_LANGUAGES][MENUTEXT_ROW1_POPUP_MAX_LENGTH] =
{
{
"PID constants"
},
{
//FRENCH TBW
}
};
static const char MenuText_VOLTAGE_OUT_CLEANUP[MENUTEXT_NUMBER_OF_LANGUAGES][2][MENUTEXT_POPUP_MESSAGE_LENGTH] =
{
{
"All rows reset to 0V",
"Press X to continue"
},
{
//FRENCH TBW
}
};
// -----------------------
// OPERATOR MENU

63
S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/Display.c
View File

@@ -232,6 +232,69 @@ ErrorStatus Display_write(struct Display* self, const char* buffer, size_t row,
}
ErrorStatus Display_writeCentered(struct Display* self, const char* buffer, unsigned int row)
{
ErrorStatus returnValue = SUCCESS;
if (self->initialized)
{
int length = 0;
int column;
// Prior to any action on the display memory, perform necessary checkings
if (returnValue == SUCCESS)
{
// Check that the row coordinate does not exceed the display boundary
if (row - 1 >= self->displayDevice->parameters.numberOfRows)
{
returnValue = ERROR;
}
}
if (returnValue == SUCCESS)
{
length = strlen(buffer);
// Check that the length request does not exceed the display boundary
// This is checked in combination with the column coordinate
// numberOfColumns - column >= length
// must be valid in order to put the requested message on display
if (length > self->displayDevice->parameters.numberOfColumns )
{
returnValue = ERROR;
}
}
if (returnValue == SUCCESS)
{
// Calculate the column to start writing for a centered string
// simply put, the length of the row minus the length of the string divided by two
column = (self->displayDevice->parameters.numberOfColumns - length) / 2;
// In case of an uneven string length, add one column
column += ((self->displayDevice->parameters.numberOfColumns - length) % 2);
// Add one column because the driver should start at column 1 (human readable)
column += 1;
}
if (returnValue == SUCCESS)
{
int loopCounter;
for (loopCounter = 0; loopCounter < length; loopCounter++)
{
DisplayContent_updateCharacter(&self->displayContent, (row - 1), (column - 1) + loopCounter, buffer[loopCounter]);
}
xSemaphoreGive(self->displayWriteRequest);
}
}
else
{
returnValue = ERROR;
}
return returnValue;
}
void Display_feedRefreshCounter(struct Display* self)
{
if (self->initialized)

2
S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/hsb-mrts.c
View File

@@ -96,7 +96,7 @@ ErrorStatus hsb_generateStartScreen(struct Display* Display)
Version_getInstance()->minor,
Version_getInstance()->branch,
Version_getInstance()->patch);
Display_write(mainDisplay, buffer, 3, 4);
Display_writeCentered(mainDisplay, buffer, 3);
}
else
{

396
S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/repairMenu.c
View File

@@ -70,6 +70,13 @@
#define REPAIRMENU_POPUPSCREEN_TIME_MS (1000)
#ifdef LANGUAGE
#if ((LANGUAGE >= MENUTEXT_NUMBER_OF_LANGUAGES) || (LANGUAGE < 0))
#error "LANGUAGE INDEX OUT OF BOUNDS";
#endif
#endif
// -----------------------------------------------------------------------------
// Type definitions
// -----------------------------------------------------------------------------
@@ -80,7 +87,7 @@
// File-scope variables
// -----------------------------------------------------------------------------
static int languageIndex = LANGUAGE;
// -----------------------------------------------------------------------------
// Function declarations
@@ -125,7 +132,6 @@ static void repairMenu_configPID(struct MenuCore* self);
static void repairMenu_configConfirmPIDKp(struct MenuCore* self);
static void repairMenu_configConfirmPIDKi(struct MenuCore* self);
static void repairMenu_configConfirmPIDKd(struct MenuCore* self);
static void repairMenu_printConfigPreset(struct MenuCore* self);
static void repairMenu_printPINVerification(struct MenuCore* self);
static void repairMenu_printVoltageOutput(struct MenuCore* self);
static void repairMenu_printPIDConstants(struct MenuCore* self);
@@ -231,7 +237,7 @@ void repairMenu_interlockWarning(struct RepairMenu* self, T_INTERLOCK_ID interlo
if (interlockID == COMMON_INTERLOCK)
{
snprintf(self->menuCore->warningMessage, sizeof(self->menuCore->warningMessage) / sizeof(self->menuCore->warningMessage[0]), "COVER OPEN");
snprintf(self->menuCore->warningMessage, sizeof(self->menuCore->warningMessage) / sizeof(self->menuCore->warningMessage[0]), MenuText_WARNING_COVER_OPEN[languageIndex]);
}
}
@@ -242,7 +248,7 @@ void repairMenu_interlockFailed(struct RepairMenu* self, T_INTERLOCK_ID interloc
if (interlockID == COMMON_INTERLOCK)
{
snprintf(self->menuCore->errorMessage, sizeof(self->menuCore->errorMessage) / sizeof(self->menuCore->errorMessage[0]), "COVER OPEN");
snprintf(self->menuCore->errorMessage, sizeof(self->menuCore->errorMessage) / sizeof(self->menuCore->errorMessage[0]), MenuText_ERROR_COVER_OPEN[languageIndex]);
}
}
@@ -250,7 +256,7 @@ void repairMenu_interlockFailed(struct RepairMenu* self, T_INTERLOCK_ID interloc
void repairMenu_processFailed(struct RepairMenu* self)
{
MenuCore_changeState(self->menuCore, RM_ERROR_STATE);
snprintf(self->menuCore->errorMessage, sizeof(self->menuCore->errorMessage) / sizeof(self->menuCore->errorMessage[0]), "PROCESS FAILED");
snprintf(self->menuCore->errorMessage, sizeof(self->menuCore->errorMessage) / sizeof(self->menuCore->errorMessage[0]), MenuText_ERROR_PROCESS_FAILED[languageIndex]);
}
@@ -264,15 +270,15 @@ void repairMenu_printCRCFailure(struct RepairMenu* self, T_ErrorCode errorCode)
MenuCore_changeState(self->menuCore, RM_ERROR_STATE);
if (errorCode == ERROR_CRC_PIN)
{
snprintf(self->menuCore->errorMessage, sizeof(self->menuCore->errorMessage) / sizeof(self->menuCore->errorMessage[0]), "PIN CRC ERROR");
snprintf(self->menuCore->errorMessage, sizeof(self->menuCore->errorMessage) / sizeof(self->menuCore->errorMessage[0]), MenuText_ERROR_CRC_PIN[languageIndex]);
}
else if (errorCode == ERROR_CRC_PARAMETERS)
{
snprintf(self->menuCore->errorMessage, sizeof(self->menuCore->errorMessage) / sizeof(self->menuCore->errorMessage[0]), "PARAMETERS CRC ERROR");
snprintf(self->menuCore->errorMessage, sizeof(self->menuCore->errorMessage) / sizeof(self->menuCore->errorMessage[0]), MenuText_ERROR_CRC_PARAMETERS[languageIndex]);
}
else if (errorCode == ERROR_CRC_PRESETS)
{
snprintf(self->menuCore->errorMessage, sizeof(self->menuCore->errorMessage) / sizeof(self->menuCore->errorMessage[0]), "PRESETS CRC ERROR");
snprintf(self->menuCore->errorMessage, sizeof(self->menuCore->errorMessage) / sizeof(self->menuCore->errorMessage[0]), MenuText_ERROR_CRC_PRESETS[languageIndex]);
}
}
@@ -296,17 +302,17 @@ static int repairMenu_getValueFromInsertString(struct MenuCore* self)
static void repairMenu_printError(struct MenuCore* self)
{
Display_write(self->display, "!!ERROR!!", 1, 6);
Display_write(self->display, self->errorMessage, 2, 1 + ((self->display->displayDevice->parameters.numberOfColumns - strlen(self->errorMessage)) / 2));
Display_write(self->display, "Hit X to continue", 4, 2);
Display_writeCentered(self->display, MenuText_ERROR[languageIndex], 1);
Display_writeCentered(self->display, self->errorMessage, 2);
Display_writeCentered(self->display, MenuText_X_CONTINUE[languageIndex], 4);
}
static void repairMenu_printWarning(struct MenuCore* self)
{
Display_write(self->display, "!!WARNING!!", 1, 5);
Display_write(self->display, self->warningMessage, 2, 1 + ((self->display->displayDevice->parameters.numberOfColumns - strlen(self->warningMessage)) / 2));
Display_write(self->display, "Hit X to continue", 4, 2);
Display_writeCentered(self->display, MenuText_WARNING[languageIndex], 1);
Display_writeCentered(self->display, self->warningMessage, 2);
Display_writeCentered(self->display, MenuText_X_CONTINUE[languageIndex], 4);
}
@@ -330,12 +336,12 @@ static void repairMenu_printRepair(struct MenuCore* self)
struct Time totalTime;
RTC_calculateTimeFromSeconds(repairProcess_getTotalRepairtime(repairProcess), &totalTime);
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%02d:%02d:%02d total", totalTime.hours, totalTime.minutes, totalTime.seconds);
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%02d:%02d:%02d %s", totalTime.hours, totalTime.minutes, totalTime.seconds, MenuText_REPAIR_SCREEN[languageIndex][0]);
Display_write(self->display, buffer, 1, 4);
struct Time remainingTime;
RTC_calculateTimeFromSeconds(repairProcess_getRemainingRepairTime(repairProcess), &remainingTime);
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%02d:%02d:%02d remain", remainingTime.hours, remainingTime.minutes, remainingTime.seconds);
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%02d:%02d:%02d %s", remainingTime.hours, remainingTime.minutes, remainingTime.seconds, MenuText_REPAIR_SCREEN[languageIndex][1]);
Display_write(self->display, buffer, 2, 4);
// Regulation is unique for each row
@@ -346,7 +352,7 @@ static void repairMenu_printRepair(struct MenuCore* self)
const struct RepairProcessRow* row;
row = repairProcess_getRowInformation(repairProcess, loopCounter);
snprintf (buffer, sizeof(buffer) / sizeof(buffer[0]), "R%d", loopCounter + 1);
snprintf (buffer, sizeof(buffer) / sizeof(buffer[0]), "%1s%d", MenuText_REPAIR_SCREEN[languageIndex][2], loopCounter + 1);
Display_write(self->display, buffer, 3, ((loopCounter * (self->display->displayDevice->parameters.numberOfColumns / REPAIRPROCESS_NUMBER_OF_ROWS) + loopCounter) + (self->display->displayDevice->parameters.numberOfColumns / REPAIRPROCESS_NUMBER_OF_ROWS) / strlen(buffer)));
if (!row->errorData.rowHasError)
@@ -357,7 +363,7 @@ static void repairMenu_printRepair(struct MenuCore* self)
}
else
{
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "ERROR ");
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%s ", MenuText_REPAIR_SCREEN[languageIndex][3]);
Display_write(self->display, buffer, 4, (loopCounter + (loopCounter * (self->display->displayDevice->parameters.numberOfColumns / REPAIRPROCESS_NUMBER_OF_ROWS)) + (self->display->displayDevice->parameters.numberOfColumns / REPAIRPROCESS_NUMBER_OF_ROWS) / strlen(buffer)));
}
}
@@ -365,31 +371,30 @@ static void repairMenu_printRepair(struct MenuCore* self)
}
else
{
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "Initialising");
Display_write(self->display, buffer, 1, 6);
Display_writeCentered(self->display, MenuText_REPAIR_SCREEN_INIT[languageIndex], 1);
}
}
static void repairMenu_printAskPause(struct MenuCore* self)
{
Display_write(self->display, "REPAIR BUSY", 2, 6);
Display_write(self->display, "Hit X to PAUSE", 3, 2);
Display_writeCentered(self->display, MenuText_PAUSE[languageIndex][0], 2);
Display_writeCentered(self->display, MenuText_PAUSE[languageIndex][1], 3);
}
static void repairMenu_printPause(struct MenuCore* self)
{
Display_write(self->display, "!!PAUSE!!", 2, 6);
Display_write(self->display, "Hit ENT to continue", 3, 2);
Display_write(self->display, "Hit X to RESET", 4, 2);
Display_writeCentered(self->display, MenuText_PAUSE[languageIndex][2], 2);
Display_writeCentered(self->display, MenuText_PAUSE[languageIndex][3], 3);
Display_writeCentered(self->display, MenuText_PAUSE[languageIndex][4], 4);
}
static void repairMenu_printFinish(struct MenuCore* self)
{
Display_write(self->display, "REPAIR FINISHED", 2, 3);
Display_write(self->display, "Hit ENT to continue", 4, 2);
Display_writeCentered(self->display, MenuText_FINISH[languageIndex][0], 2);
Display_writeCentered(self->display, MenuText_FINISH[languageIndex][1], 4);
}
@@ -399,27 +404,27 @@ static void repairMenu_printPreset(struct MenuCore* self)
int loopCounter;
char buffer[self->display->displayDevice->parameters.numberOfColumns];
// Print the preset information of the current preset under the cursor, NOT the preset that is currently selected
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "Preset %d info", self->selectionIndex);
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%s %d %s", MenuText_PRINT_PRESET[languageIndex][0], self->selectionIndex, MenuText_PRINT_PRESET[languageIndex][1]);
// Always print Row1 (index0), ignoring the scrolling index
Display_write(self->display, buffer, 1, 1);
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "Start:");
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%s", MenuText_PRINT_PRESET[languageIndex][2]);
Display_write(self->display, buffer, 2, 1);
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "Time:");
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%s", MenuText_PRINT_PRESET[languageIndex][3]);
Display_write(self->display, buffer, 3, 1);
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "Volt:");
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%s", MenuText_PRINT_PRESET[languageIndex][4]);
Display_write(self->display, buffer, 4, 1);
for (loopCounter = 0; loopCounter < RepairPresets_getPreset(self->selectionIndex)->numberOfStages; loopCounter++)
{
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5dm", (RepairPresets_getPreset(self->selectionIndex)->preset[loopCounter].softstartDuration / 60));
Display_write(self->display, buffer, 2, 8 + loopCounter * 7);
Display_write(self->display, buffer, 2, MENUTEXT_PRESET_MAX_LENGTH + 1 + loopCounter * 7);
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5dm", (RepairPresets_getPreset(self->selectionIndex)->preset[loopCounter].duration / 60));
Display_write(self->display, buffer, 3, 8 + loopCounter * 7);
Display_write(self->display, buffer, 3, MENUTEXT_PRESET_MAX_LENGTH + 1 + loopCounter * 7);
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5dV", RepairPresets_getPreset(self->selectionIndex)->preset[loopCounter].voltage);
Display_write(self->display, buffer, 4, 8 + loopCounter * 7);
Display_write(self->display, buffer, 4, MENUTEXT_PRESET_MAX_LENGTH + 1 + loopCounter * 7);
}
}
@@ -435,10 +440,8 @@ static void repairMenu_prepareAdminPinVerification(struct MenuCore* self)
static void repairMenu_printChangePinScreen(struct MenuCore* self)
{
char buffer[self->display->displayDevice->parameters.numberOfColumns];
char pin[PIN_NUMBER_OF_DIGITS + 1];
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), " New PIN:");
Display_write(self->display, buffer, 3, 1);
Display_write(self->display, MenuText_CHANGE_PIN[languageIndex][0], 3, 1);
int numberOfDigits = strlen(self->insertString);
@@ -459,14 +462,13 @@ static void repairMenu_printChangePinScreen(struct MenuCore* self)
if (self->menuState == RM_ADMIN_CHANGEPIN_FIRST_INSERT)
{
Display_write(self->display, pin, 3, 14);
Display_write(self->display, pin, 3, MENUTEXT_CHANGEPIN_MAX_LENGTH);
}
else if (self->menuState == RM_ADMIN_CHANGEPIN_SECOND_INSERT)
{
Display_write(self->display, "****", 3, 14);
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), " Repeat PIN:");
Display_write(self->display, buffer, 4, 1);
Display_write(self->display, pin, 4, 14);
Display_write(self->display, "****", 3, MENUTEXT_CHANGEPIN_MAX_LENGTH);
Display_write(self->display, MenuText_CHANGE_PIN[languageIndex][1], 4, 1);
Display_write(self->display, pin, 4, MENUTEXT_CHANGEPIN_MAX_LENGTH);
}
}
@@ -474,27 +476,22 @@ static void repairMenu_printChangePinScreen(struct MenuCore* self)
static void repairMenu_printIOInterlockStatus(struct MenuCore* self)
{
char buffer[self->display->displayDevice->parameters.numberOfColumns];
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "Cover Interlock is");
Display_write(self->display, buffer, 2, 2);
Display_writeCentered(self->display, MenuText_INTERLOCK_STATUS[languageIndex][0], 2);
if (Interlock_isClosed(interlock))
{
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "closed");
Display_write(self->display, buffer, 3, 8);
Display_writeCentered(self->display, MenuText_INTERLOCK_STATUS[languageIndex][1], 3);
}
else
{
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), " open ");
Display_write(self->display, buffer, 3, 8);
Display_writeCentered(self->display, MenuText_INTERLOCK_STATUS[languageIndex][2], 3);
}
}
static void repairMenu_confirmAdminPin(struct MenuCore* self)
{
char buffer[20];
char pin[PIN_NUMBER_OF_DIGITS];
int loopcounter;
@@ -505,17 +502,15 @@ static void repairMenu_confirmAdminPin(struct MenuCore* self)
if (PIN_isOK(DeviceParameters_getPIN(), pin))
{
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "PIN OK");
Display_clearScreen(self->display);
Display_write(self->display, buffer, 3, 8);
Display_writeCentered(self->display, MenuText_CONFIRM_PIN[languageIndex][0], 3);
vTaskDelay(REPAIRMENU_POPUPSCREEN_TIME_MS);
MenuCore_changeState(self, RM_ADMINMENU);
}
else
{
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "PIN DENIED");
Display_clearScreen(self->display);
Display_write(self->display, buffer, 3, 6);
Display_writeCentered(self->display, MenuText_CONFIRM_PIN[languageIndex][1], 3);
vTaskDelay(REPAIRMENU_POPUPSCREEN_TIME_MS);
MenuCore_changeState(self, RM_MAINMENU);
}
@@ -551,21 +546,19 @@ static void repairMenu_configConfirmSecondPin(struct MenuCore* self)
{
pin[loopcounter] = self->insertString[loopcounter] - 48;
}
char buffer[20];
if (PIN_changePinSecondInsert(DeviceParameters_getPIN(), pin) == SUCCESS)
{
DeviceParameters_writePIN(DeviceParameters_getPIN());
DeviceParameters_saveParameters();
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "New PIN accepted");
Display_clearScreen(self->display);
Display_write(self->display, buffer, 3, 3);
Display_writeCentered(self->display, MenuText_CONFIRM_NEW_PIN[languageIndex][0], 3);
}
else
{
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "New PIN denied");
Display_clearScreen(self->display);
Display_write(self->display, buffer, 3, 4);
Display_writeCentered(self->display, MenuText_CONFIRM_NEW_PIN[languageIndex][1], 3);
}
vTaskDelay(REPAIRMENU_POPUPSCREEN_TIME_MS);
MenuCore_changeState(self, RM_ADMINMENU);
@@ -754,9 +747,7 @@ static void repairMenu_configConfirmPreset(struct MenuCore* self)
MenuCore_changeState(self, RM_ADMIN_PRESET_CONFIG_SELECT);
Display_clearScreen(self->display);
char buffer[20];
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "Preset %d saved", self->selectionIndex);
Display_write(self->display, buffer, 3, 4);
Display_writeCentered(self->display, MenuText_SAFE_PRESET[languageIndex], 3);
vTaskDelay(REPAIRMENU_POPUPSCREEN_TIME_MS);
}
@@ -801,9 +792,7 @@ static void repairMenu_configConfirmPIDKd(struct MenuCore* self)
MenuCore_changeState(self, RM_ADMINMENU);
Display_clearScreen(self->display);
char buffer[20];
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "Constants saved");
Display_write(self->display, buffer, 3, 3);
Display_writeCentered(self->display, MenuText_SAFE_CONSTANTS[languageIndex], 3);
vTaskDelay(REPAIRMENU_POPUPSCREEN_TIME_MS);
}
@@ -811,55 +800,25 @@ static void repairMenu_configConfirmPIDKd(struct MenuCore* self)
static void repairMenu_printAdminVoltageInput(struct MenuCore* self)
{
char buffer[self->display->displayDevice->parameters.numberOfColumns + 1];
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "Voltage input");
Display_write(self->display, buffer, 1, 1);
Display_write(self->display, MenuText_VOLTAGE_IN_HEADER[languageIndex], 1, 1);
if (PCBA_getInstance()->pcba != PCBA_Tesla)
{
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "Row1: %5dV | %4Xx", ADConverter_getInputVoltage(adcRow1), ADConverter_getInputConverterValue(adcRow1));
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%s1: %5dV|%4Xx", MenuText_VOLTAGE_ROW[languageIndex], ADConverter_getInputVoltage(adcRow1), ADConverter_getInputConverterValue(adcRow1));
Display_write(self->display, buffer, 2, 1);
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "Row3: %5dV | %4Xx", ADConverter_getInputVoltage(adcRow3), ADConverter_getInputConverterValue(adcRow3));
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%s3: %5dV|%4Xx", MenuText_VOLTAGE_ROW[languageIndex], ADConverter_getInputVoltage(adcRow3), ADConverter_getInputConverterValue(adcRow3));
Display_write(self->display, buffer, 4, 1);
}
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "Row2: %5dV | %4Xx", ADConverter_getInputVoltage(adcRow2), ADConverter_getInputConverterValue(adcRow2));
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%s2: %5dV|%4Xx", MenuText_VOLTAGE_ROW[languageIndex], ADConverter_getInputVoltage(adcRow2), ADConverter_getInputConverterValue(adcRow2));
Display_write(self->display, buffer, 3, 1);
}
static void repairMenu_printConfigPreset(struct MenuCore* self)
{
int loopCounter;
char buffer[self->display->displayDevice->parameters.numberOfColumns];
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "Preset %d info", self->selectionIndex);
// Always print Row1 (index0), ignoring the scrolling index
Display_write(self->display, buffer, 1, 1);
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "Start:");
Display_write(self->display, buffer, 2, 1);
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "Time:");
Display_write(self->display, buffer, 3, 1);
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "Volt:");
Display_write(self->display, buffer, 4, 1);
for (loopCounter = 0; loopCounter < RepairPresets_getPreset(self->selectionIndex)->numberOfStages; loopCounter++)
{
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5dm", (RepairPresets_getPreset(self->selectionIndex)->preset[loopCounter].softstartDuration / 60));
Display_write(self->display, buffer, 2, 8 + loopCounter * 7);
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5dm", (RepairPresets_getPreset(self->selectionIndex)->preset[loopCounter].duration / 60));
Display_write(self->display, buffer, 3, 8 + loopCounter * 7);
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5dV", RepairPresets_getPreset(self->selectionIndex)->preset[loopCounter].voltage);
Display_write(self->display, buffer, 4, 8 + loopCounter * 7);
}
}
static void repairMenu_printPINVerification(struct MenuCore* self)
{
char buffer[self->display->displayDevice->parameters.numberOfColumns];
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "Insert PIN");
Display_write(self->display, buffer, 3, 6);
char buffer[PIN_NUMBER_OF_DIGITS + 1];
Display_writeCentered(self->display, MenuText_INSERT_PIN[languageIndex], 3);
int numberOfDigits = strlen(self->insertString);
int loopcounter;
@@ -876,7 +835,7 @@ static void repairMenu_printPINVerification(struct MenuCore* self)
}
buffer[PIN_NUMBER_OF_DIGITS] = '\0';
Display_write(self->display, buffer, 4, 9);
Display_writeCentered(self->display, buffer, 4);
}
@@ -884,18 +843,17 @@ static void repairMenu_printPINVerification(struct MenuCore* self)
static void repairMenu_printVoltageOutput(struct MenuCore* self)
{
char buffer[self->display->displayDevice->parameters.numberOfColumns];
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "Set voltage out");
// Always print Row1 (index0), ignoring the scrolling index
Display_write(self->display, buffer, 1, 1);
Display_write(self->display, MenuText_VOLTAGE_OUT_HEADER[languageIndex], 1, 1);
if (PCBA_getInstance()->pcba != PCBA_Tesla)
{
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "R1: %5dV | %5dV", (unsigned int)DAConverter_getCurrentValue(dacRow1), ADConverter_getInputVoltage(adcRow1));
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%s1: %5dV|%5dV", MenuText_VOLTAGE_ROW[languageIndex], (unsigned int)DAConverter_getCurrentValue(dacRow1), ADConverter_getInputVoltage(adcRow1));
Display_write(self->display, buffer, 2, 1);
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "R3: %5dV | %5dV", (unsigned int)DAConverter_getCurrentValue(dacRow3), ADConverter_getInputVoltage(adcRow3));
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%s3: %5dV|%5dV", MenuText_VOLTAGE_ROW[languageIndex], (unsigned int)DAConverter_getCurrentValue(dacRow3), ADConverter_getInputVoltage(adcRow3));
Display_write(self->display, buffer, 4, 1);
}
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "R2: %5dV | %5dV", (unsigned int)DAConverter_getCurrentValue(dacRow2), ADConverter_getInputVoltage(adcRow2));
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%s2: %5dV|%5dV", MenuText_VOLTAGE_ROW[languageIndex], (unsigned int)DAConverter_getCurrentValue(dacRow2), ADConverter_getInputVoltage(adcRow2));
Display_write(self->display, buffer, 3, 1);
}
@@ -903,9 +861,9 @@ static void repairMenu_printVoltageOutput(struct MenuCore* self)
static void repairMenu_printPIDConstants(struct MenuCore* self)
{
char buffer[self->display->displayDevice->parameters.numberOfColumns];
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "PID constants");
// Always print Row1 (index0), ignoring the scrolling index
Display_write(self->display, buffer, 1, 1);
Display_write(self->display, MenuText_CONSTANTS_HEADER[languageIndex], 1, 1);
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "Kp: %5d", DeviceParameters_getPIDParameters()->Kp);
Display_write(self->display, buffer, 2, 1);
@@ -918,20 +876,19 @@ static void repairMenu_printPIDConstants(struct MenuCore* self)
static void repairMenu_printInfo(struct MenuCore* self)
{
Display_write(mainDisplay, PCBA_getInstance()->name, 3, 2);
Display_writeCentered(mainDisplay, PCBA_getInstance()->name, 3);
char buffer[20];
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "SW V. %d.%d.%d.%d", Version_getInstance()->major,
Version_getInstance()->minor,
Version_getInstance()->branch,
Version_getInstance()->patch);
Display_write(mainDisplay, buffer, 4, 4);
Display_writeCentered(mainDisplay, buffer, 4);
}
static void repairMenu_confirmCalibrationPin(struct MenuCore* self)
{
char buffer[20];
char pin[PIN_NUMBER_OF_DIGITS];
int loopcounter;
@@ -942,9 +899,8 @@ static void repairMenu_confirmCalibrationPin(struct MenuCore* self)
if (PIN_isOK(DeviceParameters_getPIN(), pin))
{
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "PIN OK");
Display_clearScreen(self->display);
Display_write(self->display, buffer, 3, 8);
Display_writeCentered(self->display, MenuText_CONFIRM_PIN[languageIndex][0], 3);
vTaskDelay(REPAIRMENU_POPUPSCREEN_TIME_MS);
if (PCBA_getInstance()->pcba == PCBA_CathodeMCP)
{
@@ -957,9 +913,8 @@ static void repairMenu_confirmCalibrationPin(struct MenuCore* self)
}
else
{
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "PIN DENIED");
Display_clearScreen(self->display);
Display_write(self->display, buffer, 3, 6);
Display_writeCentered(self->display, MenuText_CONFIRM_PIN[languageIndex][1], 3);
vTaskDelay(REPAIRMENU_POPUPSCREEN_TIME_MS);
MenuCore_changeState(self, RM_MAINMENU);
}
@@ -991,8 +946,8 @@ static void repairMenu_selectPreset(struct MenuCore* self)
Display_clearScreen(self->display);
char buffer[20];
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "Preset %d selected", self->selectionIndex);
Display_write(self->display, buffer, 3, 2);
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%s %d", MenuText_SELECT_PRESET[languageIndex], self->selectionIndex);
Display_writeCentered(self->display, buffer, 3);
vTaskDelay(REPAIRMENU_POPUPSCREEN_TIME_MS);
}
@@ -1207,7 +1162,7 @@ void repairMenu_menuStateHandle(struct MenuCore* self)
else if (self->menuState == RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART)
{
repairMenu_printConfigPreset(self);
repairMenu_printPreset(self);
char buffer[7];
// Remove leading 0 from string if necessary
@@ -1221,16 +1176,17 @@ void repairMenu_menuStateHandle(struct MenuCore* self)
}
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5sm", self->insertString);
Display_write(self->display, buffer, 2, 8);
Display_write(self->display, buffer, 2, MENUTEXT_PRESET_MAX_LENGTH + 1);
vTaskDelay(2);
Display_setCursorToPosition(self->display, 2, 12);
Display_setCursorToPosition(self->display, 2, MENUTEXT_PRESET_MAX_LENGTH + 1 + 5);
vTaskDelay(2);
Display_setBlinkingCursorState(self->display, ON);
}
else if (self->menuState == RM_ADMIN_PRESET_CONFIG_FIRST_DURATION)
{
repairMenu_printConfigPreset(self);
// repairMenu_printConfigPreset(self);
repairMenu_printPreset(self);
char buffer[7];
// Remove leading 0 from string if necessary
@@ -1244,16 +1200,17 @@ void repairMenu_menuStateHandle(struct MenuCore* self)
}
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5sm", self->insertString);
Display_write(self->display, buffer, 3, 8);
Display_write(self->display, buffer, 3, MENUTEXT_PRESET_MAX_LENGTH + 1);
vTaskDelay(2);
Display_setCursorToPosition(self->display, 3, 12);
Display_setCursorToPosition(self->display, 3, MENUTEXT_PRESET_MAX_LENGTH + 1 + 5);
vTaskDelay(2);
Display_setBlinkingCursorState(self->display, ON);
}
else if (self->menuState == RM_ADMIN_PRESET_CONFIG_FIRST_VOLTAGE)
{
repairMenu_printConfigPreset(self);
// repairMenu_printConfigPreset(self);
repairMenu_printPreset(self);
char buffer[7];
// Remove leading 0 from string if necessary
@@ -1280,13 +1237,16 @@ void repairMenu_menuStateHandle(struct MenuCore* self)
}
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5s", self->insertString);
Display_write(self->display, buffer, 4, 8);
Display_setCursorToPosition(self->display, 4, 12);
Display_write(self->display, buffer, 4, MENUTEXT_PRESET_MAX_LENGTH + 1);
vTaskDelay(2);
Display_setCursorToPosition(self->display, 4, MENUTEXT_PRESET_MAX_LENGTH + 5);
vTaskDelay(2);
Display_setBlinkingCursorState(self->display, ON);
}
else if (self->menuState == RM_ADMIN_PRESET_CONFIG_SECOND_SOFTSTART)
{
repairMenu_printConfigPreset(self);
// repairMenu_printConfigPreset(self);
repairMenu_printPreset(self);
char buffer[7];
// Remove leading 0 from string if necessary
@@ -1300,14 +1260,17 @@ void repairMenu_menuStateHandle(struct MenuCore* self)
}
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5s", self->insertString);
Display_write(self->display, buffer, 2, 15);
Display_setCursorToPosition(self->display, 2, 19);
Display_write(self->display, buffer, 2, 2 * MENUTEXT_PRESET_MAX_LENGTH + 1);
vTaskDelay(2);
Display_setCursorToPosition(self->display, 2, 2 * MENUTEXT_PRESET_MAX_LENGTH + 5);
vTaskDelay(2);
Display_setBlinkingCursorState(self->display, ON);
}
else if (self->menuState == RM_ADMIN_PRESET_CONFIG_SECOND_DURATION)
{
repairMenu_printConfigPreset(self);
// repairMenu_printConfigPreset(self);
repairMenu_printPreset(self);
char buffer[7];
// Remove leading 0 from string if necessary
@@ -1321,14 +1284,17 @@ void repairMenu_menuStateHandle(struct MenuCore* self)
}
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5s", self->insertString);
Display_write(self->display, buffer, 3, 15);
Display_setCursorToPosition(self->display, 3, 19);
Display_write(self->display, buffer, 3, 2 * MENUTEXT_PRESET_MAX_LENGTH + 1);
vTaskDelay(2);
Display_setCursorToPosition(self->display, 3, 2 * MENUTEXT_PRESET_MAX_LENGTH + 5);
vTaskDelay(2);
Display_setBlinkingCursorState(self->display, ON);
}
else if (self->menuState == RM_ADMIN_PRESET_CONFIG_SECOND_VOLTAGE)
{
repairMenu_printConfigPreset(self);
// repairMenu_printConfigPreset(self);
repairMenu_printPreset(self);
char buffer[7];
// Remove leading 0 from string if necessary
@@ -1358,8 +1324,10 @@ void repairMenu_menuStateHandle(struct MenuCore* self)
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5s", self->insertString);
Display_write(self->display, buffer, 4, 15);
Display_setCursorToPosition(self->display, 4, 19);
Display_write(self->display, buffer, 4, 2 * MENUTEXT_PRESET_MAX_LENGTH + 1);
vTaskDelay(2);
Display_setCursorToPosition(self->display, 4, 2 * MENUTEXT_PRESET_MAX_LENGTH + 5);
vTaskDelay(2);
Display_setBlinkingCursorState(self->display, ON);
}
@@ -1378,10 +1346,14 @@ void repairMenu_menuStateHandle(struct MenuCore* self)
}
}
vTaskDelay(2);
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5s", self->insertString);
Display_write(self->display, buffer, 2, 5);
vTaskDelay(2);
Display_setCursorToPosition(self->display, 2, 9);
vTaskDelay(2);
Display_setBlinkingCursorState(self->display, ON);
vTaskDelay(2);
}
else if (self->menuState == RM_ADMIN_PID_CONFIG_KI)
@@ -1399,10 +1371,14 @@ void repairMenu_menuStateHandle(struct MenuCore* self)
}
}
vTaskDelay(2);
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5s", self->insertString);
Display_write(self->display, buffer, 3, 5);
vTaskDelay(2);
Display_setCursorToPosition(self->display, 3, 9);
vTaskDelay(2);
Display_setBlinkingCursorState(self->display, ON);
vTaskDelay(2);
}
else if (self->menuState == RM_ADMIN_PID_CONFIG_KD)
@@ -1420,10 +1396,14 @@ void repairMenu_menuStateHandle(struct MenuCore* self)
}
}
vTaskDelay(2);
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5s", self->insertString);
Display_write(self->display, buffer, 4, 5);
vTaskDelay(2);
Display_setCursorToPosition(self->display, 4, 9);
vTaskDelay(2);
Display_setBlinkingCursorState(self->display, ON);
vTaskDelay(2);
}
else if (self->menuState == RM_CALIBRATIONMENU_PIN_VERIFICATION)
@@ -1460,8 +1440,10 @@ void repairMenu_menuStateHandle(struct MenuCore* self)
}
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5sV", self->insertString);
Display_write(self->display, buffer, 2, 5);
Display_setCursorToPosition(self->display, 2, 9);
Display_write(self->display, buffer, 2, 7);
vTaskDelay(2);
Display_setCursorToPosition(self->display, 2, 11);
vTaskDelay(2);
Display_setBlinkingCursorState(self->display, ON);
}
@@ -1494,8 +1476,10 @@ void repairMenu_menuStateHandle(struct MenuCore* self)
}
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5sV", self->insertString);
Display_write(self->display, buffer, 3, 5);
Display_setCursorToPosition(self->display, 3, 9);
Display_write(self->display, buffer, 3, 7);
vTaskDelay(2);
Display_setCursorToPosition(self->display, 3, 11);
vTaskDelay(2);
Display_setBlinkingCursorState(self->display, ON);
}
@@ -1528,8 +1512,10 @@ void repairMenu_menuStateHandle(struct MenuCore* self)
}
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5sV", self->insertString);
Display_write(self->display, buffer, 4, 5);
Display_setCursorToPosition(self->display, 4, 9);
Display_write(self->display, buffer, 4, 7);
vTaskDelay(2);
Display_setCursorToPosition(self->display, 4, 11);
vTaskDelay(2);
Display_setBlinkingCursorState(self->display, ON);
}
@@ -1542,11 +1528,9 @@ void repairMenu_menuStateHandle(struct MenuCore* self)
Power6V5Supply_off();
char buffer[21];
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "All rows reset to 0V");
Display_write(self->display, buffer, 3, 1);
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "Press X to continue");
Display_write(self->display, buffer, 4, 1);
Display_writeCentered(self->display, MenuText_VOLTAGE_OUT_CLEANUP[languageIndex][0], 3);
Display_writeCentered(self->display, MenuText_VOLTAGE_OUT_CLEANUP[languageIndex][1], 4);
}
}
@@ -1571,14 +1555,14 @@ void repairMenu_createMenuEntries(struct MenuCore* menuCore)
if (PCBA_getInstance()->pcba == PCBA_CathodeMCP)
{
// For Cathode/MCP PCBA, the type of repair must be selected first
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_MAINMENU], MenuText_MAINMENU[MENUTEXT_ENGLISH][1], RM_REPAIR_CATHODEMCP_SELECT, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_MAINMENU], MenuText_MAINMENU[languageIndex][1], RM_REPAIR_CATHODEMCP_SELECT, NULL);
}
else
{
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_MAINMENU], MenuText_MAINMENU[MENUTEXT_ENGLISH][1], RM_REPAIRMENU, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_MAINMENU], MenuText_MAINMENU[languageIndex][1], RM_REPAIRMENU, NULL);
}
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_MAINMENU], MenuText_MAINMENU[MENUTEXT_ENGLISH][2], RM_ADMINMENU_PIN_VERIFICATION, repairMenu_prepareAdminPinVerification);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_MAINMENU], MenuText_MAINMENU[MENUTEXT_ENGLISH][3], RM_CALIBRATIONMENU_PIN_VERIFICATION, repairMenu_prepareAdminPinVerification);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_MAINMENU], MenuText_MAINMENU[languageIndex][2], RM_ADMINMENU_PIN_VERIFICATION, repairMenu_prepareAdminPinVerification);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_MAINMENU], MenuText_MAINMENU[languageIndex][3], RM_CALIBRATIONMENU_PIN_VERIFICATION, repairMenu_prepareAdminPinVerification);
MenuElements_addKeyAction_SCROLLUP(&menuCore->menuArray[RM_MAINMENU], 'U', PRESSED);
MenuElements_addKeyAction_SCROLLDOWN(&menuCore->menuArray[RM_MAINMENU], 'D', PRESSED);
MenuElements_addKeyAction_SELECT(&menuCore->menuArray[RM_MAINMENU], 'E', PRESSED);
@@ -1596,9 +1580,9 @@ void repairMenu_createMenuEntries(struct MenuCore* menuCore)
* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
*/
MenuElements_createMenuPage(&menuCore->menuArray[RM_REPAIR_CATHODEMCP_SELECT], MENU_HAS_CURSOR, 3);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_REPAIR_CATHODEMCP_SELECT], MenuText_CATHODEMCP_SELECT[MENUTEXT_ENGLISH][0], RM_REPAIR_CATHODEMCP_SELECT, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_REPAIR_CATHODEMCP_SELECT], MenuText_CATHODEMCP_SELECT[MENUTEXT_ENGLISH][1], RM_REPAIRMENU, repairMenu_selectCathodeRepair);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_REPAIR_CATHODEMCP_SELECT], MenuText_CATHODEMCP_SELECT[MENUTEXT_ENGLISH][2], RM_REPAIRMENU, repairMenu_selectMCPRepair);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_REPAIR_CATHODEMCP_SELECT], MenuText_CATHODEMCP_SELECT[languageIndex][0], RM_REPAIR_CATHODEMCP_SELECT, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_REPAIR_CATHODEMCP_SELECT], MenuText_CATHODEMCP_SELECT[languageIndex][1], RM_REPAIRMENU, repairMenu_selectCathodeRepair);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_REPAIR_CATHODEMCP_SELECT], MenuText_CATHODEMCP_SELECT[languageIndex][2], RM_REPAIRMENU, repairMenu_selectMCPRepair);
MenuElements_addKeyAction_SCROLLUP(&menuCore->menuArray[RM_REPAIR_CATHODEMCP_SELECT], 'U', PRESSED);
MenuElements_addKeyAction_SCROLLDOWN(&menuCore->menuArray[RM_REPAIR_CATHODEMCP_SELECT], 'D', PRESSED);
MenuElements_addKeyAction_SELECT(&menuCore->menuArray[RM_REPAIR_CATHODEMCP_SELECT], 'E', PRESSED);
@@ -1618,9 +1602,9 @@ void repairMenu_createMenuEntries(struct MenuCore* menuCore)
* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
*/
MenuElements_createMenuPage(&menuCore->menuArray[RM_REPAIRMENU], MENU_HAS_CURSOR, 4);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_REPAIRMENU], MenuText_REPAIRMENU[MENUTEXT_ENGLISH][0], RM_REPAIRMENU, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_REPAIRMENU], MenuText_REPAIRMENU[MENUTEXT_ENGLISH][1], RM_PRESETMENU, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_REPAIRMENU], MenuText_REPAIRMENU[MENUTEXT_ENGLISH][2], RM_START_REPAIR, repairMenu_startRepairProcess);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_REPAIRMENU], MenuText_REPAIRMENU[languageIndex][0], RM_REPAIRMENU, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_REPAIRMENU], MenuText_REPAIRMENU[languageIndex][1], RM_PRESETMENU, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_REPAIRMENU], MenuText_REPAIRMENU[languageIndex][2], RM_START_REPAIR, repairMenu_startRepairProcess);
MenuElements_addKeyAction_SCROLLUP(&menuCore->menuArray[RM_REPAIRMENU], 'U', PRESSED);
MenuElements_addKeyAction_SCROLLDOWN(&menuCore->menuArray[RM_REPAIRMENU], 'D', PRESSED);
MenuElements_addKeyAction_SELECT(&menuCore->menuArray[RM_REPAIRMENU], 'E', PRESSED);
@@ -1648,16 +1632,16 @@ void repairMenu_createMenuEntries(struct MenuCore* menuCore)
* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
*/
MenuElements_createMenuPage(&menuCore->menuArray[RM_PRESETMENU], MENU_HAS_CURSOR, 10);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_PRESETMENU], MenuText_PRESETMENU[MENUTEXT_ENGLISH][0], RM_PRESETMENU, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_PRESETMENU], MenuText_PRESETMENU[MENUTEXT_ENGLISH][1], RM_REPAIRMENU, repairMenu_selectPreset);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_PRESETMENU], MenuText_PRESETMENU[MENUTEXT_ENGLISH][2], RM_REPAIRMENU, repairMenu_selectPreset);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_PRESETMENU], MenuText_PRESETMENU[MENUTEXT_ENGLISH][3], RM_REPAIRMENU, repairMenu_selectPreset);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_PRESETMENU], MenuText_PRESETMENU[MENUTEXT_ENGLISH][4], RM_REPAIRMENU, repairMenu_selectPreset);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_PRESETMENU], MenuText_PRESETMENU[MENUTEXT_ENGLISH][5], RM_REPAIRMENU, repairMenu_selectPreset);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_PRESETMENU], MenuText_PRESETMENU[MENUTEXT_ENGLISH][6], RM_REPAIRMENU, repairMenu_selectPreset);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_PRESETMENU], MenuText_PRESETMENU[MENUTEXT_ENGLISH][7], RM_REPAIRMENU, repairMenu_selectPreset);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_PRESETMENU], MenuText_PRESETMENU[MENUTEXT_ENGLISH][8], RM_REPAIRMENU, repairMenu_selectPreset);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_PRESETMENU], MenuText_PRESETMENU[MENUTEXT_ENGLISH][9], RM_REPAIRMENU, repairMenu_selectPreset);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_PRESETMENU], MenuText_PRESETMENU[languageIndex][0], RM_PRESETMENU, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_PRESETMENU], MenuText_PRESETMENU[languageIndex][1], RM_REPAIRMENU, repairMenu_selectPreset);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_PRESETMENU], MenuText_PRESETMENU[languageIndex][2], RM_REPAIRMENU, repairMenu_selectPreset);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_PRESETMENU], MenuText_PRESETMENU[languageIndex][3], RM_REPAIRMENU, repairMenu_selectPreset);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_PRESETMENU], MenuText_PRESETMENU[languageIndex][4], RM_REPAIRMENU, repairMenu_selectPreset);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_PRESETMENU], MenuText_PRESETMENU[languageIndex][5], RM_REPAIRMENU, repairMenu_selectPreset);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_PRESETMENU], MenuText_PRESETMENU[languageIndex][6], RM_REPAIRMENU, repairMenu_selectPreset);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_PRESETMENU], MenuText_PRESETMENU[languageIndex][7], RM_REPAIRMENU, repairMenu_selectPreset);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_PRESETMENU], MenuText_PRESETMENU[languageIndex][8], RM_REPAIRMENU, repairMenu_selectPreset);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_PRESETMENU], MenuText_PRESETMENU[languageIndex][9], RM_REPAIRMENU, repairMenu_selectPreset);
MenuElements_addKeyAction_SCROLLUP(&menuCore->menuArray[RM_PRESETMENU], 'U', PRESSED);
MenuElements_addKeyAction_SCROLLDOWN(&menuCore->menuArray[RM_PRESETMENU], 'D', PRESSED);
MenuElements_addKeyAction_SELECT(&menuCore->menuArray[RM_PRESETMENU], 'E', PRESSED);
@@ -1720,9 +1704,9 @@ void repairMenu_createMenuEntries(struct MenuCore* menuCore)
* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
*/
MenuElements_createMenuPage(&menuCore->menuArray[RM_ADMIN_CATHODEMCP_SELECT], MENU_HAS_CURSOR, 3);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_CATHODEMCP_SELECT], MenuText_ADMIN_CATHODEMCP_SELECT[MENUTEXT_ENGLISH][0], RM_ADMIN_CATHODEMCP_SELECT, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_CATHODEMCP_SELECT], MenuText_ADMIN_CATHODEMCP_SELECT[MENUTEXT_ENGLISH][1], RM_ADMIN_PRESET_CONFIG_SELECT, repairMenu_selectCathodeRepair);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_CATHODEMCP_SELECT], MenuText_ADMIN_CATHODEMCP_SELECT[MENUTEXT_ENGLISH][2], RM_ADMIN_PRESET_CONFIG_SELECT, repairMenu_selectMCPRepair);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_CATHODEMCP_SELECT], MenuText_ADMIN_CATHODEMCP_SELECT[languageIndex][0], RM_ADMIN_CATHODEMCP_SELECT, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_CATHODEMCP_SELECT], MenuText_ADMIN_CATHODEMCP_SELECT[languageIndex][1], RM_ADMIN_PRESET_CONFIG_SELECT, repairMenu_selectCathodeRepair);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_CATHODEMCP_SELECT], MenuText_ADMIN_CATHODEMCP_SELECT[languageIndex][2], RM_ADMIN_PRESET_CONFIG_SELECT, repairMenu_selectMCPRepair);
MenuElements_addKeyAction_SCROLLUP(&menuCore->menuArray[RM_ADMIN_CATHODEMCP_SELECT], 'U', PRESSED);
MenuElements_addKeyAction_SCROLLDOWN(&menuCore->menuArray[RM_ADMIN_CATHODEMCP_SELECT], 'D', PRESSED);
MenuElements_addKeyAction_SELECT(&menuCore->menuArray[RM_ADMIN_CATHODEMCP_SELECT], 'E', PRESSED);
@@ -1740,19 +1724,19 @@ void repairMenu_createMenuEntries(struct MenuCore* menuCore)
* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
*/
MenuElements_createMenuPage(&menuCore->menuArray[RM_ADMINMENU], MENU_HAS_CURSOR, 6);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMINMENU], MenuText_ADMINMENU[MENUTEXT_ENGLISH][0], RM_ADMINMENU, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMINMENU], MenuText_ADMINMENU[MENUTEXT_ENGLISH][1], RM_ADMIN_CHANGEPIN_FIRST_INSERT, repairMenu_configPinChange);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMINMENU], MenuText_ADMINMENU[MENUTEXT_ENGLISH][2], RM_ADMIN_IOCONTROL, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMINMENU], MenuText_ADMINMENU[languageIndex][0], RM_ADMINMENU, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMINMENU], MenuText_ADMINMENU[languageIndex][1], RM_ADMIN_CHANGEPIN_FIRST_INSERT, repairMenu_configPinChange);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMINMENU], MenuText_ADMINMENU[languageIndex][2], RM_ADMIN_IOCONTROL, NULL);
if (PCBA_getInstance()->pcba == PCBA_CathodeMCP)
{
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMINMENU], MenuText_ADMINMENU[MENUTEXT_ENGLISH][3], RM_ADMIN_CATHODEMCP_SELECT, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMINMENU], MenuText_ADMINMENU[languageIndex][3], RM_ADMIN_CATHODEMCP_SELECT, NULL);
}
else
{
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMINMENU], MenuText_ADMINMENU[MENUTEXT_ENGLISH][3], RM_ADMIN_PRESET_CONFIG_SELECT, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMINMENU], MenuText_ADMINMENU[languageIndex][3], RM_ADMIN_PRESET_CONFIG_SELECT, NULL);
}
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMINMENU], MenuText_ADMINMENU[MENUTEXT_ENGLISH][4], RM_ADMIN_PID_CONFIG_KP, repairMenu_configPID);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMINMENU], MenuText_ADMINMENU[MENUTEXT_ENGLISH][5], RM_ADMIN_INFO, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMINMENU], MenuText_ADMINMENU[languageIndex][4], RM_ADMIN_PID_CONFIG_KP, repairMenu_configPID);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMINMENU], MenuText_ADMINMENU[languageIndex][5], RM_ADMIN_INFO, NULL);
MenuElements_addKeyAction_SCROLLUP(&menuCore->menuArray[RM_ADMINMENU], 'U', PRESSED);
MenuElements_addKeyAction_SCROLLDOWN(&menuCore->menuArray[RM_ADMINMENU], 'D', PRESSED);
MenuElements_addKeyAction_SELECT(&menuCore->menuArray[RM_ADMINMENU], 'E', PRESSED);
@@ -1768,7 +1752,7 @@ void repairMenu_createMenuEntries(struct MenuCore* menuCore)
* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
*/
MenuElements_createMenuPage(&menuCore->menuArray[RM_ADMIN_CHANGEPIN_FIRST_INSERT], MENU_HAS_NO_CURSOR, 5);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_CHANGEPIN_FIRST_INSERT], MenuText_ADMINCHANGEPINMENU[MENUTEXT_ENGLISH][0], RM_ADMIN_CHANGEPIN_FIRST_INSERT, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_CHANGEPIN_FIRST_INSERT], MenuText_ADMINCHANGEPINMENU[languageIndex][0], RM_ADMIN_CHANGEPIN_FIRST_INSERT, NULL);
MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_ADMIN_CHANGEPIN_FIRST_INSERT], 'X', PRESSED, RM_ADMINMENU);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_CHANGEPIN_FIRST_INSERT], '0', PRESSED, 4);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_CHANGEPIN_FIRST_INSERT], '1', PRESSED, 4);
@@ -1784,7 +1768,7 @@ void repairMenu_createMenuEntries(struct MenuCore* menuCore)
MenuElements_addKeyAction_DIGITINSERTCONFIRM(&menuCore->menuArray[RM_ADMIN_CHANGEPIN_FIRST_INSERT], 'E', PRESSED, repairMenu_configConfirmFirstPin);
MenuElements_createMenuPage(&menuCore->menuArray[RM_ADMIN_CHANGEPIN_SECOND_INSERT], MENU_HAS_NO_CURSOR, 5);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_CHANGEPIN_SECOND_INSERT], MenuText_ADMINCHANGEPINMENU[MENUTEXT_ENGLISH][0], RM_ADMIN_CHANGEPIN_SECOND_INSERT, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_CHANGEPIN_SECOND_INSERT], MenuText_ADMINCHANGEPINMENU[languageIndex][0], RM_ADMIN_CHANGEPIN_SECOND_INSERT, NULL);
MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_ADMIN_CHANGEPIN_SECOND_INSERT], 'X', PRESSED, RM_ADMINMENU);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_CHANGEPIN_SECOND_INSERT], '0', PRESSED, 4);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_CHANGEPIN_SECOND_INSERT], '1', PRESSED, 4);
@@ -1818,21 +1802,21 @@ void repairMenu_createMenuEntries(struct MenuCore* menuCore)
{
MenuElements_createMenuPage(&menuCore->menuArray[RM_ADMIN_IOCONTROL], MENU_HAS_CURSOR, 5);
}
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_IOCONTROL], MenuText_ADMINIOMAINMENU[MENUTEXT_ENGLISH][0], RM_ADMIN_IOCONTROL, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_IOCONTROL], MenuText_ADMINIOMAINMENU[MENUTEXT_ENGLISH][1], RM_ADMIN_IO_INTERLOCK, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_IOCONTROL], MenuText_ADMINIOMAINMENU[MENUTEXT_ENGLISH][2], RM_ADMIN_IO_SOLENOID, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_IOCONTROL], MenuText_ADMINIOMAINMENU[MENUTEXT_ENGLISH][3], RM_ADMIN_IO_VOLTAGE_IN, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_IOCONTROL], MenuText_ADMINIOMAINMENU[languageIndex][0], RM_ADMIN_IOCONTROL, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_IOCONTROL], MenuText_ADMINIOMAINMENU[languageIndex][1], RM_ADMIN_IO_INTERLOCK, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_IOCONTROL], MenuText_ADMINIOMAINMENU[languageIndex][2], RM_ADMIN_IO_SOLENOID, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_IOCONTROL], MenuText_ADMINIOMAINMENU[languageIndex][3], RM_ADMIN_IO_VOLTAGE_IN, NULL);
if (PCBA_getInstance()->pcba == PCBA_Tesla)
{
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_IOCONTROL], MenuText_ADMINIOMAINMENU[MENUTEXT_ENGLISH][4], RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL2, repairMenu_configVoltageOutput);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_IOCONTROL], MenuText_ADMINIOMAINMENU[languageIndex][4], RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL2, repairMenu_configVoltageOutput);
}
else
{
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_IOCONTROL], MenuText_ADMINIOMAINMENU[MENUTEXT_ENGLISH][4], RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL1, repairMenu_configVoltageOutput);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_IOCONTROL], MenuText_ADMINIOMAINMENU[languageIndex][4], RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL1, repairMenu_configVoltageOutput);
}
if (PCBA_getInstance()->pcba == PCBA_Tesla)
{
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_IOCONTROL], MenuText_ADMINIOMAINMENU[MENUTEXT_ENGLISH][5], RM_ADMIN_IO_TESLAGUN, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_IOCONTROL], MenuText_ADMINIOMAINMENU[languageIndex][5], RM_ADMIN_IO_TESLAGUN, NULL);
}
MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_ADMIN_IOCONTROL], 'X', PRESSED, RM_ADMINMENU);
MenuElements_addKeyAction_SCROLLUP(&menuCore->menuArray[RM_ADMIN_IOCONTROL], 'U', PRESSED);
@@ -1855,7 +1839,7 @@ void repairMenu_createMenuEntries(struct MenuCore* menuCore)
* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
*/
MenuElements_createMenuPage(&menuCore->menuArray[RM_ADMIN_IO_INTERLOCK], MENU_HAS_NO_CURSOR, 4);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_IOCONTROL], MenuText_ADMINIOINTERLOCKMENU[MENUTEXT_ENGLISH][0], RM_ADMIN_IO_INTERLOCK, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_IOCONTROL], MenuText_ADMINIOINTERLOCKMENU[languageIndex][0], RM_ADMIN_IO_INTERLOCK, NULL);
MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_ADMIN_IO_INTERLOCK], 'X', PRESSED, RM_ADMIN_IOCONTROL);
/* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
@@ -1867,8 +1851,8 @@ void repairMenu_createMenuEntries(struct MenuCore* menuCore)
* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
*/
MenuElements_createMenuPage(&menuCore->menuArray[RM_ADMIN_IO_SOLENOID], MENU_HAS_NO_CURSOR, 4);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_IO_SOLENOID], MenuText_ADMINSOLENOIDMENU[MENUTEXT_ENGLISH][0], RM_ADMIN_IO_SOLENOID, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_IO_SOLENOID], MenuText_ADMINSOLENOIDMENU[MENUTEXT_ENGLISH][1], RM_ADMIN_IO_SOLENOID, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_IO_SOLENOID], MenuText_ADMINSOLENOIDMENU[languageIndex][0], RM_ADMIN_IO_SOLENOID, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_IO_SOLENOID], MenuText_ADMINSOLENOIDMENU[languageIndex][1], RM_ADMIN_IO_SOLENOID, NULL);
MenuElements_addKeyAction_EXECUTEFUNCTION(&menuCore->menuArray[RM_ADMIN_IO_SOLENOID], '0', PRESSED, repairMenu_solenoidUnlock);
MenuElements_addKeyAction_EXECUTEFUNCTION(&menuCore->menuArray[RM_ADMIN_IO_SOLENOID], '0', RELEASED, repairMenu_solenoidLock);
MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_ADMIN_IO_SOLENOID], 'X', PRESSED, RM_ADMIN_IOCONTROL);
@@ -1980,8 +1964,8 @@ void repairMenu_createMenuEntries(struct MenuCore* menuCore)
if (PCBA_getInstance()->pcba == PCBA_Tesla)
{
MenuElements_createMenuPage(&menuCore->menuArray[RM_ADMIN_IO_TESLAGUN], MENU_HAS_NO_CURSOR, 4);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_IO_TESLAGUN], MenuText_ADMINTESLAGUNMENU[MENUTEXT_ENGLISH][0], RM_ADMIN_IO_TESLAGUN, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_IO_TESLAGUN], MenuText_ADMINTESLAGUNMENU[MENUTEXT_ENGLISH][1], RM_ADMIN_IO_TESLAGUN, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_IO_TESLAGUN], MenuText_ADMINTESLAGUNMENU[languageIndex][0], RM_ADMIN_IO_TESLAGUN, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_IO_TESLAGUN], MenuText_ADMINTESLAGUNMENU[languageIndex][1], RM_ADMIN_IO_TESLAGUN, NULL);
MenuElements_addKeyAction_EXECUTEFUNCTION(&menuCore->menuArray[RM_ADMIN_IO_TESLAGUN], '0', PRESSED, repairMenu_teslagunRelease);
MenuElements_addKeyAction_EXECUTEFUNCTION(&menuCore->menuArray[RM_ADMIN_IO_TESLAGUN], '0', RELEASED, repairMenu_teslagunBlock);
MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_ADMIN_IO_TESLAGUN], 'X', PRESSED, RM_ADMIN_IOCONTROL);
@@ -1994,16 +1978,16 @@ void repairMenu_createMenuEntries(struct MenuCore* menuCore)
* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
*/
MenuElements_createMenuPage(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SELECT], MENU_HAS_CURSOR, 10);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SELECT], MenuText_ADMINPRESETCONFIGSELECTMENU[MENUTEXT_ENGLISH][0], RM_ADMIN_PRESET_CONFIG_SELECT, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SELECT], MenuText_ADMINPRESETCONFIGSELECTMENU[MENUTEXT_ENGLISH][1], RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART, repairMenu_configPresetFirstSoftstart);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SELECT], MenuText_ADMINPRESETCONFIGSELECTMENU[MENUTEXT_ENGLISH][2], RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART, repairMenu_configPresetFirstSoftstart);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SELECT], MenuText_ADMINPRESETCONFIGSELECTMENU[MENUTEXT_ENGLISH][3], RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART, repairMenu_configPresetFirstSoftstart);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SELECT], MenuText_ADMINPRESETCONFIGSELECTMENU[MENUTEXT_ENGLISH][4], RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART, repairMenu_configPresetFirstSoftstart);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SELECT], MenuText_ADMINPRESETCONFIGSELECTMENU[MENUTEXT_ENGLISH][5], RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART, repairMenu_configPresetFirstSoftstart);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SELECT], MenuText_ADMINPRESETCONFIGSELECTMENU[MENUTEXT_ENGLISH][6], RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART, repairMenu_configPresetFirstSoftstart);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SELECT], MenuText_ADMINPRESETCONFIGSELECTMENU[MENUTEXT_ENGLISH][7], RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART, repairMenu_configPresetFirstSoftstart);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SELECT], MenuText_ADMINPRESETCONFIGSELECTMENU[MENUTEXT_ENGLISH][8], RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART, repairMenu_configPresetFirstSoftstart);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SELECT], MenuText_ADMINPRESETCONFIGSELECTMENU[MENUTEXT_ENGLISH][9], RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART, repairMenu_configPresetFirstSoftstart);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SELECT], MenuText_ADMINPRESETCONFIGSELECTMENU[languageIndex][0], RM_ADMIN_PRESET_CONFIG_SELECT, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SELECT], MenuText_ADMINPRESETCONFIGSELECTMENU[languageIndex][1], RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART, repairMenu_configPresetFirstSoftstart);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SELECT], MenuText_ADMINPRESETCONFIGSELECTMENU[languageIndex][2], RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART, repairMenu_configPresetFirstSoftstart);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SELECT], MenuText_ADMINPRESETCONFIGSELECTMENU[languageIndex][3], RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART, repairMenu_configPresetFirstSoftstart);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SELECT], MenuText_ADMINPRESETCONFIGSELECTMENU[languageIndex][4], RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART, repairMenu_configPresetFirstSoftstart);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SELECT], MenuText_ADMINPRESETCONFIGSELECTMENU[languageIndex][5], RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART, repairMenu_configPresetFirstSoftstart);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SELECT], MenuText_ADMINPRESETCONFIGSELECTMENU[languageIndex][6], RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART, repairMenu_configPresetFirstSoftstart);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SELECT], MenuText_ADMINPRESETCONFIGSELECTMENU[languageIndex][7], RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART, repairMenu_configPresetFirstSoftstart);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SELECT], MenuText_ADMINPRESETCONFIGSELECTMENU[languageIndex][8], RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART, repairMenu_configPresetFirstSoftstart);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SELECT], MenuText_ADMINPRESETCONFIGSELECTMENU[languageIndex][9], RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART, repairMenu_configPresetFirstSoftstart);
MenuElements_addKeyAction_SCROLLUP(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SELECT], 'U', PRESSED);
MenuElements_addKeyAction_SCROLLDOWN(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SELECT], 'D', PRESSED);
MenuElements_addKeyAction_SELECT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SELECT], 'E', PRESSED);
@@ -2196,7 +2180,7 @@ void repairMenu_createMenuEntries(struct MenuCore* menuCore)
* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
*/
MenuElements_createMenuPage(&menuCore->menuArray[RM_ADMIN_INFO], MENU_HAS_NO_CURSOR, 5);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_INFO], MenuText_ADMININFOMENU[MENUTEXT_ENGLISH][0], RM_ADMIN_INFO, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_INFO], MenuText_ADMININFOMENU[languageIndex][0], RM_ADMIN_INFO, NULL);
MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_ADMIN_INFO], 'X', PRESSED, RM_ADMINMENU);
@@ -2228,8 +2212,8 @@ void repairMenu_createMenuEntries(struct MenuCore* menuCore)
MenuElements_createMenuPage(&menuCore->menuArray[RM_CALIBRATIONMENU], MENU_HAS_NO_CURSOR, 2);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_CALIBRATIONMENU], MenuText_CALIBRATIONMENU[MENUTEXT_ENGLISH][0], RM_CALIBRATIONMENU, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_CALIBRATIONMENU], MenuText_CALIBRATIONMENU[MENUTEXT_ENGLISH][1], RM_CALIBRATIONMENU, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_CALIBRATIONMENU], MenuText_CALIBRATIONMENU[languageIndex][0], RM_CALIBRATIONMENU, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_CALIBRATIONMENU], MenuText_CALIBRATIONMENU[languageIndex][1], RM_CALIBRATIONMENU, NULL);
MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_CALIBRATIONMENU], 'X', PRESSED, RM_MAINMENU);