1bbfa1c7f3
git-svn-id: https://svn.vbchaos.nl/svn/hsb/trunk@417 05563f52-14a8-4384-a975-3d1654cca0fa
2417 lines
129 KiB
C
2417 lines
129 KiB
C
// -----------------------------------------------------------------------------
|
|
/// @file repairMenu.c
|
|
/// @brief Description
|
|
// -----------------------------------------------------------------------------
|
|
// Micro-Key bv
|
|
// Industrieweg 28, 9804 TG Noordhorn
|
|
// Postbus 92, 9800 AB Zuidhorn
|
|
// The Netherlands
|
|
// Tel: +31 594 503020
|
|
// Fax: +31 594 505825
|
|
// Email: support@microkey.nl
|
|
// Web: www.microkey.nl
|
|
// -----------------------------------------------------------------------------
|
|
/// $Revision$
|
|
/// $Author$
|
|
/// $Date$
|
|
// (c) 2017 Micro-Key bv
|
|
// -----------------------------------------------------------------------------
|
|
|
|
/// @file repairMenu.c
|
|
/// @ingroup {group_name}
|
|
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// Include files
|
|
// -----------------------------------------------------------------------------
|
|
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
|
|
#include "DeviceParameters.h"
|
|
#include "PIDParameters.h"
|
|
#include "PowerLossDetector.h"
|
|
#include "repairMenu.h"
|
|
|
|
#include "CalibrationParameters.h"
|
|
#include "CalibrationSetpoint.h"
|
|
#include "CalibrationSetpoints.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_setDACToLowSetpoint(struct MenuCore* self);
|
|
static void repairMenu_setDACToHighSetpoint(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_selectCathodeCalibration(struct MenuCore* self);
|
|
static void repairMenu_selectMCPRepair(struct MenuCore* self);
|
|
static void repairMenu_selectMCPCalibration(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_CALIBRATION)
|
|
{
|
|
snprintf(self->menuCore->errorMessage, sizeof(self->menuCore->errorMessage) / sizeof(self->menuCore->errorMessage[0]), MenuText_ERROR_CRC_CALIBRATION[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_setDACToLowSetpoint(struct MenuCore* self)
|
|
{
|
|
struct CalibrationSetpoints* tempSetpoints = CalibrationParameters_getCalibrationSetpoints();
|
|
struct CalibrationSetpoint* tempSetpoint = CalibrationSetpoints_getActiveSetpointSet(tempSetpoints);
|
|
|
|
if (PCBA_getInstance()->pcba != PCBA_Tesla)
|
|
{
|
|
DAConverter_setOutputVoltage(dacRow1, tempSetpoint->low);
|
|
DAConverter_setOutputVoltage(dacRow3, tempSetpoint->low);
|
|
}
|
|
DAConverter_setOutputVoltage(dacRow2, tempSetpoint->low);
|
|
}
|
|
|
|
|
|
static void repairMenu_setDACToHighSetpoint(struct MenuCore* self)
|
|
{
|
|
struct CalibrationSetpoints* tempSetpoints = CalibrationParameters_getCalibrationSetpoints();
|
|
struct CalibrationSetpoint* tempSetpoint = CalibrationSetpoints_getActiveSetpointSet(tempSetpoints);
|
|
|
|
if (PCBA_getInstance()->pcba != PCBA_Tesla)
|
|
{
|
|
DAConverter_setOutputVoltage(dacRow1, tempSetpoint->high);
|
|
DAConverter_setOutputVoltage(dacRow3, tempSetpoint->high);
|
|
}
|
|
DAConverter_setOutputVoltage(dacRow2, tempSetpoint->high);
|
|
}
|
|
|
|
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_selectPCBACalibration(struct MenuCore* self)
|
|
{
|
|
struct CalibrationSetpoints* tempSetpoints = CalibrationParameters_getCalibrationSetpoints();
|
|
if (PCBA_getInstance()->pcba == PCBA_Anode)
|
|
{
|
|
CalibrationSetpoints_setActiveSetpointSet(tempSetpoints, CALIBRATION_SETPOINT_ANODE);
|
|
}
|
|
else if (PCBA_getInstance()->pcba == PCBA_Tesla)
|
|
{
|
|
CalibrationSetpoints_setActiveSetpointSet(tempSetpoints, CALIBRATION_SETPOINT_TESLA);
|
|
}
|
|
}
|
|
|
|
static void repairMenu_selectCathodeCalibration(struct MenuCore* self)
|
|
{
|
|
struct CalibrationSetpoints* tempSetpoints = CalibrationParameters_getCalibrationSetpoints();
|
|
CalibrationSetpoints_setActiveSetpointSet(tempSetpoints, CALIBRATION_SETPOINT_CATHODE);
|
|
}
|
|
|
|
|
|
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_selectMCPCalibration(struct MenuCore* self)
|
|
{
|
|
struct CalibrationSetpoints* tempSetpoints = CalibrationParameters_getCalibrationSetpoints();
|
|
CalibrationSetpoints_setActiveSetpointSet(tempSetpoints, CALIBRATION_SETPOINT_MCP);
|
|
}
|
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
else if (self->menuState == RM_CALIBRATION_SETPOINT_LOW)
|
|
{
|
|
repairMenu_printVoltageOutput(self);
|
|
}
|
|
|
|
else if (self->menuState == RM_CALIBRATION_SETPOINT_HIGH)
|
|
{
|
|
repairMenu_printVoltageOutput(self);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
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_CURSOR, 2);
|
|
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_CALIBRATIONMENU], MenuText_CALIBRATIONMENU[languageIndex][0], RM_CALIBRATIONMENU, NULL);
|
|
if (PCBA_getInstance()->pcba == PCBA_CathodeMCP)
|
|
{
|
|
// For Cathode/MCP PCBA, the type of repair must be selected first
|
|
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_CALIBRATIONMENU], MenuText_CALIBRATIONMENU[languageIndex][1], RM_CALIBRATION_CATHOEMCP_SELECT, NULL);
|
|
}
|
|
else
|
|
{
|
|
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_CALIBRATIONMENU], MenuText_CALIBRATIONMENU[languageIndex][1], RM_CALIBRATION_SETPOINT_MENU, repairMenu_selectPCBACalibration);
|
|
}
|
|
|
|
|
|
MenuElements_addKeyAction_SCROLLUP(&menuCore->menuArray[RM_CALIBRATIONMENU], 'U', PRESSED);
|
|
MenuElements_addKeyAction_SCROLLDOWN(&menuCore->menuArray[RM_CALIBRATIONMENU], 'D', PRESSED);
|
|
MenuElements_addKeyAction_SELECT(&menuCore->menuArray[RM_CALIBRATIONMENU], 'E', PRESSED);
|
|
MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_CALIBRATIONMENU], '1', PRESSED, 1);
|
|
MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_CALIBRATIONMENU], 'X', PRESSED, RM_MAINMENU);
|
|
|
|
|
|
/* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
|
* 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_CALIBRATION_CATHOEMCP_SELECT], MENU_HAS_CURSOR, 4);
|
|
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_CALIBRATION_CATHOEMCP_SELECT], MenuText_CATHODEMCP_SELECT[languageIndex][0], RM_CALIBRATION_CATHOEMCP_SELECT, NULL);
|
|
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_CALIBRATION_CATHOEMCP_SELECT], MenuText_CATHODEMCP_SELECT[languageIndex][1], RM_CALIBRATION_SETPOINT_MENU, repairMenu_selectCathodeCalibration);
|
|
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_CALIBRATION_CATHOEMCP_SELECT], MenuText_CATHODEMCP_SELECT[languageIndex][2], RM_CALIBRATION_SETPOINT_MENU, repairMenu_selectMCPCalibration);
|
|
MenuElements_addKeyAction_SCROLLUP(&menuCore->menuArray[RM_CALIBRATION_CATHOEMCP_SELECT], 'U', PRESSED);
|
|
MenuElements_addKeyAction_SCROLLDOWN(&menuCore->menuArray[RM_CALIBRATION_CATHOEMCP_SELECT], 'D', PRESSED);
|
|
MenuElements_addKeyAction_SELECT(&menuCore->menuArray[RM_CALIBRATION_CATHOEMCP_SELECT], 'E', PRESSED);
|
|
MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_CALIBRATION_CATHOEMCP_SELECT], '1', PRESSED, 1);
|
|
MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_CALIBRATION_CATHOEMCP_SELECT], '2', PRESSED, 2);
|
|
MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_CALIBRATION_CATHOEMCP_SELECT], 'X', PRESSED, RM_CALIBRATIONMENU);
|
|
|
|
/* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
|
* Calibration setpoint selection
|
|
* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
|
*/
|
|
MenuElements_createMenuPage(&menuCore->menuArray[RM_CALIBRATION_SETPOINT_MENU], MENU_HAS_CURSOR, 3);
|
|
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_CALIBRATION_SETPOINT_MENU], MenuText_CALIBRATION_SETPOINTMENU[languageIndex][0], RM_CALIBRATION_SETPOINT_MENU, NULL);
|
|
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_CALIBRATION_SETPOINT_MENU], MenuText_CALIBRATION_SETPOINTMENU[languageIndex][1], RM_CALIBRATION_SETPOINT_LOW, repairMenu_setDACToLowSetpoint);
|
|
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_CALIBRATION_SETPOINT_MENU], MenuText_CALIBRATION_SETPOINTMENU[languageIndex][2], RM_CALIBRATION_SETPOINT_HIGH, repairMenu_setDACToHighSetpoint);
|
|
MenuElements_addKeyAction_SCROLLUP(&menuCore->menuArray[RM_CALIBRATION_SETPOINT_MENU], 'U', PRESSED);
|
|
MenuElements_addKeyAction_SCROLLDOWN(&menuCore->menuArray[RM_CALIBRATION_SETPOINT_MENU], 'D', PRESSED);
|
|
MenuElements_addKeyAction_SELECT(&menuCore->menuArray[RM_CALIBRATION_SETPOINT_MENU], 'E', PRESSED);
|
|
MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_CALIBRATION_SETPOINT_MENU], '1', PRESSED, 1);
|
|
MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_CALIBRATION_SETPOINT_MENU], '2', PRESSED, 2);
|
|
MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_CALIBRATION_SETPOINT_MENU], 'X', PRESSED, RM_CALIBRATIONMENU);
|
|
|
|
/* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
|
* Calibration LOW setpoint
|
|
* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
|
*/
|
|
MenuElements_createMenuPage(&menuCore->menuArray[RM_CALIBRATION_SETPOINT_LOW], MENU_HAS_NO_CURSOR, 3);
|
|
MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_CALIBRATION_SETPOINT_LOW], 'X', PRESSED, RM_CALIBRATION_SETPOINT_MENU);
|
|
|
|
/* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
|
* Calibration HIGH setpoint
|
|
* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
|
*/
|
|
MenuElements_createMenuPage(&menuCore->menuArray[RM_CALIBRATION_SETPOINT_HIGH], MENU_HAS_NO_CURSOR, 3);
|
|
MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_CALIBRATION_SETPOINT_HIGH], 'X', PRESSED, RM_CALIBRATION_SETPOINT_MENU);
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
|
|
|
|