private/hsb
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
e92304755cae28eca9108c55932fdc1f4c26df0f
hsb/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/repairMenu.c
mmi f3e4c109d1 Fixed some priorities for IRQs for stability 
Fixed ERROR/ERREUR messages position

git-svn-id: https://svn.vbchaos.nl/svn/hsb/trunk@403 05563f52-14a8-4384-a975-3d1654cca0fa
2017-12-15 13:03:39 +00:00

2282 lines
120 KiB
C
Raw Blame History

// -----------------------------------------------------------------------------
/// @file repairMenu.c
/// @brief Description
// -----------------------------------------------------------------------------
// Micro-Key bv
// Industrieweg 28, 9804 TG Noordhorn
// Postbus 92, 9800 AB Zuidhorn
// The Netherlands
// Tel: +31 594 503020
// Fax: +31 594 505825
// Email: support@microkey.nl
// Web: www.microkey.nl
// -----------------------------------------------------------------------------
/// $Revision$
/// $Author$
/// $Date$
// (c) 2017 Micro-Key bv
// -----------------------------------------------------------------------------
/// @file repairMenu.c
/// @ingroup {group_name}
// -----------------------------------------------------------------------------
// Include files
// -----------------------------------------------------------------------------
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "DeviceParameters.h"
#include "PIDParameters.h"
#include "PowerLossDetector.h"
#include "repairMenu.h"
#include "repairMenus.h"
#include "RepairPreset.h"
#include "repairProcess.h"
#include "repairProcesses.h"
#include "ADConverters.h"
#include "CathodeMCP.h"
#include "DAConverters.h"
#include "Display.h"
#include "Error.h"
#include "hsb-mrts.h"
#include "MenuCore.h"
#include "MenuElements.h"
#include "MenuText.h"
#include "CoverSolenoid.h"
#include "Leds.h"
#include "Logger.h"
#include "Interlock.h"
#include "internalADC.h"
#include "MAX5715.h"
#include "TeslaGunSafety.h"
#include "KeyboardDevice.h"
#include "PCBA.h"
#include "rtc.h"
#include "storm700.h"
#include "Version.h"
// -----------------------------------------------------------------------------
// Constant and macro definitions
// -----------------------------------------------------------------------------
#define MENU_HAS_CURSOR (true)
#define MENU_HAS_NO_CURSOR (false)
#define REPAIRMENU_POPUPSCREEN_TIME_MS (1000)
#define ENGLISH (0)
#define FRENCH (1)
#ifdef LANGUAGE
#if ((LANGUAGE >= MENUTEXT_NUMBER_OF_LANGUAGES) || (LANGUAGE < 0))
#error "LANGUAGE INDEX OUT OF BOUNDS";
#endif
#endif
// -----------------------------------------------------------------------------
// Type definitions
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
// File-scope variables
// -----------------------------------------------------------------------------
static int languageIndex = LANGUAGE;
// -----------------------------------------------------------------------------
// Function declarations
// -----------------------------------------------------------------------------
static void repairMenu_clearInsertString(struct MenuCore* self);
static void repairMenu_fillInsertStringWithValue(struct MenuCore* self, int value);
static int repairMenu_getValueFromInsertString(struct MenuCore* self);
static void repairMenu_printError(struct MenuCore* self);
static void repairMenu_printWarning(struct MenuCore* self);
static void repairMenu_printRepair(struct MenuCore* self);
static void repairMenu_printAskPause(struct MenuCore* self);
static void repairMenu_printPause(struct MenuCore* self);
static void repairMenu_printFinish(struct MenuCore* self);
static void repairMenu_printPreset(struct MenuCore* self);
static void repairMenu_printChangePinScreen(struct MenuCore* self);
static void repairMenu_printIOInterlockStatus(struct MenuCore* self);
static void repairMenu_prepareAdminPinVerification(struct MenuCore* self);
static void repairMenu_confirmAdminPin(struct MenuCore* self);
static void repairMenu_configPinChange(struct MenuCore* self);
static void repairMenu_configConfirmFirstPin(struct MenuCore* self);
static void repairMenu_configConfirmSecondPin(struct MenuCore* self);
static void repairMenu_configPresetFirstSoftstart(struct MenuCore* self);
static void repairMenu_configVoltageOutput(struct MenuCore* self);
static void repairMenu_configConfirmVoltageOutFirstRow(struct MenuCore* self);
static void repairMenu_configConfirmVoltageOutFirstRowGotoNext(struct MenuCore* self);
static void repairMenu_configConfirmVoltageOutSecondRow(struct MenuCore* self);
static void repairMenu_configConfirmVoltageOutSecondRowGotoPrevious(struct MenuCore* self);
static void repairMenu_configConfirmVoltageOutSecondRowGotoNext(struct MenuCore* self);
static void repairMenu_configConfirmVoltageOutThirdRow(struct MenuCore* self);
static void repairMenu_configConfirmVoltageOutThirdRowGotoPrevious(struct MenuCore* self);
static void repairMenu_configConfirmVoltageOutThirdRowGotoPrevious(struct MenuCore* self);
static void repairMenu_configConfirmPresetFirstSoftstart(struct MenuCore* self);
static void repairMenu_configConfirmPresetFirstDuration(struct MenuCore* self);
static void repairMenu_configConfirmPresetFirstVoltage(struct MenuCore* self);
static void repairMenu_configConfirmPresetSecondSoftstart(struct MenuCore* self);
static void repairMenu_configConfirmPresetSecondDuration(struct MenuCore* self);
static void repairMenu_configConfirmPresetSecondVoltage(struct MenuCore* self);
static void repairMenu_configConfirmPreset(struct MenuCore* self);
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_printPINVerification(struct MenuCore* self);
static void repairMenu_printVoltageOutput(struct MenuCore* self);
static void repairMenu_printPIDConstants(struct MenuCore* self);
static void repairMenu_printInfo(struct MenuCore* self);
static void repairMenu_confirmCalibrationPin(struct MenuCore* self);
static void repairMenu_selectCathodeRepair(struct MenuCore* self);
static void repairMenu_selectMCPRepair(struct MenuCore* self);
static void repairMenu_selectPreset(struct MenuCore* self);
static void repairMenu_solenoidLock(struct MenuCore* self);
static void repairMenu_solenoidUnlock(struct MenuCore* self);
static void repairMenu_teslagunRelease(struct MenuCore* self);
static void repairMenu_teslagunBlock(struct MenuCore* self);
static void repairMenu_startRepairProcess(struct MenuCore* self);
static void repairMenu_stopRepairProcess(struct MenuCore* self);
static void repairMenu_abortRepairProcessAndGotoMainMenu(struct MenuCore* self);
static void repairMenu_pauseRepairProcess(struct MenuCore* self);
static void repairMenu_continueRepairProcess(struct MenuCore* self);
static void repairMenu_gotoLastState(struct MenuCore* self);
// -----------------------------------------------------------------------------
// Function definitions
// -----------------------------------------------------------------------------
ErrorStatus repairMenu_construct(struct RepairMenu* self, struct MenuCore* menuCore, struct MemoryDevice* memoryDevice, Observer repairScreenUpdateObserver)
{
ErrorStatus returnValue = SUCCESS;
if (!self->initialized)
{
if (returnValue == SUCCESS)
{
if (menuCore->initialized)
{
self->menuCore = menuCore;
}
else
{
returnValue = ERROR;
}
}
if (returnValue == SUCCESS)
{
if (memoryDevice->initialized)
{
self->memoryDevice = memoryDevice;
self->presetStorage.initialized = false;
}
else
{
returnValue = ERROR;
}
}
if (returnValue == SUCCESS)
{
if (PCBA_getInstance()->pcba == PCBA_CathodeMCP)
{
// Loading of presets is done when selecting either Cathode or MCP repair
}
else if (PCBA_getInstance()->pcba == PCBA_Anode)
{
RepairPresets_loadPresets(REPAIR_PRESETS_ANODE);
self->repairPreset = RepairPresets_getPreset(1);
}
else if (PCBA_getInstance()->pcba == PCBA_Tesla)
{
RepairPresets_loadPresets(REPAIR_PRESETS_TESLA);
self->repairPreset = RepairPresets_getPreset(1);
}
MenuCore_changeState(self->menuCore, RM_MAINMENU);
vSemaphoreCreateBinary(self->repairScreenUpdateSemaphore);
self->observer = repairScreenUpdateObserver;
self->initialized = true;
}
}
else
{
returnValue = ERROR;
}
return returnValue;
}
void repairMenu_destruct (struct RepairMenu* self)
{
repairProcesses_abortMainRepairProcess();
self->initialized = false;
}
void repairMenu_interlockWarning(struct RepairMenu* self, T_INTERLOCK_ID interlockID)
{
self->menuCore->lastMenuState = RM_REPAIR_PAUSE;
MenuCore_changeState(self->menuCore, RM_WARNING_STATE);
if (interlockID == COMMON_INTERLOCK)
{
snprintf(self->menuCore->warningMessage, sizeof(self->menuCore->warningMessage) / sizeof(self->menuCore->warningMessage[0]), MenuText_WARNING_COVER_OPEN[languageIndex]);
}
}
void repairMenu_interlockFailed(struct RepairMenu* self, T_INTERLOCK_ID interlockID)
{
MenuCore_changeState(self->menuCore, RM_ERROR_STATE);
if (interlockID == COMMON_INTERLOCK)
{
snprintf(self->menuCore->errorMessage, sizeof(self->menuCore->errorMessage) / sizeof(self->menuCore->errorMessage[0]), MenuText_ERROR_COVER_OPEN[languageIndex]);
}
}
void repairMenu_powerLossDetected(struct RepairMenu* self)
{
MenuCore_changeState(self->menuCore, RM_ERROR_STATE);
snprintf(self->menuCore->errorMessage, sizeof(self->menuCore->errorMessage) / sizeof(self->menuCore->errorMessage[0]), MenuText_ERROR_POWER_LOSS[languageIndex]);
}
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]), MenuText_ERROR_PROCESS_FAILED[languageIndex]);
}
void repairMenu_printCRCFailure(struct RepairMenu* self, T_ErrorCode errorCode)
{
while (self->menuCore->menuState == RM_ERROR_STATE)
{
vTaskDelay(100);
}
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]), MenuText_ERROR_CRC_PIN[languageIndex]);
}
else if (errorCode == ERROR_CRC_PARAMETERS)
{
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]), MenuText_ERROR_CRC_PRESETS[languageIndex]);
}
}
static void repairMenu_clearInsertString(struct MenuCore* self)
{
self->insertString[0] = '\0';
}
static void repairMenu_fillInsertStringWithValue(struct MenuCore* self, int value)
{
snprintf(self->insertString, sizeof(self->insertString) / sizeof(self->insertString[0]), "%d", value);
}
static int repairMenu_getValueFromInsertString(struct MenuCore* self)
{
return atoi(self->insertString);
}
static void repairMenu_printError(struct MenuCore* self)
{
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_writeCentered(self->display, MenuText_WARNING[languageIndex], 1);
Display_writeCentered(self->display, self->warningMessage, 2);
Display_writeCentered(self->display, MenuText_X_CONTINUE[languageIndex], 4);
}
static void repairMenu_printRepair(struct MenuCore* self)
{
struct RepairMenu* repairMenu = repairMenus_getMainRepairMenu();
struct RepairProcess* repairProcess = repairProcesses_getMainRepairProcess();
if (repairProcess_isProcessRunning(repairProcess))
{
int loopCounter = 0;
char buffer[self->display->displayDevice->parameters.numberOfColumns + 1];
if (xSemaphoreTake(repairMenu->repairScreenUpdateSemaphore, 0) != pdTRUE)
{
// Taking semaphore failed - no update on the screen
}
else
{
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%1d", repairMenu->repairPreset->presetNumber);
Display_write(self->display, buffer, 1, 1);
struct Time totalTime;
RTC_calculateTimeFromSeconds(repairProcess_getTotalRepairtime(repairProcess), &totalTime);
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 %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
// For TESLA repair only row 1 (out of 0,1,2) is used
// For ANODE and Cathode/MCP, all 3 rows are used
for (loopCounter = ((PCBA_getInstance()->pcba == PCBA_Tesla) ? 1 : 0); loopCounter <= ((PCBA_getInstance()->pcba == PCBA_Tesla) ? 1 : 2); loopCounter++)
{
const struct RepairProcessRow* row;
row = repairProcess_getRowInformation(repairProcess, loopCounter);
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)
{
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5dV", row->lastADCValue);
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)));
}
else
{
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%*.*s", self->display->displayDevice->parameters.numberOfColumns / REPAIRPROCESS_NUMBER_OF_ROWS, self->display->displayDevice->parameters.numberOfColumns / REPAIRPROCESS_NUMBER_OF_ROWS, 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)));
}
}
}
}
else
{
Display_writeCentered(self->display, MenuText_REPAIR_SCREEN_INIT[languageIndex], 1);
}
}
static void repairMenu_printAskPause(struct MenuCore* self)
{
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_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_writeCentered(self->display, MenuText_FINISH[languageIndex][0], 2);
Display_writeCentered(self->display, MenuText_FINISH[languageIndex][1], 4);
}
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]), "%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]), "%s", MenuText_PRINT_PRESET[languageIndex][2]);
Display_write(self->display, buffer, 2, 1);
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]), "%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, 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, 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, MENUTEXT_PRESET_MAX_LENGTH + 1 + loopCounter * 7);
}
}
static void repairMenu_prepareAdminPinVerification(struct MenuCore* self)
{
// RESET the insert string before inserting the PIN
self->insertString[0] = '\0';
}
static void repairMenu_printChangePinScreen(struct MenuCore* self)
{
char pin[PIN_NUMBER_OF_DIGITS + 1];
Display_write(self->display, MenuText_CHANGE_PIN[languageIndex][0], 3, 1);
int numberOfDigits = strlen(self->insertString);
int loopcounter;
for (loopcounter = 0; loopcounter < PIN_NUMBER_OF_DIGITS; loopcounter++)
{
if (loopcounter < numberOfDigits)
{
pin[loopcounter] = '*';
}
else
{
pin[loopcounter] = '-';
}
}
pin[PIN_NUMBER_OF_DIGITS] = '\0';
if (self->menuState == RM_ADMIN_CHANGEPIN_FIRST_INSERT)
{
Display_write(self->display, pin, 3, MENUTEXT_CHANGEPIN_MAX_LENGTH);
}
else if (self->menuState == RM_ADMIN_CHANGEPIN_SECOND_INSERT)
{
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);
}
}
static void repairMenu_printIOInterlockStatus(struct MenuCore* self)
{
Display_writeCentered(self->display, MenuText_INTERLOCK_STATUS[languageIndex][0], 2);
if (Interlock_isClosed(interlock))
{
Display_writeCentered(self->display, MenuText_INTERLOCK_STATUS[languageIndex][1], 3);
}
else
{
Display_writeCentered(self->display, MenuText_INTERLOCK_STATUS[languageIndex][2], 3);
}
}
static void repairMenu_confirmAdminPin(struct MenuCore* self)
{
char pin[PIN_NUMBER_OF_DIGITS];
int loopcounter;
for (loopcounter = 0; loopcounter < PIN_NUMBER_OF_DIGITS; loopcounter++)
{
pin[loopcounter] = self->insertString[loopcounter] - 48;
}
if (PIN_isOK(DeviceParameters_getPIN(), pin))
{
Display_clearScreen(self->display);
Display_writeCentered(self->display, MenuText_CONFIRM_PIN[languageIndex][0], 3);
vTaskDelay(REPAIRMENU_POPUPSCREEN_TIME_MS);
MenuCore_changeState(self, RM_ADMINMENU);
}
else
{
Display_clearScreen(self->display);
Display_writeCentered(self->display, MenuText_CONFIRM_PIN[languageIndex][1], 3);
vTaskDelay(REPAIRMENU_POPUPSCREEN_TIME_MS);
MenuCore_changeState(self, RM_MAINMENU);
}
}
static void repairMenu_configPinChange(struct MenuCore* self)
{
repairMenu_clearInsertString(self);
}
static void repairMenu_configConfirmFirstPin(struct MenuCore* self)
{
char pin[PIN_NUMBER_OF_DIGITS];
int loopcounter;
for (loopcounter = 0; loopcounter < PIN_NUMBER_OF_DIGITS; loopcounter++)
{
pin[loopcounter] = self->insertString[loopcounter] - 48;
}
PIN_changePinFirstInsert(DeviceParameters_getPIN(), pin);
repairMenu_clearInsertString(self);
MenuCore_changeState(self, RM_ADMIN_CHANGEPIN_SECOND_INSERT);
}
static void repairMenu_configConfirmSecondPin(struct MenuCore* self)
{
char pin[PIN_NUMBER_OF_DIGITS];
int loopcounter;
for (loopcounter = 0; loopcounter < PIN_NUMBER_OF_DIGITS; loopcounter++)
{
pin[loopcounter] = self->insertString[loopcounter] - 48;
}
if (PIN_changePinSecondInsert(DeviceParameters_getPIN(), pin) == SUCCESS)
{
DeviceParameters_writePIN(DeviceParameters_getPIN());
DeviceParameters_saveParameters();
Display_clearScreen(self->display);
Display_writeCentered(self->display, MenuText_CONFIRM_NEW_PIN[languageIndex][0], 3);
}
else
{
Display_clearScreen(self->display);
Display_writeCentered(self->display, MenuText_CONFIRM_NEW_PIN[languageIndex][1], 3);
}
vTaskDelay(REPAIRMENU_POPUPSCREEN_TIME_MS);
MenuCore_changeState(self, RM_ADMINMENU);
}
static void repairMenu_configPresetFirstSoftstart(struct MenuCore* self)
{
repairMenu_clearInsertString(self);
repairMenu_fillInsertStringWithValue(self, RepairPresets_getPreset(self->selectionIndex)->preset[0].softstartDuration / 60);
}
static void repairMenu_configVoltageOutput(struct MenuCore* self)
{
repairMenu_clearInsertString(self);
// In case of CathodeMCP, the insert value must be negative
repairMenu_fillInsertStringWithValue(self, DAConverter_getCurrentValue(dacRow1));
}
static void repairMenu_configConfirmVoltageOutFirstRow(struct MenuCore* self)
{
DAConverter_setOutputVoltage(dacRow1, repairMenu_getValueFromInsertString(self));
}
static void repairMenu_configConfirmVoltageOutFirstRowGotoNext(struct MenuCore* self)
{
// Takeover the inserted value
repairMenu_configConfirmVoltageOutFirstRow(self);
// Goto next insertion state
MenuCore_changeState(self, RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL2);
// Receive next value for insertion
repairMenu_clearInsertString(self);
repairMenu_fillInsertStringWithValue(self, DAConverter_getCurrentValue(dacRow2));
}
static void repairMenu_configConfirmVoltageOutSecondRow(struct MenuCore* self)
{
DAConverter_setOutputVoltage(dacRow2, repairMenu_getValueFromInsertString(self));
}
static void repairMenu_configConfirmVoltageOutSecondRowGotoPrevious(struct MenuCore* self)
{
// Takeover the inserted value
repairMenu_configConfirmVoltageOutSecondRow(self);
// Goto next insertion state
MenuCore_changeState(self, RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL1);
// Receive next value for insertion
repairMenu_clearInsertString(self);
repairMenu_fillInsertStringWithValue(self, DAConverter_getCurrentValue(dacRow1));
}
static void repairMenu_configConfirmVoltageOutSecondRowGotoNext(struct MenuCore* self)
{
// Takeover the inserted value
repairMenu_configConfirmVoltageOutSecondRow(self);
// Goto next insertion state
MenuCore_changeState(self, RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL3);
// Receive next value for insertion
repairMenu_clearInsertString(self);
repairMenu_fillInsertStringWithValue(self, DAConverter_getCurrentValue(dacRow3));
}
static void repairMenu_configConfirmVoltageOutThirdRow(struct MenuCore* self)
{
DAConverter_setOutputVoltage(dacRow3, repairMenu_getValueFromInsertString(self));
}
static void repairMenu_configConfirmVoltageOutThirdRowGotoPrevious(struct MenuCore* self)
{
// Takeover the inserted value
repairMenu_configConfirmVoltageOutThirdRow(self);
// Goto next insertion state
MenuCore_changeState(self, RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL2);
// Receive next value for insertion
repairMenu_clearInsertString(self);
repairMenu_fillInsertStringWithValue(self, DAConverter_getCurrentValue(dacRow2));
}
static void repairMenu_configConfirmPresetFirstSoftstart(struct MenuCore* self)
{
// Takeover the inserted value
RepairPreset_setSoftstartValue(&RepairPresets_getPreset(self->selectionIndex)->preset[0], repairMenu_getValueFromInsertString(self) * 60);
// Goto next insertion state
MenuCore_changeState(self, RM_ADMIN_PRESET_CONFIG_FIRST_DURATION);
// Receive next value for insertion
repairMenu_clearInsertString(self);
repairMenu_fillInsertStringWithValue(self, RepairPresets_getPreset(self->selectionIndex)->preset[0].duration / 60);
}
static void repairMenu_configConfirmPresetFirstDuration(struct MenuCore* self)
{
// Takeover the inserted value
RepairPreset_setDurationValue(&RepairPresets_getPreset(self->selectionIndex)->preset[0], repairMenu_getValueFromInsertString(self) * 60);
// Goto next insertion state
MenuCore_changeState(self, RM_ADMIN_PRESET_CONFIG_FIRST_VOLTAGE);
// Receive next value for insertion
repairMenu_clearInsertString(self);
repairMenu_fillInsertStringWithValue(self, abs(RepairPresets_getPreset(self->selectionIndex)->preset[0].voltage));
}
static void repairMenu_configConfirmPresetFirstVoltage(struct MenuCore* self)
{
// Takeover the inserted value
if (PCBA_getInstance()->pcba == PCBA_CathodeMCP)
{
RepairPreset_setVoltageValue(&RepairPresets_getPreset(self->selectionIndex)->preset[0], repairMenu_getValueFromInsertString(self));
}
else
{
RepairPreset_setVoltageValue(&RepairPresets_getPreset(self->selectionIndex)->preset[0], repairMenu_getValueFromInsertString(self));
}
// Check if another Stage is available inside this preset
if (RepairPresets_getPreset(self->selectionIndex)->numberOfStages > 1)
{
// There is another stage
// Receive next value for insertion
repairMenu_clearInsertString(self);
repairMenu_fillInsertStringWithValue(self, RepairPresets_getPreset(self->selectionIndex)->preset[1].softstartDuration / 60);
MenuCore_changeState(self, RM_ADMIN_PRESET_CONFIG_SECOND_SOFTSTART);
}
else
{
// Just a single stage preset
repairMenu_configConfirmPreset(self);
Display_setBlinkingCursorState(self->display, OFF);
}
}
static void repairMenu_configConfirmPresetSecondSoftstart(struct MenuCore* self)
{
// Takeover the inserted value
RepairPreset_setSoftstartValue(&RepairPresets_getPreset(self->selectionIndex)->preset[1], repairMenu_getValueFromInsertString(self) * 60);
// Goto next insertion state
MenuCore_changeState(self, RM_ADMIN_PRESET_CONFIG_SECOND_DURATION);
// Receive next value for insertion
repairMenu_clearInsertString(self);
repairMenu_fillInsertStringWithValue(self, RepairPresets_getPreset(self->selectionIndex)->preset[1].duration / 60);
}
static void repairMenu_configConfirmPresetSecondDuration(struct MenuCore* self)
{
// Takeover the inserted value
RepairPreset_setDurationValue(&RepairPresets_getPreset(self->selectionIndex)->preset[1], repairMenu_getValueFromInsertString(self) * 60);
// Goto next insertion state
MenuCore_changeState(self, RM_ADMIN_PRESET_CONFIG_SECOND_VOLTAGE);
// Receive next value for insertion
repairMenu_clearInsertString(self);
repairMenu_fillInsertStringWithValue(self, RepairPresets_getPreset(self->selectionIndex)->preset[1].voltage);
}
static void repairMenu_configConfirmPresetSecondVoltage(struct MenuCore* self)
{
// Takeover the inserted value
RepairPreset_setVoltageValue(&RepairPresets_getPreset(self->selectionIndex)->preset[1], repairMenu_getValueFromInsertString(self));
// Goto next insertion state
// Check if another Stage is available inside this preset
if (RepairPresets_getPreset(self->selectionIndex)->numberOfStages > 2)
{
// There is another stage
// TODO - Currently only two-stage presets are implemented
}
else
{
// No more stages available
repairMenu_configConfirmPreset(self);
Display_setBlinkingCursorState(self->display, OFF);
}
}
static void repairMenu_configConfirmPreset(struct MenuCore* self)
{
RepairPresets_writePreset(RepairPresets_getPreset(self->selectionIndex));
RepairPresets_savePresets();
MenuCore_changeState(self, RM_ADMIN_PRESET_CONFIG_SELECT);
Display_clearScreen(self->display);
Display_writeCentered(self->display, MenuText_SAFE_PRESET[languageIndex], 3);
vTaskDelay(REPAIRMENU_POPUPSCREEN_TIME_MS);
}
static void repairMenu_configPID(struct MenuCore* self)
{
repairMenu_fillInsertStringWithValue(self, DeviceParameters_getPIDParameters()->Kp);
}
static void repairMenu_configConfirmPIDKp(struct MenuCore* self)
{
PIDParameters_setKp(DeviceParameters_getPIDParameters(), repairMenu_getValueFromInsertString(self));
// Goto next insertion state
MenuCore_changeState(self, RM_ADMIN_PID_CONFIG_KI);
// Receive next value for insertion
repairMenu_fillInsertStringWithValue(self, DeviceParameters_getPIDParameters()->Ki);
}
static void repairMenu_configConfirmPIDKi(struct MenuCore* self)
{
PIDParameters_setKi(DeviceParameters_getPIDParameters(), repairMenu_getValueFromInsertString(self));
// Goto next insertion state
MenuCore_changeState(self, RM_ADMIN_PID_CONFIG_KD);
// Receive next value for insertion
repairMenu_fillInsertStringWithValue(self, DeviceParameters_getPIDParameters()->Kd);
}
static void repairMenu_configConfirmPIDKd(struct MenuCore* self)
{
PIDParameters_setKd(DeviceParameters_getPIDParameters(), repairMenu_getValueFromInsertString(self));
// Write inserted values to FLASH
DeviceParameters_writePIDParameters(DeviceParameters_getPIDParameters());
DeviceParameters_saveParameters();
// Go back next admin menu
MenuCore_changeState(self, RM_ADMINMENU);
Display_clearScreen(self->display);
Display_writeCentered(self->display, MenuText_SAFE_CONSTANTS[languageIndex], 3);
vTaskDelay(REPAIRMENU_POPUPSCREEN_TIME_MS);
}
static void repairMenu_printAdminVoltageInput(struct MenuCore* self)
{
char buffer[self->display->displayDevice->parameters.numberOfColumns + 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]), "%*.*s1: %5dV|%4Xx", sizeof(MenuText_VOLTAGE_ROW[languageIndex]), sizeof(MenuText_VOLTAGE_ROW[languageIndex]), MenuText_VOLTAGE_ROW[languageIndex], ADConverter_getInputVoltage(adcRow1), ADConverter_getInputConverterValue(adcRow1));
Display_write(self->display, buffer, 2, 1);
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%*.*s3: %5dV|%4Xx", sizeof(MenuText_VOLTAGE_ROW[languageIndex]), sizeof(MenuText_VOLTAGE_ROW[languageIndex]), MenuText_VOLTAGE_ROW[languageIndex], ADConverter_getInputVoltage(adcRow3), ADConverter_getInputConverterValue(adcRow3));
Display_write(self->display, buffer, 4, 1);
}
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%*.*s2: %5dV|%4Xx", sizeof(MenuText_VOLTAGE_ROW[languageIndex]), sizeof(MenuText_VOLTAGE_ROW[languageIndex]), MenuText_VOLTAGE_ROW[languageIndex], ADConverter_getInputVoltage(adcRow2), ADConverter_getInputConverterValue(adcRow2));
Display_write(self->display, buffer, 3, 1);
}
static void repairMenu_printPINVerification(struct MenuCore* self)
{
char buffer[PIN_NUMBER_OF_DIGITS + 1];
Display_writeCentered(self->display, MenuText_INSERT_PIN[languageIndex], 3);
int numberOfDigits = strlen(self->insertString);
int loopcounter;
for (loopcounter = 0; loopcounter < PIN_NUMBER_OF_DIGITS; loopcounter++)
{
if (loopcounter < numberOfDigits)
{
buffer[loopcounter] = '*';
}
else
{
buffer[loopcounter] = '-';
}
}
buffer[PIN_NUMBER_OF_DIGITS] = '\0';
Display_writeCentered(self->display, buffer, 4);
}
static void repairMenu_printVoltageOutput(struct MenuCore* self)
{
char buffer[self->display->displayDevice->parameters.numberOfColumns + 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]), "%*.*s1:%5dV|%5dV", sizeof(MenuText_VOLTAGE_ROW[languageIndex]), sizeof(MenuText_VOLTAGE_ROW[languageIndex]), 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]), "%*.*s3:%5dV|%5dV", sizeof(MenuText_VOLTAGE_ROW[languageIndex]), sizeof(MenuText_VOLTAGE_ROW[languageIndex]), 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]), "%*.*s2:%5dV|%5dV", sizeof(MenuText_VOLTAGE_ROW[languageIndex]), sizeof(MenuText_VOLTAGE_ROW[languageIndex]), MenuText_VOLTAGE_ROW[languageIndex], (unsigned int)DAConverter_getCurrentValue(dacRow2), ADConverter_getInputVoltage(adcRow2));
Display_write(self->display, buffer, 3, 1);
}
static void repairMenu_printPIDConstants(struct MenuCore* self)
{
char buffer[self->display->displayDevice->parameters.numberOfColumns];
// Always print Row1 (index0), ignoring the scrolling index
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);
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "Ki: %5d", DeviceParameters_getPIDParameters()->Ki);
Display_write(self->display, buffer, 3, 1);
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "Kd: %5d", DeviceParameters_getPIDParameters()->Kd);
Display_write(self->display, buffer, 4, 1);
}
static void repairMenu_printInfo(struct MenuCore* self)
{
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_writeCentered(mainDisplay, buffer, 4);
}
static void repairMenu_confirmCalibrationPin(struct MenuCore* self)
{
char pin[PIN_NUMBER_OF_DIGITS];
int loopcounter;
for (loopcounter = 0; loopcounter < PIN_NUMBER_OF_DIGITS; loopcounter++)
{
pin[loopcounter] = self->insertString[loopcounter] - 48;
}
if (PIN_isOK(DeviceParameters_getPIN(), pin))
{
Display_clearScreen(self->display);
Display_writeCentered(self->display, MenuText_CONFIRM_PIN[languageIndex][0], 3);
vTaskDelay(REPAIRMENU_POPUPSCREEN_TIME_MS);
if (PCBA_getInstance()->pcba == PCBA_CathodeMCP)
{
MenuCore_changeState(self, RM_CALIBRATIONMENU);
}
else
{
MenuCore_changeState(self, RM_CALIBRATIONMENU);
}
}
else
{
Display_clearScreen(self->display);
Display_writeCentered(self->display, MenuText_CONFIRM_PIN[languageIndex][1], 3);
vTaskDelay(REPAIRMENU_POPUPSCREEN_TIME_MS);
MenuCore_changeState(self, RM_MAINMENU);
}
}
static void repairMenu_selectCathodeRepair(struct MenuCore* self)
{
RepairPresets_loadPresets(REPAIR_PRESETS_CATHODE);
struct RepairMenu* tempMenu = repairMenus_getMainRepairMenu();
tempMenu->repairPreset = RepairPresets_getPreset(1);
CathodeMCP_switchToCathode();
}
static void repairMenu_selectMCPRepair(struct MenuCore* self)
{
RepairPresets_loadPresets(REPAIR_PRESETS_MCP);
struct RepairMenu* tempMenu = repairMenus_getMainRepairMenu();
tempMenu->repairPreset = RepairPresets_getPreset(1);
CathodeMCP_switchToMCP();
}
static void repairMenu_selectPreset(struct MenuCore* self)
{
struct RepairMenu* tempMenu = repairMenus_getMainRepairMenu();
tempMenu->repairPreset = RepairPresets_getPreset(self->selectionIndex);
Display_clearScreen(self->display);
char buffer[20];
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);
}
static void repairMenu_solenoidLock(struct MenuCore* self)
{
CoverSolenoid_lock();
}
static void repairMenu_solenoidUnlock(struct MenuCore* self)
{
CoverSolenoid_unlock();
}
static void repairMenu_teslagunRelease(struct MenuCore* self)
{
TeslaGunSafety_release();
}
static void repairMenu_teslagunBlock(struct MenuCore* self)
{
TeslaGunSafety_block();
}
static void repairMenu_startRepairProcess(struct MenuCore* self)
{
ErrorStatus returnValue = SUCCESS;
struct RepairMenu* repairMenu = repairMenus_getMainRepairMenu();
repairMenu->rpParameters.adcR1 = adcRow1;
repairMenu->rpParameters.adcR2 = adcRow2;
repairMenu->rpParameters.adcR3 = adcRow3;
repairMenu->rpParameters.dacR1 = dacRow1;
repairMenu->rpParameters.dacR2 = dacRow2;
repairMenu->rpParameters.dacR3 = dacRow3;
if (returnValue == SUCCESS)
{
// Enable all safety features of the HSB setup
returnValue = hsb_enableSafetyWithError();
}
// If all is OK, start the repair process
if (returnValue == SUCCESS)
{
returnValue = repairProcesses_startMainRepairProcess(repairMenu->repairPreset, &repairMenu->rpParameters);
if (returnValue != SUCCESS)
{
Error_postError(REPAIR_FAIL);
}
}
if (returnValue == SUCCESS)
{
returnValue = repairProcesses_mainRepairProcessAddObserver(repairMenu->observer);
if (returnValue == SUCCESS)
{
// repair process is running
MenuCore_changeState(self, RM_REPAIR_RUNNING);
// Set Flag in FLASH
PowerLossDetector_setBusyFlag();
}
else
{
Error_postError(REPAIR_FAIL);
}
}
}
static void repairMenu_stopRepairProcess(struct MenuCore* self)
{
struct RepairMenu* tempMenu = repairMenus_getMainRepairMenu();
repairProcesses_mainRepairProcessRemoveObserver(tempMenu->observer);
repairProcesses_abortMainRepairProcess();
hsb_disableSafety();
}
static void repairMenu_abortRepairProcessAndGotoMainMenu(struct MenuCore* self)
{
repairMenu_stopRepairProcess(self);
MenuCore_changeState(self, RM_MAINMENU);
PowerLossDetector_clearBusyFlag();
}
static void repairMenu_pauseRepairProcess(struct MenuCore* self)
{
MenuCore_changeState(self, RM_REPAIR_PAUSE);
repairProcess_pauseProcess(repairProcesses_getMainRepairProcess());
hsb_disableSafety();
}
static void repairMenu_continueRepairProcess(struct MenuCore* self)
{
hsb_enableSafetyWithWarning();
MenuCore_changeState(self, RM_REPAIR_RUNNING);
repairProcess_continueProcess(repairProcesses_getMainRepairProcess());
}
static void repairMenu_gotoLastState(struct MenuCore* self)
{
MenuCore_changeState(self, self->lastMenuState);
}
void repairMenu_menuStateHandle(struct MenuCore* self)
{
// Stop the buzzer from recovered error or warning
if (self->lastMenuState == RM_ERROR_STATE)
{
if (self->menuState != RM_ERROR_STATE)
{
Buzzer_stop(self->buzzer);
Led_off(LED_BICOLOR_RED);
}
}
// Stop the buzzer from recovered error or warning
if (self->lastMenuState == RM_WARNING_STATE)
{
if (self->menuState != RM_WARNING_STATE)
{
Buzzer_stop(self->buzzer);
Led_off(LED_BICOLOR_ORANGE);
}
}
// Catch ERROR state
if (self->menuState == RM_ERROR_STATE)
{
self->lastMenuState = self->menuState;
// Show ERROR message
repairMenu_printError(self);
Led_on(LED_BICOLOR_RED);
// Handle error
if (hsb_safetyIsEnabled())
{
repairMenu_stopRepairProcess(self);
}
}
else if (self->menuState == RM_WARNING_STATE)
{
self->lastMenuState = self->menuState;
repairMenu_printWarning(self);
Led_on(LED_BICOLOR_ORANGE);
}
else if (self->menuState == RM_PRESET_PRINT)
{
repairMenu_printPreset(self);
}
else if (self->menuState == RM_REPAIR_RUNNING)
{
// Check the remaining repair time
uint32_t remainingTime = repairProcess_getRemainingRepairTime(repairProcesses_getMainRepairProcess());
Led_on(LED_BICOLOR_GREEN);
if (remainingTime > (2 * REPAIRMENU_POPUPSCREEN_TIME_MS / 1000))
{
self->popUpCounter = remainingTime - (2 * REPAIRMENU_POPUPSCREEN_TIME_MS / 1000);
self->lastMenuState = self->menuState;
}
if (remainingTime == 0)
{
// repair is finished
MenuCore_changeState(self, RM_FINISH_CONTROL);
}
else
{
// Create the repair screen
repairMenu_printRepair(self);
}
}
else if (self->menuState == RM_REPAIR_ASK_PAUSE)
{
uint32_t remainingTime = repairProcess_getRemainingRepairTime(repairProcesses_getMainRepairProcess());
repairMenu_printAskPause(self);
if (self->popUpCounter >= remainingTime)
{
// POPUP screen time is over, return to previous state
MenuCore_changeState(self, self->lastMenuState);
}
}
else if (self->menuState == RM_REPAIR_PAUSE)
{
repairMenu_printPause(self);
Led_off(LED_BICOLOR_GREEN);
}
else if (self->menuState == RM_FINISH_CONTROL)
{
repairMenu_stopRepairProcess(self);
PowerLossDetector_clearBusyFlag();
MenuCore_changeState(self, RM_FINISH);
}
else if (self->menuState == RM_FINISH)
{
repairMenu_printFinish(self);
Led_off(LED_BICOLOR_GREEN);
}
else if (self->menuState == RM_ADMINMENU_PIN_VERIFICATION)
{
repairMenu_printPINVerification(self);
}
else if (self->menuState == RM_ADMIN_IO_INTERLOCK)
{
// Show the current INTERLOCK status
repairMenu_printIOInterlockStatus(self);
}
else if(self->menuState == RM_ADMIN_IO_VOLTAGE_IN)
{
repairMenu_printAdminVoltageInput(self);
}
else if (self->menuState == RM_ADMIN_INFO)
{
repairMenu_printInfo(self);
}
else if (self->menuState == RM_ADMIN_CHANGEPIN_FIRST_INSERT)
{
repairMenu_printChangePinScreen(self);
}
else if (self->menuState == RM_ADMIN_CHANGEPIN_SECOND_INSERT)
{
repairMenu_printChangePinScreen(self);
}
else if (self->menuState == RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART)
{
repairMenu_printPreset(self);
char buffer[7];
// Remove leading 0 from string if necessary
if ((self->insertString[0] == '0') && (strlen(self->insertString) > 1))
{
int loopcounter;
for (loopcounter = 0; loopcounter < strlen(self->insertString); loopcounter++)
{
self->insertString[loopcounter] = self->insertString[loopcounter + 1];
}
}
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5sm", self->insertString);
Display_write(self->display, buffer, 2, MENUTEXT_PRESET_MAX_LENGTH + 1);
vTaskDelay(2);
Display_setCursorToPosition(self->display, 2, MENUTEXT_PRESET_MAX_LENGTH + 5);
vTaskDelay(2);
Display_setBlinkingCursorState(self->display, ON);
}
else if (self->menuState == RM_ADMIN_PRESET_CONFIG_FIRST_DURATION)
{
repairMenu_printPreset(self);
char buffer[7];
// Remove leading 0 from string if necessary
if ((self->insertString[0] == '0') && (strlen(self->insertString) > 1))
{
int loopcounter;
for (loopcounter = 0; loopcounter < strlen(self->insertString); loopcounter++)
{
self->insertString[loopcounter] = self->insertString[loopcounter + 1];
}
}
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5sm", self->insertString);
Display_write(self->display, buffer, 3, MENUTEXT_PRESET_MAX_LENGTH + 1);
vTaskDelay(2);
Display_setCursorToPosition(self->display, 3, MENUTEXT_PRESET_MAX_LENGTH + 5);
vTaskDelay(2);
Display_setBlinkingCursorState(self->display, ON);
}
else if (self->menuState == RM_ADMIN_PRESET_CONFIG_FIRST_VOLTAGE)
{
repairMenu_printPreset(self);
char buffer[7];
// Remove leading 0 from string if necessary
if ((self->insertString[0] == '0') && (strlen(self->insertString) > 1))
{
int loopcounter;
for (loopcounter = 0; loopcounter < strlen(self->insertString); loopcounter++)
{
self->insertString[loopcounter] = self->insertString[loopcounter + 1];
}
}
if (PCBA_getInstance()->pcba == PCBA_CathodeMCP)
{
if (atoi(self->insertString) > 0)
{
int loopcounter;
for (loopcounter = strlen(self->insertString); loopcounter >= 0; loopcounter--)
{
self->insertString[loopcounter + 1] = self->insertString[loopcounter];
}
self->insertString[0] = '-';
}
}
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5s", self->insertString);
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_printPreset(self);
char buffer[7];
// Remove leading 0 from string if necessary
if ((self->insertString[0] == '0') && (strlen(self->insertString) > 1))
{
int loopcounter;
for (loopcounter = 0; loopcounter < strlen(self->insertString); loopcounter++)
{
self->insertString[loopcounter] = self->insertString[loopcounter + 1];
}
}
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5s", self->insertString);
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_printPreset(self);
char buffer[7];
// Remove leading 0 from string if necessary
if ((self->insertString[0] == '0') && (strlen(self->insertString) > 1))
{
int loopcounter;
for (loopcounter = 0; loopcounter < strlen(self->insertString); loopcounter++)
{
self->insertString[loopcounter] = self->insertString[loopcounter + 1];
}
}
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5s", self->insertString);
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_printPreset(self);
char buffer[7];
// Remove leading 0 from string if necessary
if ((self->insertString[0] == '0') && (strlen(self->insertString) > 1))
{
int loopcounter;
for (loopcounter = 0; loopcounter < strlen(self->insertString); loopcounter++)
{
self->insertString[loopcounter] = self->insertString[loopcounter + 1];
}
}
if (PCBA_getInstance()->pcba == PCBA_CathodeMCP)
{
if (atoi(self->insertString) > 0)
{
LOGGER_DEBUG(mainLog, "%s", self->insertString);
int loopcounter;
for (loopcounter = strlen(self->insertString); loopcounter >= 0; loopcounter--)
{
self->insertString[loopcounter + 1] = self->insertString[loopcounter];
}
self->insertString[0] = '-';
LOGGER_DEBUG(mainLog, "%s", self->insertString);
}
}
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5s", self->insertString);
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);
}
else if (self->menuState == RM_ADMIN_PID_CONFIG_KP)
{
repairMenu_printPIDConstants(self);
char buffer[7];
// Remove leading 0 from string if necessary
if ((self->insertString[0] == '0') && (strlen(self->insertString) > 1))
{
int loopcounter;
for (loopcounter = 0; loopcounter < strlen(self->insertString); loopcounter++)
{
self->insertString[loopcounter] = self->insertString[loopcounter + 1];
}
}
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)
{
repairMenu_printPIDConstants(self);
char buffer[7];
// Remove leading 0 from string if necessary
if ((self->insertString[0] == '0') && (strlen(self->insertString) > 1))
{
int loopcounter;
for (loopcounter = 0; loopcounter < strlen(self->insertString); loopcounter++)
{
self->insertString[loopcounter] = self->insertString[loopcounter + 1];
}
}
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)
{
repairMenu_printPIDConstants(self);
char buffer[7];
// Remove leading 0 from string if necessary
if ((self->insertString[0] == '0') && (strlen(self->insertString) > 1))
{
int loopcounter;
for (loopcounter = 0; loopcounter < strlen(self->insertString); loopcounter++)
{
self->insertString[loopcounter] = self->insertString[loopcounter + 1];
}
}
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)
{
repairMenu_printPINVerification(self);
}
else if (self->menuState == RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL1)
{
repairMenu_printVoltageOutput(self);
char buffer[7];
// Remove leading 0 from string if necessary
if ((self->insertString[0] == '0') && (strlen(self->insertString) > 1))
{
int loopcounter;
for (loopcounter = 0; loopcounter < strlen(self->insertString); loopcounter++)
{
self->insertString[loopcounter] = self->insertString[loopcounter + 1];
}
}
if (PCBA_getInstance()->pcba == PCBA_CathodeMCP)
{
if (atoi(self->insertString) > 0)
{
int loopcounter;
for (loopcounter = strlen(self->insertString); loopcounter >= 0; loopcounter--)
{
self->insertString[loopcounter + 1] = self->insertString[loopcounter];
}
self->insertString[0] = '-';
}
}
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5sV", self->insertString);
Display_write(self->display, buffer, 2, sizeof(MenuText_VOLTAGE_ROW[languageIndex]) + 3);
vTaskDelay(2);
Display_setCursorToPosition(self->display, 2, 12);
vTaskDelay(2);
Display_setBlinkingCursorState(self->display, ON);
}
else if (self->menuState == RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL2)
{
repairMenu_printVoltageOutput(self);
char buffer[7];
// Remove leading 0 from string if necessary
if ((self->insertString[0] == '0') && (strlen(self->insertString) > 1))
{
int loopcounter;
for (loopcounter = 0; loopcounter < strlen(self->insertString); loopcounter++)
{
self->insertString[loopcounter] = self->insertString[loopcounter + 1];
}
}
if (PCBA_getInstance()->pcba == PCBA_CathodeMCP)
{
if (atoi(self->insertString) > 0)
{
int loopcounter;
for (loopcounter = strlen(self->insertString); loopcounter >= 0; loopcounter--)
{
self->insertString[loopcounter + 1] = self->insertString[loopcounter];
}
self->insertString[0] = '-';
}
}
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5sV", self->insertString);
Display_write(self->display, buffer, 3, sizeof(MenuText_VOLTAGE_ROW[languageIndex]) + 3);
vTaskDelay(2);
Display_setCursorToPosition(self->display, 3, 12);
vTaskDelay(2);
Display_setBlinkingCursorState(self->display, ON);
}
else if (self->menuState == RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL3)
{
repairMenu_printVoltageOutput(self);
char buffer[7];
// Remove leading 0 from string if necessary
if ((self->insertString[0] == '0') && (strlen(self->insertString) > 1))
{
int loopcounter;
for (loopcounter = 0; loopcounter < strlen(self->insertString); loopcounter++)
{
self->insertString[loopcounter] = self->insertString[loopcounter + 1];
}
}
if (PCBA_getInstance()->pcba == PCBA_CathodeMCP)
{
if (atoi(self->insertString) > 0)
{
int loopcounter;
for (loopcounter = strlen(self->insertString); loopcounter >= 0; loopcounter--)
{
self->insertString[loopcounter + 1] = self->insertString[loopcounter];
}
self->insertString[0] = '-';
}
}
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5sV", self->insertString);
Display_write(self->display, buffer, 4, sizeof(MenuText_VOLTAGE_ROW[languageIndex]) + 3);
vTaskDelay(2);
Display_setCursorToPosition(self->display, 4, 12);
vTaskDelay(2);
Display_setBlinkingCursorState(self->display, ON);
}
else if (self->menuState == RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CLEANUP)
{
// RESET all DACs to 0
DAConverter_setOutputVoltage(dacRow1, 0);
DAConverter_setOutputVoltage(dacRow2, 0);
DAConverter_setOutputVoltage(dacRow3, 0);
Display_writeCentered(self->display, MenuText_VOLTAGE_OUT_CLEANUP[languageIndex][0], 3);
Display_writeCentered(self->display, MenuText_VOLTAGE_OUT_CLEANUP[languageIndex][1], 4);
}
}
void repairMenu_createMenuEntries(struct MenuCore* menuCore)
{
int numberOfDigits;
/* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
* MAIN MENU SCREEN with 3 options
* TUBE REPAIR
* for Tesla and Anode, go to repair menu directly
* for CathodeMCP, ask for type of repair first
* ADMINISTRATION
* CALIBRATION
*
* Key '0' allows control of the Solenoids - Hold to open, release to close
* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
*/
MenuElements_createMenuPage(&menuCore->menuArray[RM_MAINMENU], MENU_HAS_CURSOR, 4);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_MAINMENU], PCBA_getInstance()->name, RM_MAINMENU, NULL);
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[languageIndex][1], RM_REPAIR_CATHODEMCP_SELECT, NULL);
}
else
{
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_MAINMENU], MenuText_MAINMENU[languageIndex][1], RM_REPAIRMENU, NULL);
}
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);
MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_MAINMENU], '1', PRESSED, 1);
MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_MAINMENU], '2', PRESSED, 2);
MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_MAINMENU], '3', PRESSED, 3);
MenuElements_addKeyAction_EXECUTEFUNCTION(&menuCore->menuArray[RM_MAINMENU], '0', PRESSED, repairMenu_solenoidUnlock);
MenuElements_addKeyAction_EXECUTEFUNCTION(&menuCore->menuArray[RM_MAINMENU], '0', RELEASED, repairMenu_solenoidLock);
/* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
* Cathode / MCP selection
* This screen is only required for CATHODE/MCP PCBAs and allows selection between these two repair methods
*
* Key '0' allows control of the Solenoids - Hold to open, release to close
* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
*/
MenuElements_createMenuPage(&menuCore->menuArray[RM_REPAIR_CATHODEMCP_SELECT], MENU_HAS_CURSOR, 3);
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);
MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_REPAIR_CATHODEMCP_SELECT], '1', PRESSED, 1);
MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_REPAIR_CATHODEMCP_SELECT], '2', PRESSED, 2);
MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_REPAIR_CATHODEMCP_SELECT], 'X', PRESSED, RM_MAINMENU);
MenuElements_addKeyAction_EXECUTEFUNCTION(&menuCore->menuArray[RM_REPAIR_CATHODEMCP_SELECT], '0', PRESSED, repairMenu_solenoidUnlock);
MenuElements_addKeyAction_EXECUTEFUNCTION(&menuCore->menuArray[RM_REPAIR_CATHODEMCP_SELECT], '0', RELEASED, repairMenu_solenoidLock);
/* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
* REPAIR MENU
* This screen is the main repair screen
* SELECT PRESET
* START REPAIR
*
* Key '0' allows control of the Solenoids - Hold to open, release to close
* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
*/
MenuElements_createMenuPage(&menuCore->menuArray[RM_REPAIRMENU], MENU_HAS_CURSOR, 4);
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);
MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_REPAIRMENU], '1', PRESSED, 1);
MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_REPAIRMENU], '2', PRESSED, 2);
if (PCBA_getInstance()->pcba == PCBA_CathodeMCP)
{
// For Cathode/MCP PCBA, the type of repair must can be selected
MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_REPAIRMENU], 'X', PRESSED, RM_REPAIR_CATHODEMCP_SELECT);
}
else
{
MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_REPAIRMENU], 'X', PRESSED, RM_MAINMENU);
}
MenuElements_addKeyAction_EXECUTEFUNCTION(&menuCore->menuArray[RM_REPAIRMENU], '0', PRESSED, repairMenu_solenoidUnlock);
MenuElements_addKeyAction_EXECUTEFUNCTION(&menuCore->menuArray[RM_REPAIRMENU], '0', RELEASED, repairMenu_solenoidLock);
/* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
* PRESET SELECTION
* Select the repair preset
* Key 'R' shows preset information
*
* Key '0' allows control of the Solenoids - Hold to open, release to close
* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
*/
MenuElements_createMenuPage(&menuCore->menuArray[RM_PRESETMENU], MENU_HAS_CURSOR, 10);
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);
MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_PRESETMENU], '1', PRESSED, 1);
MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_PRESETMENU], '2', PRESSED, 2);
MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_PRESETMENU], '3', PRESSED, 3);
MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_PRESETMENU], '4', PRESSED, 4);
MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_PRESETMENU], '5', PRESSED, 5);
MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_PRESETMENU], '6', PRESSED, 6);
MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_PRESETMENU], '7', PRESSED, 7);
MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_PRESETMENU], '8', PRESSED, 8);
MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_PRESETMENU], '9', PRESSED, 9);
MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_PRESETMENU], 'X', PRESSED, RM_REPAIRMENU);
MenuElements_addKeyAction_EXECUTEFUNCTION(&menuCore->menuArray[RM_PRESETMENU], '0', PRESSED, repairMenu_solenoidUnlock);
MenuElements_addKeyAction_EXECUTEFUNCTION(&menuCore->menuArray[RM_PRESETMENU], '0', RELEASED, repairMenu_solenoidLock);
MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_PRESETMENU], 'R', PRESSED, RM_PRESET_PRINT);
/* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
* PRESET INFORMATION
* Shows the preset information. Screen is generated via function, not as a menu
* Key 'L' and 'X' both leads back to preset selection.
* Showing information does not select the preset
*
* Key '0' allows control of the Solenoids - Hold to open, release to close
* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
*/
MenuElements_createMenuPage(&menuCore->menuArray[RM_PRESET_PRINT], MENU_HAS_NO_CURSOR, 4);
MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_PRESET_PRINT], 'X', PRESSED, RM_PRESETMENU);
MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_PRESET_PRINT], 'L', PRESSED, RM_PRESETMENU);
/* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
* ADMIN PIN VERIFICATION
* This screen is designed in a dedicated function
*
* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
*/
numberOfDigits = PIN_NUMBER_OF_DIGITS;
MenuElements_createMenuPage(&menuCore->menuArray[RM_ADMINMENU_PIN_VERIFICATION], MENU_HAS_NO_CURSOR, 10);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMINMENU_PIN_VERIFICATION], '0', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMINMENU_PIN_VERIFICATION], '1', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMINMENU_PIN_VERIFICATION], '2', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMINMENU_PIN_VERIFICATION], '3', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMINMENU_PIN_VERIFICATION], '4', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMINMENU_PIN_VERIFICATION], '5', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMINMENU_PIN_VERIFICATION], '6', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMINMENU_PIN_VERIFICATION], '7', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMINMENU_PIN_VERIFICATION], '8', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMINMENU_PIN_VERIFICATION], '9', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITREMOVE(&menuCore->menuArray[RM_ADMINMENU_PIN_VERIFICATION], 'L', PRESSED);
MenuElements_addKeyAction_DIGITINSERTCONFIRM(&menuCore->menuArray[RM_ADMINMENU_PIN_VERIFICATION], 'E', PRESSED, repairMenu_confirmAdminPin);
MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_ADMINMENU_PIN_VERIFICATION], 'X', PRESSED, RM_MAINMENU);
/* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
* ADMIN Cathode / MCP selection
* This screen is only required for CATHODE/MCP PCBAs and allows selection between these two repair methods
*
* Key '0' allows control of the Solenoids - Hold to open, release to close
* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
*/
MenuElements_createMenuPage(&menuCore->menuArray[RM_ADMIN_CATHODEMCP_SELECT], MENU_HAS_CURSOR, 3);
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);
MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_ADMIN_CATHODEMCP_SELECT], '1', PRESSED, 1);
MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_ADMIN_CATHODEMCP_SELECT], '2', PRESSED, 2);
MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_ADMIN_CATHODEMCP_SELECT], 'X', PRESSED, RM_ADMINMENU);
/* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
* ADMINISTRATION MAIN MENU
* All administrational functionality is concentrated in this menu. Allows access to:
* Change pin
* I/O control
* PRESET configuration
* Info & Version
* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
*/
MenuElements_createMenuPage(&menuCore->menuArray[RM_ADMINMENU], MENU_HAS_CURSOR, 6);
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[languageIndex][3], RM_ADMIN_CATHODEMCP_SELECT, NULL);
}
else
{
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMINMENU], MenuText_ADMINMENU[languageIndex][3], RM_ADMIN_PRESET_CONFIG_SELECT, 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);
MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_ADMINMENU], 'X', PRESSED, RM_MAINMENU);
MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_ADMINMENU], '1', PRESSED, 1);
MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_ADMINMENU], '2', PRESSED, 2);
MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_ADMINMENU], '3', PRESSED, 3);
MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_ADMINMENU], '4', PRESSED, 4);
MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_ADMINMENU], '5', PRESSED, 5);
/* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
* ADMIN change pin
* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
*/
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[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);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_CHANGEPIN_FIRST_INSERT], '2', PRESSED, 4);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_CHANGEPIN_FIRST_INSERT], '3', PRESSED, 4);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_CHANGEPIN_FIRST_INSERT], '4', PRESSED, 4);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_CHANGEPIN_FIRST_INSERT], '5', PRESSED, 4);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_CHANGEPIN_FIRST_INSERT], '6', PRESSED, 4);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_CHANGEPIN_FIRST_INSERT], '7', PRESSED, 4);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_CHANGEPIN_FIRST_INSERT], '8', PRESSED, 4);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_CHANGEPIN_FIRST_INSERT], '9', PRESSED, 4);
MenuElements_addKeyAction_DIGITREMOVE(&menuCore->menuArray[RM_ADMIN_CHANGEPIN_FIRST_INSERT], 'L', PRESSED);
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[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);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_CHANGEPIN_SECOND_INSERT], '2', PRESSED, 4);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_CHANGEPIN_SECOND_INSERT], '3', PRESSED, 4);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_CHANGEPIN_SECOND_INSERT], '4', PRESSED, 4);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_CHANGEPIN_SECOND_INSERT], '5', PRESSED, 4);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_CHANGEPIN_SECOND_INSERT], '6', PRESSED, 4);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_CHANGEPIN_SECOND_INSERT], '7', PRESSED, 4);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_CHANGEPIN_SECOND_INSERT], '8', PRESSED, 4);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_CHANGEPIN_SECOND_INSERT], '9', PRESSED, 4);
MenuElements_addKeyAction_DIGITREMOVE(&menuCore->menuArray[RM_ADMIN_CHANGEPIN_SECOND_INSERT], 'L', PRESSED);
MenuElements_addKeyAction_DIGITINSERTCONFIRM(&menuCore->menuArray[RM_ADMIN_CHANGEPIN_SECOND_INSERT], 'E', PRESSED, repairMenu_configConfirmSecondPin);
/* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
* ADMIN I/O control
* Read interlock
* Solenoid
* Get Voltage In
* Set Voltage Out
* Teslagun Relais
* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
*/
// TESLA PCBA has one additional menu item
if (PCBA_getInstance()->pcba == PCBA_Tesla)
{
MenuElements_createMenuPage(&menuCore->menuArray[RM_ADMIN_IOCONTROL], MENU_HAS_CURSOR, 6);
}
else
{
MenuElements_createMenuPage(&menuCore->menuArray[RM_ADMIN_IOCONTROL], MENU_HAS_CURSOR, 5);
}
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[languageIndex][4], RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL2, repairMenu_configVoltageOutput);
}
else
{
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[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);
MenuElements_addKeyAction_SCROLLDOWN(&menuCore->menuArray[RM_ADMIN_IOCONTROL], 'D', PRESSED);
MenuElements_addKeyAction_SELECT(&menuCore->menuArray[RM_ADMIN_IOCONTROL], 'E', PRESSED);
MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_ADMIN_IOCONTROL], '1', PRESSED, 1);
MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_ADMIN_IOCONTROL], '2', PRESSED, 2);
MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_ADMIN_IOCONTROL], '3', PRESSED, 3);
MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_ADMIN_IOCONTROL], '4', PRESSED, 4);
if (PCBA_getInstance()->pcba == PCBA_Tesla)
{
MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_ADMIN_IOCONTROL], '5', PRESSED, 5);
}
/* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
* ADMIN interlock control
* Shows the interlock state. Screen is generated via function, not as a menu
* Key 'X' returns to I/O menu
*
* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
*/
MenuElements_createMenuPage(&menuCore->menuArray[RM_ADMIN_IO_INTERLOCK], MENU_HAS_NO_CURSOR, 4);
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);
/* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
* ADMIN Solenoid control
* Allows control over the Solenoids
* Key '0' controls the solenoid. Holding opens, releasing closes
* Key 'X' returns to I/O menu
*
* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
*/
MenuElements_createMenuPage(&menuCore->menuArray[RM_ADMIN_IO_SOLENOID], MENU_HAS_NO_CURSOR, 4);
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);
/* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
* ADMIN Voltage input
* Allows constant readout of all three ADCs
* Key 'X' returns to I/O menu
*
* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
*/
MenuElements_createMenuPage(&menuCore->menuArray[RM_ADMIN_IO_VOLTAGE_IN], MENU_HAS_NO_CURSOR, 4);
MenuElements_addKeyAction_EXECUTEFUNCTION(&menuCore->menuArray[RM_ADMIN_IO_VOLTAGE_IN], '0', PRESSED, repairMenu_solenoidUnlock);
MenuElements_addKeyAction_EXECUTEFUNCTION(&menuCore->menuArray[RM_ADMIN_IO_VOLTAGE_IN], '0', RELEASED, repairMenu_solenoidLock);
MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_ADMIN_IO_VOLTAGE_IN], 'X', PRESSED, RM_ADMIN_IOCONTROL);
/* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
* ADMIN Voltage output
* Allows control over all three DACs
* Key 'X' returns to I/O menu
*
* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
*/
if (PCBA_getInstance()->pcba == PCBA_Anode)
{
numberOfDigits = 5;
}
else if (PCBA_getInstance()->pcba == PCBA_CathodeMCP)
{
// The signage adds to the number of digits
numberOfDigits = 5;
}
else if (PCBA_getInstance()->pcba == PCBA_Tesla)
{
numberOfDigits = 4;
}
MenuElements_createMenuPage(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL1], MENU_HAS_NO_CURSOR, 10);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL1], '0', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL1], '1', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL1], '2', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL1], '3', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL1], '4', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL1], '5', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL1], '6', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL1], '7', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL1], '8', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL1], '9', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITREMOVE(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL1], 'L', PRESSED);
MenuElements_addKeyAction_DIGITINSERTCONFIRM(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL1], 'E', PRESSED, repairMenu_configConfirmVoltageOutFirstRow);
if (PCBA_getInstance()->pcba != PCBA_Tesla)
{
MenuElements_addKeyAction_DIGITINSERTCONFIRM(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL1], 'D', PRESSED, repairMenu_configConfirmVoltageOutFirstRowGotoNext);
}
MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL1], 'X', PRESSED, RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CLEANUP);
MenuElements_createMenuPage(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL2], MENU_HAS_NO_CURSOR, 10);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL2], '0', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL2], '1', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL2], '2', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL2], '3', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL2], '4', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL2], '5', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL2], '6', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL2], '7', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL2], '8', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL2], '9', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITREMOVE(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL2], 'L', PRESSED);
MenuElements_addKeyAction_DIGITINSERTCONFIRM(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL2], 'E', PRESSED, repairMenu_configConfirmVoltageOutSecondRow);
if (PCBA_getInstance()->pcba != PCBA_Tesla)
{
MenuElements_addKeyAction_DIGITINSERTCONFIRM(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL2], 'U', PRESSED, repairMenu_configConfirmVoltageOutSecondRowGotoPrevious);
MenuElements_addKeyAction_DIGITINSERTCONFIRM(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL2], 'D', PRESSED, repairMenu_configConfirmVoltageOutSecondRowGotoNext);
}
MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL2], 'X', PRESSED, RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CLEANUP);
MenuElements_createMenuPage(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL3], MENU_HAS_NO_CURSOR, 10);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL3], '0', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL3], '1', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL3], '2', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL3], '3', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL3], '4', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL3], '5', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL3], '6', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL3], '7', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL3], '8', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL3], '9', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITREMOVE(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL3], 'L', PRESSED);
MenuElements_addKeyAction_DIGITINSERTCONFIRM(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL3], 'E', PRESSED, repairMenu_configConfirmVoltageOutThirdRow);
if (PCBA_getInstance()->pcba != PCBA_Tesla)
{
MenuElements_addKeyAction_DIGITINSERTCONFIRM(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL3], 'U', PRESSED, repairMenu_configConfirmVoltageOutThirdRowGotoPrevious);
}
MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CHANNEL3], 'X', PRESSED, RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CLEANUP);
MenuElements_createMenuPage(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CLEANUP], MENU_HAS_NO_CURSOR, 10);
MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_ADMIN_IOCONTROL_VOLTAGE_OUT_CLEANUP], 'X', PRESSED, RM_ADMIN_IOCONTROL);
/* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
* ADMIN Teslagun relais control
*
* THIS MENU IS AVAILABLE ONLY ON TESLA REPAIR PCBAs
*
* Allows control over the TeslaGun relais
* Key '0' controls the relais. Holding opens, releasing closes
* Key 'X' returns to I/O menu
*
* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
*/
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[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);
}
/* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
* ADMIN preset config
* Select the repair preset to configure/modify
*
* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
*/
MenuElements_createMenuPage(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SELECT], MENU_HAS_CURSOR, 10);
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);
MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SELECT], '1', PRESSED, 1);
MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SELECT], '2', PRESSED, 2);
MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SELECT], '3', PRESSED, 3);
MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SELECT], '4', PRESSED, 4);
MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SELECT], '5', PRESSED, 5);
MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SELECT], '6', PRESSED, 6);
MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SELECT], '7', PRESSED, 7);
MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SELECT], '8', PRESSED, 8);
MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SELECT], '9', PRESSED, 9);
if (PCBA_getInstance()->pcba == PCBA_CathodeMCP)
{
MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SELECT], 'X', PRESSED, RM_ADMIN_CATHODEMCP_SELECT);
}
else
{
MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SELECT], 'X', PRESSED, RM_ADMINMENU);
}
/* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
* ADMIN preset config
* Select the repair preset to configure/modify
*
* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
*/
int softStartDigits = 0;
int durationDigits = 0;
int voltageDigits = 0;
if (PCBA_getInstance()->pcba == PCBA_Anode)
{
softStartDigits = 3;
durationDigits = 4;
voltageDigits = 5;
}
else if (PCBA_getInstance()->pcba == PCBA_CathodeMCP)
{
softStartDigits = 3;
durationDigits = 4;
voltageDigits = 5;
}
else if (PCBA_getInstance()->pcba == PCBA_Tesla)
{
softStartDigits = 3;
durationDigits = 4;
voltageDigits = 4;
}
MenuElements_createMenuPage(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART], MENU_HAS_NO_CURSOR, 10);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART], '0', PRESSED, softStartDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART], '1', PRESSED, softStartDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART], '2', PRESSED, softStartDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART], '3', PRESSED, softStartDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART], '4', PRESSED, softStartDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART], '5', PRESSED, softStartDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART], '6', PRESSED, softStartDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART], '7', PRESSED, softStartDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART], '8', PRESSED, softStartDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART], '9', PRESSED, softStartDigits);
MenuElements_addKeyAction_DIGITREMOVE(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART], 'L', PRESSED);
MenuElements_addKeyAction_DIGITINSERTCONFIRM(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART], 'E', PRESSED, repairMenu_configConfirmPresetFirstSoftstart);
MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART], 'X', PRESSED, RM_ADMIN_PRESET_CONFIG_SELECT);
MenuElements_createMenuPage(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_DURATION], MENU_HAS_NO_CURSOR, 10);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_DURATION], '0', PRESSED, durationDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_DURATION], '1', PRESSED, durationDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_DURATION], '2', PRESSED, durationDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_DURATION], '3', PRESSED, durationDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_DURATION], '4', PRESSED, durationDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_DURATION], '5', PRESSED, durationDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_DURATION], '6', PRESSED, durationDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_DURATION], '7', PRESSED, durationDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_DURATION], '8', PRESSED, durationDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_DURATION], '9', PRESSED, durationDigits);
MenuElements_addKeyAction_DIGITREMOVE(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_DURATION], 'L', PRESSED);
MenuElements_addKeyAction_DIGITINSERTCONFIRM(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_DURATION], 'E', PRESSED, repairMenu_configConfirmPresetFirstDuration);
MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_DURATION], 'X', PRESSED, RM_ADMIN_PRESET_CONFIG_SELECT);
MenuElements_createMenuPage(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_VOLTAGE], MENU_HAS_NO_CURSOR, 10);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_VOLTAGE], '0', PRESSED, voltageDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_VOLTAGE], '1', PRESSED, voltageDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_VOLTAGE], '2', PRESSED, voltageDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_VOLTAGE], '3', PRESSED, voltageDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_VOLTAGE], '4', PRESSED, voltageDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_VOLTAGE], '5', PRESSED, voltageDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_VOLTAGE], '6', PRESSED, voltageDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_VOLTAGE], '7', PRESSED, voltageDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_VOLTAGE], '8', PRESSED, voltageDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_VOLTAGE], '9', PRESSED, voltageDigits);
MenuElements_addKeyAction_DIGITREMOVE(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_VOLTAGE], 'L', PRESSED);
MenuElements_addKeyAction_DIGITINSERTCONFIRM(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_VOLTAGE], 'E', PRESSED, repairMenu_configConfirmPresetFirstVoltage);
MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_VOLTAGE], 'X', PRESSED, RM_ADMIN_PRESET_CONFIG_SELECT);
MenuElements_createMenuPage(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_SOFTSTART], MENU_HAS_NO_CURSOR, 10);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_SOFTSTART], '0', PRESSED, softStartDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_SOFTSTART], '1', PRESSED, softStartDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_SOFTSTART], '2', PRESSED, softStartDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_SOFTSTART], '3', PRESSED, softStartDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_SOFTSTART], '4', PRESSED, softStartDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_SOFTSTART], '5', PRESSED, softStartDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_SOFTSTART], '6', PRESSED, softStartDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_SOFTSTART], '7', PRESSED, softStartDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_SOFTSTART], '8', PRESSED, softStartDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_SOFTSTART], '9', PRESSED, softStartDigits);
MenuElements_addKeyAction_DIGITREMOVE(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_SOFTSTART], 'L', PRESSED);
MenuElements_addKeyAction_DIGITINSERTCONFIRM(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_SOFTSTART], 'E', PRESSED, repairMenu_configConfirmPresetSecondSoftstart);
MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_SOFTSTART], 'X', PRESSED, RM_ADMIN_PRESET_CONFIG_SELECT);
MenuElements_createMenuPage(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_DURATION], MENU_HAS_NO_CURSOR, 10);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_DURATION], '0', PRESSED, durationDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_DURATION], '1', PRESSED, durationDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_DURATION], '2', PRESSED, durationDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_DURATION], '3', PRESSED, durationDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_DURATION], '4', PRESSED, durationDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_DURATION], '5', PRESSED, durationDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_DURATION], '6', PRESSED, durationDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_DURATION], '7', PRESSED, durationDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_DURATION], '8', PRESSED, durationDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_DURATION], '9', PRESSED, durationDigits);
MenuElements_addKeyAction_DIGITREMOVE(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_DURATION], 'L', PRESSED);
MenuElements_addKeyAction_DIGITINSERTCONFIRM(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_DURATION], 'E', PRESSED, repairMenu_configConfirmPresetSecondDuration);
MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_DURATION], 'X', PRESSED, RM_ADMIN_PRESET_CONFIG_SELECT);
MenuElements_createMenuPage(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_VOLTAGE], MENU_HAS_NO_CURSOR, 10);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_VOLTAGE], '0', PRESSED, voltageDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_VOLTAGE], '1', PRESSED, voltageDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_VOLTAGE], '2', PRESSED, voltageDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_VOLTAGE], '3', PRESSED, voltageDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_VOLTAGE], '4', PRESSED, voltageDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_VOLTAGE], '5', PRESSED, voltageDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_VOLTAGE], '6', PRESSED, voltageDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_VOLTAGE], '7', PRESSED, voltageDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_VOLTAGE], '8', PRESSED, voltageDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_VOLTAGE], '9', PRESSED, voltageDigits);
MenuElements_addKeyAction_DIGITREMOVE(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_VOLTAGE], 'L', PRESSED);
MenuElements_addKeyAction_DIGITINSERTCONFIRM(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_VOLTAGE], 'E', PRESSED, repairMenu_configConfirmPresetSecondVoltage);
MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_VOLTAGE], 'X', PRESSED, RM_ADMIN_PRESET_CONFIG_SELECT);
numberOfDigits = 5;
MenuElements_createMenuPage(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KP], MENU_HAS_NO_CURSOR, 10);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KP], '0', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KP], '1', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KP], '2', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KP], '3', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KP], '4', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KP], '5', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KP], '6', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KP], '7', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KP], '8', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KP], '9', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITREMOVE(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KP], 'L', PRESSED);
MenuElements_addKeyAction_DIGITINSERTCONFIRM(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KP], 'E', PRESSED, repairMenu_configConfirmPIDKp);
MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KP], 'X', PRESSED, RM_ADMINMENU);
numberOfDigits = 5;
MenuElements_createMenuPage(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KI], MENU_HAS_NO_CURSOR, 10);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KI], '0', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KI], '1', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KI], '2', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KI], '3', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KI], '4', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KI], '5', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KI], '6', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KI], '7', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KI], '8', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KI], '9', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITREMOVE(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KI], 'L', PRESSED);
MenuElements_addKeyAction_DIGITINSERTCONFIRM(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KI], 'E', PRESSED, repairMenu_configConfirmPIDKi);
MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KI], 'X', PRESSED, RM_ADMINMENU);
numberOfDigits = 5;
MenuElements_createMenuPage(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KD], MENU_HAS_NO_CURSOR, 10);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KD], '0', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KD], '1', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KD], '2', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KD], '3', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KD], '4', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KD], '5', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KD], '6', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KD], '7', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KD], '8', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KD], '9', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITREMOVE(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KD], 'L', PRESSED);
MenuElements_addKeyAction_DIGITINSERTCONFIRM(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KD], 'E', PRESSED, repairMenu_configConfirmPIDKd);
MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_ADMIN_PID_CONFIG_KD], 'X', PRESSED, RM_ADMINMENU);
/* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
* ADMIN INFORMATION & VERSION SCREEN
* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
*/
MenuElements_createMenuPage(&menuCore->menuArray[RM_ADMIN_INFO], MENU_HAS_NO_CURSOR, 5);
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);
/* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
* CALIBRATION PIN VERIFICATION
* This screen is designed in a dedicated function
*
* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
*/
numberOfDigits = PIN_NUMBER_OF_DIGITS;
MenuElements_createMenuPage(&menuCore->menuArray[RM_CALIBRATIONMENU_PIN_VERIFICATION], MENU_HAS_NO_CURSOR, 10);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_CALIBRATIONMENU_PIN_VERIFICATION], '0', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_CALIBRATIONMENU_PIN_VERIFICATION], '1', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_CALIBRATIONMENU_PIN_VERIFICATION], '2', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_CALIBRATIONMENU_PIN_VERIFICATION], '3', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_CALIBRATIONMENU_PIN_VERIFICATION], '4', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_CALIBRATIONMENU_PIN_VERIFICATION], '5', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_CALIBRATIONMENU_PIN_VERIFICATION], '6', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_CALIBRATIONMENU_PIN_VERIFICATION], '7', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_CALIBRATIONMENU_PIN_VERIFICATION], '8', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_CALIBRATIONMENU_PIN_VERIFICATION], '9', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITREMOVE(&menuCore->menuArray[RM_CALIBRATIONMENU_PIN_VERIFICATION], 'L', PRESSED);
MenuElements_addKeyAction_DIGITINSERTCONFIRM(&menuCore->menuArray[RM_CALIBRATIONMENU_PIN_VERIFICATION], 'E', PRESSED, repairMenu_confirmCalibrationPin);
MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_CALIBRATIONMENU_PIN_VERIFICATION], 'X', PRESSED, RM_MAINMENU);
MenuElements_createMenuPage(&menuCore->menuArray[RM_CALIBRATIONMENU], MENU_HAS_NO_CURSOR, 2);
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);
MenuElements_createMenuPage(&menuCore->menuArray[RM_REPAIR_RUNNING], MENU_HAS_NO_CURSOR, 4);
MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_REPAIR_RUNNING], 'X', PRESSED, RM_REPAIR_ASK_PAUSE);
MenuElements_createMenuPage(&menuCore->menuArray[RM_REPAIR_ASK_PAUSE], MENU_HAS_NO_CURSOR, 4);
MenuElements_addKeyAction_EXECUTEFUNCTION(&menuCore->menuArray[RM_REPAIR_ASK_PAUSE], 'X', PRESSED, repairMenu_pauseRepairProcess);
MenuElements_createMenuPage(&menuCore->menuArray[RM_REPAIR_PAUSE], MENU_HAS_NO_CURSOR, 4);
MenuElements_addKeyAction_EXECUTEFUNCTION(&menuCore->menuArray[RM_REPAIR_PAUSE], 'X', PRESSED, repairMenu_abortRepairProcessAndGotoMainMenu);
MenuElements_addKeyAction_EXECUTEFUNCTION(&menuCore->menuArray[RM_REPAIR_PAUSE], 'E', PRESSED, repairMenu_continueRepairProcess);
MenuElements_addKeyAction_EXECUTEFUNCTION(&menuCore->menuArray[RM_REPAIR_PAUSE], '0', PRESSED, repairMenu_solenoidUnlock);
MenuElements_addKeyAction_EXECUTEFUNCTION(&menuCore->menuArray[RM_REPAIR_PAUSE], '0', RELEASED, repairMenu_solenoidLock);
MenuElements_createMenuPage(&menuCore->menuArray[RM_FINISH], MENU_HAS_NO_CURSOR, 4);
MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_FINISH], 'E', PRESSED, RM_MAINMENU);
MenuElements_createMenuPage(&menuCore->menuArray[RM_ERROR_STATE], MENU_HAS_NO_CURSOR, 4);
MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_ERROR_STATE], 'X', PRESSED, RM_MAINMENU);
MenuElements_createMenuPage(&menuCore->menuArray[RM_WARNING_STATE], MENU_HAS_NO_CURSOR, 4);
MenuElements_addKeyAction_EXECUTEFUNCTION(&menuCore->menuArray[RM_WARNING_STATE], 'X', PRESSED, repairMenu_gotoLastState);
}
Reference in New Issue View Git Blame Copy Permalink