// ----------------------------------------------------------------------------- /// @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 #include #include #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); }