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

Fixed some major issues with RAM shortage. Also moved the cached storage to a MALLOC design instead of fixed memory usage. Using freertos porteds malloc and free required to move to HEAP4 to make sure memory does not get fragmented.

Browse Source 
Resized nearly all task stacks

Also: 
- Menu fixes for insertion. Almost done, just need to fix the negative voltage insertion for mcp and cathode
- Added Device parameters, must be filled in

git-svn-id: https://svn.vbchaos.nl/svn/hsb/trunk@271 05563f52-14a8-4384-a975-3d1654cca0fa
This commit is contained in:
mmi
2017-11-07 15:50:25 +00:00
parent 27755498e6
commit 17207a3a4b
32 changed files with 1833 additions and 280 deletions
Download Patch File Download Diff File Expand all files Collapse all files

136
S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/DeviceParameters.c Normal file
View File

@@ -0,0 +1,136 @@
// -----------------------------------------------------------------------------
/// @file DeviceParameters.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 DeviceParameters.c
/// @ingroup {group_name}
// -----------------------------------------------------------------------------
// Include files
// -----------------------------------------------------------------------------
#include "DeviceParameters.h"
// -----------------------------------------------------------------------------
// Constant and macro definitions
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
// Type definitions
// -----------------------------------------------------------------------------
struct DeviceParameters
{
bool initialized;
struct CachedStorage* parametersStorage;
struct MemoryDevice* memoryDevice;
};
struct PIDParametersStorageClass
{
uint32_t crc;
struct PIDParameters pidParameters;
};
struct PINStorageClass
{
uint32_t crc;
struct PIN pin;
};
// -----------------------------------------------------------------------------
// File-scope variables
// -----------------------------------------------------------------------------
static struct DeviceParameters _self = {.initialized = false};
struct DeviceParameters* const self = &_self;
// -----------------------------------------------------------------------------
// Function declarations
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
// Function definitions
// -----------------------------------------------------------------------------
ErrorStatus DeviceParameters_construct(struct CachedStorage* parametersStorage, struct MemoryDevice* memoryDevice)
{
ErrorStatus returnValue = SUCCESS;
if (!self->initialized)
{
if (returnValue == SUCCESS)
{
if (parametersStorage != NULL)
{
self->parametersStorage = parametersStorage;
}
else
{
returnValue = ERROR;
}
}
if (returnValue == SUCCESS)
{
if (memoryDevice != NULL)
{
if (memoryDevice->initialized)
{
self->memoryDevice = memoryDevice;
}
else
{
returnValue = ERROR;
}
}
else
{
returnValue = ERROR;
}
}
self->initialized = true;
}
else
{
returnValue = ERROR;
}
return returnValue;
}
void DeviceParameters_destruct(void)
{
}
struct PIDParameters* DeviceParameters_getPIDParameters(void)
{
}
struct PIN* DeviceParameters_getPIN(void)
{
}

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

@@ -158,6 +158,23 @@ ErrorStatus Display_setContrast(struct Display* self, size_t contrast)
}
ErrorStatus Display_setBlinkingCursorState(struct Display* self, DisplayDevice_functionalState state)
{
return DisplayDevice_setBlinkingCursorState(self->displayDevice, state);
}
ErrorStatus Display_setCursorToPosition(struct Display* self, unsigned int row, unsigned int column)
{
return DisplayDevice_setCursorToPosition(self->displayDevice, row, column);
}
ErrorStatus Display_backspace(struct Display* self)
{
return DisplayDevice_backspace(self->displayDevice);
}
ErrorStatus Display_write(struct Display* self, const char* buffer, size_t row, size_t column)
{
ErrorStatus returnValue = SUCCESS;

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

@@ -81,6 +81,11 @@ ErrorStatus Displays_construct(void)
returnValue = Observable_addObserver(RTC_getObservable(rtc), Displays_mainDisplayObserverFromISR);
}
if (returnValue == SUCCESS)
{
returnValue = Display_setBlinkingCursorState(mainDisplay, OFF);
}
if (returnValue == SUCCESS)
{
returnValue = Display_clearScreen(mainDisplay);
@@ -95,6 +100,7 @@ ErrorStatus Displays_construct(void)
{
returnValue = Display_setContrast(mainDisplay, MAINDISP_DEFAULT_CONTRAST);
}
return returnValue;
}

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

@@ -70,7 +70,7 @@ ErrorStatus Error_construct(void)
Observable_construct(&observable);
errorQueue = xQueueCreate(ERROR_QUEUE_SIZE, sizeof(struct ErrorQueueItem));
xTaskCreate(ErrorTask, "ErrorTask", 512, NULL, 1, &errorTaskHandle);
xTaskCreate(ErrorTask, "ErrorTask", 300, NULL, 1, &errorTaskHandle);
return SUCCESS;
}

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

@@ -180,8 +180,8 @@ static void MenuCore_task(void* parameters)
void MenuCore_changeState(struct MenuCore* self, T_MenuState newState)
{
Display_clearScreen(self->display);
Display_setBlinkingCursorState(self->display, OFF);
self->menuState = newState;
LOGGER_WARNING(mainLog, "New menu index is %d", self->menuState);
}
static void MenuCore_printMenu(struct MenuCore* self)
@@ -191,6 +191,13 @@ static void MenuCore_printMenu(struct MenuCore* self)
// Always print Row1 (index0), ignoring the scrolling index
Display_write(self->display, self->menuArray[self->menuState].row[0].text, 1, 1);
// Verify the cursor position.
// It may be off from a previous menu, so if it is off, reset it
if (self->cursorIndex > (self->menuArray[self->menuState].numberOfRows - 1))
{
MenuCore_scrollIndexHandlerReset(self);
}
for (loopCounter = 1 ; loopCounter < self->display->displayDevice->parameters.numberOfRows; loopCounter++)
{
Display_write(self->display, self->menuArray[self->menuState].row[loopCounter + self->scrollOffset].text, loopCounter + 1, 1);
@@ -212,21 +219,18 @@ static ErrorStatus MenuCore_performAction(struct MenuCore* self, char key, Keypa
ErrorStatus returnValue = SUCCESS;
struct KeyActionBinding keyAction = MenuCore_findKeyAction(self, key, keyState);
LOGGER_DEBUG(mainLog, "Action: received key %c, action to perform %d,", key, keyAction.action);
switch (keyAction.action)
{
case NO_ACTION:
{
LOGGER_INFO(mainLog, "This button has no action");
returnValue = ERROR;
break;
}
case HOTKEY_SELECT:
{
LOGGER_INFO(mainLog, "HOTKEY SELECT ITEM: char %c, argument %d - Going to state %d", keyAction.key, keyAction.argument, self->menuArray[self->menuState].row[keyAction.argument].newState);
self->cursorIndex = keyAction.argument;
self->selectionIndex = keyAction.argument;
T_MenuState tempState = self->menuState;
MenuCore_changeState(self, self->menuArray[self->menuState].row[keyAction.argument].newState);
if (self->menuArray[tempState].row[keyAction.argument].actionPointer != NULL)
@@ -239,8 +243,8 @@ static ErrorStatus MenuCore_performAction(struct MenuCore* self, char key, Keypa
case SELECT:
{
LOGGER_INFO(mainLog, "SELECT ITEM %d - going to state %d", self->cursorIndex, self->menuArray[self->menuState].row[self->cursorIndex].newState);
T_MenuState tempState = self->menuState;
self->selectionIndex = self->cursorIndex;
MenuCore_changeState(self, self->menuArray[self->menuState].row[self->cursorIndex].newState);
if (self->menuArray[tempState].row[self->cursorIndex].actionPointer != NULL)
{
@@ -252,15 +256,15 @@ static ErrorStatus MenuCore_performAction(struct MenuCore* self, char key, Keypa
case GOTO_STATE:
{
LOGGER_INFO(mainLog, "Going to new state %d directly", keyAction.argument);
self->selectionIndex = self->cursorIndex;
MenuCore_changeState(self, keyAction.argument);
// MenuCore_scrollIndexHandlerReset(self);
MenuCore_scrollIndexHandlerReset(self);
break;
}
case EXECUTE_FUNCTION:
{
LOGGER_INFO(mainLog, "Executing function directly");
self->selectionIndex = self->cursorIndex;
if (keyAction.actionPointer != NULL)
{
keyAction.actionPointer(self);
@@ -270,19 +274,60 @@ static ErrorStatus MenuCore_performAction(struct MenuCore* self, char key, Keypa
case SCROLL_UP:
{
LOGGER_INFO(mainLog, "Scrolling up");
MenuCore_scrollUpIndexHandler(self);
break;
}
case SCROLL_DOWN:
{
LOGGER_INFO(mainLog, "Scrolling down");
MenuCore_scrollDownIndexHandler(self);
break;
}
case DIGIT_INSERT:
{
LOGGER_INFO(mainLog, "Key is allowed as insert");
// Determine the number of digits currently used
int divider = self->insertValue;
int numberOfDigits = 0;
while (divider != 0)
{
divider /= 10;
numberOfDigits++;
}
// The Argument carries the max number of digits for the current insertion value
if (numberOfDigits < keyAction.argument)
{
// Verify that only digits 0-9 are taken into account
// Copare with decimal ASCII
if ((keyAction.key > 47) && (keyAction.key < 58))
{
// Shift the already inserted value to the left
self->insertValue = self->insertValue * 10;
// Add the latest value
self->insertValue = self->insertValue + (keyAction.key - 48);
}
}
LOGGER_INFO(mainLog, "Inserted Value is: %d", self->insertValue);
break;
}
case DIGIT_REMOVE:
{
LOGGER_INFO(mainLog, "Key is allowed as remove");
// Shift the already inserted value to the right
self->insertValue = self->insertValue / 10;
LOGGER_INFO(mainLog, "Inserted Value is: %d", self->insertValue);
break;
}
case DIGIT_INSERT_CONFIRM:
{
LOGGER_INFO(mainLog, "Digit insert confirmed");
if (keyAction.actionPointer != NULL)
{
keyAction.actionPointer(self);
}
break;
}
}

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

@@ -82,7 +82,8 @@ ErrorStatus MenuElements_addMenuPageRow (struct MenuPage* self, const char* text
ErrorStatus returnValue = SUCCESS;
if (self->numberOfRows < self->maxNumberOfRows)
{
memcpy(self->row[self->numberOfRows].text, text, 20);
// memcpy(self->row[self->numberOfRows].text, text, 20);
self->row[self->numberOfRows].text = text;
self->row[self->numberOfRows].newState = newState;
self->row[self->numberOfRows].actionPointer = actionCall;
self->numberOfRows++;
@@ -219,3 +220,66 @@ ErrorStatus MenuElements_addKeyAction_SCROLLDOWN (struct MenuPage* self, char ke
}
return returnValue;
}
ErrorStatus MenuElements_addKeyAction_DIGITINSERT (struct MenuPage* self, char key, Keypad_KeyState keyState, unsigned int maxNumberOfDigits)
{
ErrorStatus returnValue = SUCCESS;
if (self->numberOfKeys < self->maxNumberOfKeys)
{
self->keyActionBinding[self->numberOfKeys].key = key;
self->keyActionBinding[self->numberOfKeys].keyState = keyState;
self->keyActionBinding[self->numberOfKeys].action = DIGIT_INSERT;
self->keyActionBinding[self->numberOfKeys].argument = maxNumberOfDigits;
self->keyActionBinding[self->numberOfKeys].actionPointer = NULL;
self->numberOfKeys++;
}
else
{
returnValue = ERROR;
}
return returnValue;
}
ErrorStatus MenuElements_addKeyAction_DIGITREMOVE (struct MenuPage* self, char key, Keypad_KeyState keyState)
{
ErrorStatus returnValue = SUCCESS;
if (self->numberOfKeys < self->maxNumberOfKeys)
{
self->keyActionBinding[self->numberOfKeys].key = key;
self->keyActionBinding[self->numberOfKeys].keyState = keyState;
self->keyActionBinding[self->numberOfKeys].action = DIGIT_REMOVE;
self->keyActionBinding[self->numberOfKeys].argument = 0;
self->keyActionBinding[self->numberOfKeys].actionPointer = NULL;
self->numberOfKeys++;
}
else
{
returnValue = ERROR;
}
return returnValue;
}
ErrorStatus MenuElements_addKeyAction_DIGITINSERTCONFIRM (struct MenuPage* self, char key, Keypad_KeyState keyState, MenuCoreFunctionCall actionPointer)
{
ErrorStatus returnValue = SUCCESS;
if (self->numberOfKeys < self->maxNumberOfKeys)
{
self->keyActionBinding[self->numberOfKeys].key = key;
self->keyActionBinding[self->numberOfKeys].keyState = keyState;
self->keyActionBinding[self->numberOfKeys].action = DIGIT_INSERT_CONFIRM;
self->keyActionBinding[self->numberOfKeys].argument = 0;
self->keyActionBinding[self->numberOfKeys].actionPointer = actionPointer;
self->numberOfKeys++;
}
else
{
returnValue = ERROR;
}
return returnValue;
}

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

@@ -33,6 +33,8 @@
#include "RepairPreset.h"
#include "PCBA.h"
// -----------------------------------------------------------------------------
// Constant and macro definitions
// -----------------------------------------------------------------------------
@@ -53,17 +55,50 @@ ErrorStatus RepairPreset_generateDefaultPreset(struct RepairPreset* self, unsign
{
ErrorStatus returnValue = SUCCESS;
if (presetNumber <= REPAIR_PRESET_MAX_ONE_STAGE_PRESETS)
{
self->numberOfStages = 1;
}
else
{
self->numberOfStages = 2;
}
self->presetNumber = presetNumber;
self->numberOfStages = 1;
self->preset[0].softstartDuration = 100;
self->preset[0].duration = 200;
self->preset[0].voltage = 0;
self->preset[0].softstartDuration = 1800;
self->preset[0].duration = 28800;
if (PCBA_getInstance()->pcba == PCBA_CathodeMCP)
{
self->preset[0].voltage = -1000;
self->preset[1].voltage = -1000;
}
else
{
self->preset[0].voltage = 1000;
self->preset[1].voltage = 1000;
}
// Generate dummy presets to fill the memory
self->preset[1].softstartDuration = 0;
self->preset[1].duration = 0;
self->preset[1].voltage = 0;
self->preset[1].softstartDuration = 1800;
self->preset[1].duration = 28800;
return returnValue;
}
void RepairPreset_setSoftstartValue(struct RepairPresetParameters* self, unsigned int value)
{
self->softstartDuration = value;
}
void RepairPreset_setDurationValue(struct RepairPresetParameters* self, unsigned int value)
{
self->duration = value;
}
void RepairPreset_setVoltageValue(struct RepairPresetParameters* self, int value)
{
self->voltage = value;
}
#endif /* REPAIRPRESET_C_ */

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

@@ -74,7 +74,6 @@ struct RepairPresets* const self = &_self;
static ErrorStatus RepairPresets_verifyCRCs(void);
static ErrorStatus RepairPresets_verifyPresetCRC(struct RepairPresetStorageClass* repairPreset);
static ErrorStatus RepairPresets_writePreset(struct RepairPreset* preset);
// -----------------------------------------------------------------------------
// Function definitions
@@ -184,7 +183,7 @@ ErrorStatus RepairPresets_loadPresets(REPAIR_PRESETS_ID presetID)
if (returnValue == SUCCESS)
{
// Create new cachedStorage with preset page number
returnValue = CachedStorage_construct(self->presetStorage, self->memoryDevice, pageNumber);
returnValue = CachedStorage_construct(self->presetStorage, self->memoryDevice, pageNumber, ((sizeof(struct RepairPresetStorageClass) * REPAIR_PRESETS_NUMBER_OF_PRESETS) / 4));
}
else
{
@@ -215,9 +214,9 @@ ErrorStatus RepairPresets_loadPresets(REPAIR_PRESETS_ID presetID)
}
const struct RepairPreset* RepairPresets_getPreset(unsigned int index)
struct RepairPreset* RepairPresets_getPreset(unsigned int index)
{
const struct RepairPreset* returnValue = NULL;
struct RepairPreset* returnValue = NULL;
if (self->initialized)
{
if (self->presetsLoaded)
@@ -226,8 +225,8 @@ const struct RepairPreset* RepairPresets_getPreset(unsigned int index)
if ((index > 0) || (index <= REPAIR_PRESETS_NUMBER_OF_PRESETS))
{
struct RepairPresetStorageClass* tempPreset;
tempPreset = CachedStorage_readBlob(self->presetStorage, (index - 1) * sizeof(struct RepairPresetStorageClass));
returnValue = (const struct RepairPreset*)&tempPreset->preset;
tempPreset = CachedStorage_readBlob(self->presetStorage, (index - 1) * sizeof(struct RepairPresetStorageClass) / 4);
returnValue = (struct RepairPreset*)&tempPreset->preset;
}
}
}
@@ -235,6 +234,13 @@ const struct RepairPreset* RepairPresets_getPreset(unsigned int index)
}
void RepairPresets_savePresets(void)
{
// Commit cache to memory - will not write if no changes have been made
CachedStorage_commit(self->presetStorage);
}
static ErrorStatus RepairPresets_verifyCRCs(void)
{
ErrorStatus returnValue = SUCCESS;
@@ -246,7 +252,7 @@ static ErrorStatus RepairPresets_verifyCRCs(void)
for (loopCounter = 0; loopCounter < REPAIR_PRESETS_NUMBER_OF_PRESETS; loopCounter++)
{
// Load next preset from cache
tempPresetStorage = CachedStorage_readBlob(self->presetStorage, loopCounter * sizeof(struct RepairPresetStorageClass));
tempPresetStorage = CachedStorage_readBlob(self->presetStorage, loopCounter * sizeof(struct RepairPresetStorageClass) / 4);
// Verify CRC
returnValue = RepairPresets_verifyPresetCRC(tempPresetStorage);
// Check CRC verification
@@ -285,10 +291,6 @@ static ErrorStatus RepairPresets_verifyPresetCRC(struct RepairPresetStorageClass
returnValue = ERROR;
LOGGER_ERROR(mainLog, "CRC ERROR at repair preset %d (calculated %X but loaded %X)", repairPreset->preset.presetNumber, (unsigned int)tempCRC, (unsigned int)repairPreset->crc);
}
else
{
LOGGER_INFO(mainLog, "CRC OK at repair preset %d (calculated %X and loaded %X)", repairPreset->preset.presetNumber, (unsigned int)tempCRC, (unsigned int)repairPreset->crc);
}
}
else
{
@@ -299,7 +301,7 @@ static ErrorStatus RepairPresets_verifyPresetCRC(struct RepairPresetStorageClass
static ErrorStatus RepairPresets_writePreset(struct RepairPreset* preset)
ErrorStatus RepairPresets_writePreset(struct RepairPreset* preset)
{
ErrorStatus returnValue = SUCCESS;
if (self->initialized)
@@ -309,7 +311,8 @@ static ErrorStatus RepairPresets_writePreset(struct RepairPreset* preset)
// Calculate CRC over preset
tempPresetStorage.crc = crc32_calculate(0, &tempPresetStorage.preset, sizeof(struct RepairPreset));
// Put default preset on Cache
CachedStorage_writeBlob(self->presetStorage, (tempPresetStorage.preset.presetNumber - 1) * sizeof(struct RepairPresetStorageClass), &tempPresetStorage, sizeof(struct RepairPresetStorageClass));
CachedStorage_writeBlob(self->presetStorage, (tempPresetStorage.preset.presetNumber - 1) * sizeof(struct RepairPresetStorageClass) / 4,
&tempPresetStorage, sizeof(struct RepairPresetStorageClass) / 4);
}
else

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

@@ -129,7 +129,7 @@ int main (void)
ledTaskArguments.led = ledOrange;
ledTaskArguments.frequency = 1;
xTaskCreate(initTask, (const char* const)"initTask", 2048, NULL, 5, &initTaskHandle);
xTaskCreate(initTask, (const char* const)"initTask", 1024, NULL, 5, &initTaskHandle);
/* Start the scheduler. */
vTaskStartScheduler();
@@ -169,6 +169,8 @@ static ErrorStatus systeminfoCommandHandler(void)
snprintf(text, sizeof(text), "Free heap memory: %d bytes", freeMemory);
LOGGER_INFO(mainLog, text);
vTaskDelay(10);
OS_logTaskInfo(initTaskHandle);
vTaskDelay(10);
OS_logTaskInfo(ledTaskHandle);
vTaskDelay(10);
@@ -180,6 +182,8 @@ static ErrorStatus systeminfoCommandHandler(void)
vTaskDelay(10);
OS_logTaskInfo(mainDisplay->taskHandle);
vTaskDelay(10);
OS_logTaskInfo(repairMenus_getMainRepairMenu()->menuCore->taskHandle);
vTaskDelay(10);
OS_logTaskInfo(repairProcesses_getMainRepairProcess()->taskHandle);
@@ -275,7 +279,7 @@ static void ledBlinkTask (void* parameters)
vTaskDelay(configTICK_RATE_HZ / (frequency * 2));
IODevice_write(&gpio->device, &low, 1);
indicator[0] = ' ';
Display_write(mainDisplay, indicator, 1, 20);
// Display_write(mainDisplay, indicator, 1, 20);
vTaskDelay(configTICK_RATE_HZ / (frequency * 2));
}
}

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

@@ -54,6 +54,7 @@
#include "PCBA.h"
#include "rtc.h"
#include "storm700.h"
#include "Version.h"
// -----------------------------------------------------------------------------
// Constant and macro definitions
@@ -87,12 +88,28 @@ 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_configPresetFirstSoftstart(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_printConfigPreset(struct MenuCore* self);
static void repairMenu_printInfo(struct MenuCore* self);
static void repairMenu_selectCathodeRepair(struct MenuCore* self);
static void repairMenu_selectMCPRepair(struct MenuCore* self);
static void repairMenu_selectPreset(struct MenuCore* self);
static void repairMenu_solenoidLock(struct MenuCore* self);
static void repairMenu_solenoidUnlock(struct MenuCore* self);
static void repairMenu_teslagunRelease(struct MenuCore* self);
static void repairMenu_teslagunBlock(struct MenuCore* self);
static void repairMenu_startRepairProcess(struct MenuCore* self);
static void repairMenu_stopRepairProcess(struct MenuCore* self);
static void repairMenu_abortRepairProcessAndGotoMainMenu(struct MenuCore* self);
@@ -303,7 +320,7 @@ static void repairMenu_printPreset(struct MenuCore* self)
int loopCounter;
char buffer[self->display->displayDevice->parameters.numberOfColumns];
// Print the preset information of the current preset under the cursor, NOT the preset that is currently selected
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "Preset %d info", self->cursorIndex);
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "Preset %d info", self->selectionIndex);
// Always print Row1 (index0), ignoring the scrolling index
Display_write(self->display, buffer, 1, 1);
@@ -314,21 +331,210 @@ static void repairMenu_printPreset(struct MenuCore* self)
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "Volt:");
Display_write(self->display, buffer, 4, 1);
for (loopCounter = 0; loopCounter < RepairPresets_getPreset(self->cursorIndex)->numberOfStages; loopCounter++)
for (loopCounter = 0; loopCounter < RepairPresets_getPreset(self->selectionIndex)->numberOfStages; loopCounter++)
{
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5dm", (RepairPresets_getPreset(self->cursorIndex)->preset[loopCounter].softstartDuration / 60));
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5dm", (RepairPresets_getPreset(self->selectionIndex)->preset[loopCounter].softstartDuration / 60));
Display_write(self->display, buffer, 2, 8 + loopCounter * 7);
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5dm", (RepairPresets_getPreset(self->cursorIndex)->preset[loopCounter].duration / 60));
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5dm", (RepairPresets_getPreset(self->selectionIndex)->preset[loopCounter].duration / 60));
Display_write(self->display, buffer, 3, 8 + loopCounter * 7);
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5dV", RepairPresets_getPreset(self->cursorIndex)->preset[loopCounter].voltage);
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5dV", RepairPresets_getPreset(self->selectionIndex)->preset[loopCounter].voltage);
Display_write(self->display, buffer, 4, 8 + loopCounter * 7);
}
}
static void repairMenu_printChangePinScreen(struct MenuCore* self)
{
char buffer[self->display->displayDevice->parameters.numberOfColumns];
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), " New PIN: ----");
Display_write(self->display, buffer, 3, 1);
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), " Repeat PIN: ----");
Display_write(self->display, buffer, 4, 1);
Display_setCursorToPosition(self->display, 3, 14);
DisplayDevice_setBlinkingCursorState(self->display->displayDevice, ON);
}
static void repairMenu_printIOInterlockStatus(struct MenuCore* self)
{
char buffer[self->display->displayDevice->parameters.numberOfColumns];
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "Cover Interlock is");
Display_write(self->display, buffer, 2, 1);
if (Interlock_isClosed(interlock))
{
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "closed");
Display_write(self->display, buffer, 3, 8);
}
else
{
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "open");
Display_write(self->display, buffer, 3, 9);
}
}
static void repairMenu_configPresetFirstSoftstart(struct MenuCore* self)
{
self->insertValue = RepairPresets_getPreset(self->selectionIndex)->preset[0].softstartDuration / 60;
}
static void repairMenu_configConfirmPresetFirstSoftstart(struct MenuCore* self)
{
// Takeover the inserted value
RepairPreset_setSoftstartValue(&RepairPresets_getPreset(self->selectionIndex)->preset[0], self->insertValue * 60);
// Goto next insertion state
MenuCore_changeState(self, RM_ADMIN_PRESET_CONFIG_FIRST_DURATION);
// Receive next value for insertion
self->insertValue = 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], self->insertValue * 60);
// Goto next insertion state
MenuCore_changeState(self, RM_ADMIN_PRESET_CONFIG_FIRST_VOLTAGE);
// Receive next value for insertion
self->insertValue = RepairPresets_getPreset(self->selectionIndex)->preset[0].voltage;
}
static void repairMenu_configConfirmPresetFirstVoltage(struct MenuCore* self)
{
// Takeover the inserted value
RepairPreset_setVoltageValue(&RepairPresets_getPreset(self->selectionIndex)->preset[0], self->insertValue);
// 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
self->insertValue = 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], self->insertValue * 60);
// Goto next insertion state
MenuCore_changeState(self, RM_ADMIN_PRESET_CONFIG_SECOND_DURATION);
// Receive next value for insertion
self->insertValue = 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], self->insertValue * 60);
// Goto next insertion state
MenuCore_changeState(self, RM_ADMIN_PRESET_CONFIG_SECOND_VOLTAGE);
// Receive next value for insertion
self->insertValue = 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], self->insertValue);
// 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);
char buffer[20];
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "Preset %d saved", self->selectionIndex);
Display_write(self->display, buffer, 3, 2);
vTaskDelay(2000);
}
static void repairMenu_printConfigPreset(struct MenuCore* self)
{
int loopCounter;
char buffer[self->display->displayDevice->parameters.numberOfColumns];
// Print the preset information of the current preset under the cursor, NOT the preset that is currently selected
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "Preset %d info", self->selectionIndex);
// Always print Row1 (index0), ignoring the scrolling index
Display_write(self->display, buffer, 1, 1);
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "Start:");
Display_write(self->display, buffer, 2, 1);
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "Time:");
Display_write(self->display, buffer, 3, 1);
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "Volt:");
Display_write(self->display, buffer, 4, 1);
for (loopCounter = 0; loopCounter < RepairPresets_getPreset(self->selectionIndex)->numberOfStages; loopCounter++)
{
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5dm", (RepairPresets_getPreset(self->selectionIndex)->preset[loopCounter].softstartDuration / 60));
Display_write(self->display, buffer, 2, 8 + loopCounter * 7);
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5dm", (RepairPresets_getPreset(self->selectionIndex)->preset[loopCounter].duration / 60));
Display_write(self->display, buffer, 3, 8 + loopCounter * 7);
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5dV", RepairPresets_getPreset(self->selectionIndex)->preset[loopCounter].voltage);
Display_write(self->display, buffer, 4, 8 + loopCounter * 7);
}
}
static void repairMenu_printInfo(struct MenuCore* self)
{
Display_write(mainDisplay, PCBA_getInstance()->name, 3, 2);
char buffer[20];
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "SW V. %d.%d.%d.%d", Version_getInstance()->major,
Version_getInstance()->minor,
Version_getInstance()->branch,
Version_getInstance()->patch);
Display_write(mainDisplay, buffer, 4, 4);
}
static void repairMenu_selectCathodeRepair(struct MenuCore* self)
{
@@ -351,11 +557,11 @@ static void repairMenu_selectMCPRepair(struct MenuCore* self)
static void repairMenu_selectPreset(struct MenuCore* self)
{
struct RepairMenu* tempMenu = repairMenus_getMainRepairMenu();
tempMenu->repairPreset = RepairPresets_getPreset(self->cursorIndex);
tempMenu->repairPreset = RepairPresets_getPreset(self->selectionIndex);
Display_clearScreen(self->display);
char buffer[20];
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "Preset %d selected", self->cursorIndex);
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "Preset %d selected", self->selectionIndex);
Display_write(self->display, buffer, 3, 2);
vTaskDelay(2000);
}
@@ -372,6 +578,17 @@ 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)
{
@@ -527,6 +744,81 @@ void repairMenu_menuStateHandle(struct MenuCore* self)
{
repairMenu_printFinish(self);
}
else if (self->menuState == RM_ADMIN_IO_INTERLOCK)
{
// Show the current INTERLOCK status
repairMenu_printIOInterlockStatus(self);
}
else if (self->menuState == RM_ADMIN_INFO)
{
repairMenu_printInfo(self);
}
else if (self->menuState == RM_ADMIN_CHANGEPIN)
{
repairMenu_printChangePinScreen(self);
}
else if (self->menuState == RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART)
{
repairMenu_printConfigPreset(self);
char buffer[7];
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%4d", self->insertValue);
Display_write(self->display, buffer, 2, 9);
Display_setCursorToPosition(self->display, 2, 12);
Display_setBlinkingCursorState(self->display, ON);
}
else if (self->menuState == RM_ADMIN_PRESET_CONFIG_FIRST_DURATION)
{
repairMenu_printConfigPreset(self);
char buffer[7];
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%4d", self->insertValue);
Display_write(self->display, buffer, 3, 9);
Display_setCursorToPosition(self->display, 3, 12);
Display_setBlinkingCursorState(self->display, ON);
}
else if (self->menuState == RM_ADMIN_PRESET_CONFIG_FIRST_VOLTAGE)
{
repairMenu_printConfigPreset(self);
char buffer[7];
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5d", self->insertValue);
Display_write(self->display, buffer, 4, 8);
Display_setCursorToPosition(self->display, 4, 12);
Display_setBlinkingCursorState(self->display, ON);
}
else if (self->menuState == RM_ADMIN_PRESET_CONFIG_SECOND_SOFTSTART)
{
repairMenu_printConfigPreset(self);
char buffer[7];
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5d", self->insertValue);
Display_write(self->display, buffer, 2, 15);
Display_setCursorToPosition(self->display, 2, 19);
Display_setBlinkingCursorState(self->display, ON);
}
else if (self->menuState == RM_ADMIN_PRESET_CONFIG_SECOND_DURATION)
{
repairMenu_printConfigPreset(self);
char buffer[7];
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5d", self->insertValue);
Display_write(self->display, buffer, 3, 15);
Display_setCursorToPosition(self->display, 3, 19);
Display_setBlinkingCursorState(self->display, ON);
}
else if (self->menuState == RM_ADMIN_PRESET_CONFIG_SECOND_VOLTAGE)
{
repairMenu_printConfigPreset(self);
char buffer[7];
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%5d", self->insertValue);
Display_write(self->display, buffer, 4, 15);
Display_setCursorToPosition(self->display, 4, 19);
Display_setBlinkingCursorState(self->display, ON);
}
}
@@ -534,18 +826,30 @@ void repairMenu_menuStateHandle(struct MenuCore* self)
void repairMenu_createMenuEntries(struct MenuCore* menuCore)
{
/* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
* 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[MENUTEXT_ENGLISH][1], RM_CATHODEMCP_SELECT, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_MAINMENU], MenuText_MAINMENU[MENUTEXT_ENGLISH][1], RM_REPAIR_CATHODEMCP_SELECT, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_MAINMENU], MenuText_MAINMENU[MENUTEXT_ENGLISH][2], RM_ADMIN_CATHODEMCP_SELECT, NULL);
}
else
{
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_MAINMENU], MenuText_MAINMENU[MENUTEXT_ENGLISH][1], RM_REPAIRMENU, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_MAINMENU], MenuText_MAINMENU[MENUTEXT_ENGLISH][2], RM_ADMINMENU, NULL);
}
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_MAINMENU], MenuText_MAINMENU[MENUTEXT_ENGLISH][2], RM_ADMINMENU, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_MAINMENU], MenuText_MAINMENU[MENUTEXT_ENGLISH][3], RM_CALIBRATIONMENU, NULL);
MenuElements_addKeyAction_SCROLLUP(&menuCore->menuArray[RM_MAINMENU], 'U', PRESSED);
MenuElements_addKeyAction_SCROLLDOWN(&menuCore->menuArray[RM_MAINMENU], 'D', PRESSED);
@@ -556,19 +860,35 @@ void repairMenu_createMenuEntries(struct MenuCore* menuCore)
MenuElements_addKeyAction_EXECUTEFUNCTION(&menuCore->menuArray[RM_MAINMENU], '0', PRESSED, repairMenu_solenoidUnlock);
MenuElements_addKeyAction_EXECUTEFUNCTION(&menuCore->menuArray[RM_MAINMENU], '0', RELEASED, repairMenu_solenoidLock);
MenuElements_createMenuPage(&menuCore->menuArray[RM_CATHODEMCP_SELECT], MENU_HAS_CURSOR, 3);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_CATHODEMCP_SELECT], MenuText_CATHODEMCP_SELECT[MENUTEXT_ENGLISH][0], RM_CATHODEMCP_SELECT, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_CATHODEMCP_SELECT], MenuText_CATHODEMCP_SELECT[MENUTEXT_ENGLISH][1], RM_REPAIRMENU, repairMenu_selectCathodeRepair);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_CATHODEMCP_SELECT], MenuText_CATHODEMCP_SELECT[MENUTEXT_ENGLISH][2], RM_REPAIRMENU, repairMenu_selectMCPRepair);
MenuElements_addKeyAction_SCROLLUP(&menuCore->menuArray[RM_CATHODEMCP_SELECT], 'U', PRESSED);
MenuElements_addKeyAction_SCROLLDOWN(&menuCore->menuArray[RM_CATHODEMCP_SELECT], 'D', PRESSED);
MenuElements_addKeyAction_SELECT(&menuCore->menuArray[RM_CATHODEMCP_SELECT], 'E', PRESSED);
MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_CATHODEMCP_SELECT], '1', PRESSED, 1);
MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_CATHODEMCP_SELECT], '2', PRESSED, 2);
MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_CATHODEMCP_SELECT], 'X', PRESSED, RM_MAINMENU);
MenuElements_addKeyAction_EXECUTEFUNCTION(&menuCore->menuArray[RM_CATHODEMCP_SELECT], '0', PRESSED, repairMenu_solenoidUnlock);
MenuElements_addKeyAction_EXECUTEFUNCTION(&menuCore->menuArray[RM_CATHODEMCP_SELECT], '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[MENUTEXT_ENGLISH][0], RM_REPAIR_CATHODEMCP_SELECT, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_REPAIR_CATHODEMCP_SELECT], MenuText_CATHODEMCP_SELECT[MENUTEXT_ENGLISH][1], RM_REPAIRMENU, repairMenu_selectCathodeRepair);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_REPAIR_CATHODEMCP_SELECT], MenuText_CATHODEMCP_SELECT[MENUTEXT_ENGLISH][2], RM_REPAIRMENU, repairMenu_selectMCPRepair);
MenuElements_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[MENUTEXT_ENGLISH][0], RM_REPAIRMENU, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_REPAIRMENU], MenuText_REPAIRMENU[MENUTEXT_ENGLISH][1], RM_PRESETMENU, NULL);
@@ -581,7 +901,7 @@ void repairMenu_createMenuEntries(struct MenuCore* menuCore)
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_CATHODEMCP_SELECT);
MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_REPAIRMENU], 'X', PRESSED, RM_REPAIR_CATHODEMCP_SELECT);
}
else
{
@@ -591,20 +911,14 @@ void repairMenu_createMenuEntries(struct MenuCore* menuCore)
MenuElements_addKeyAction_EXECUTEFUNCTION(&menuCore->menuArray[RM_REPAIRMENU], '0', PRESSED, repairMenu_solenoidUnlock);
MenuElements_addKeyAction_EXECUTEFUNCTION(&menuCore->menuArray[RM_REPAIRMENU], '0', RELEASED, repairMenu_solenoidLock);
MenuElements_createMenuPage(&menuCore->menuArray[RM_ADMINMENU], MENU_HAS_NO_CURSOR, 2);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMINMENU], MenuText_ADMINMENU[MENUTEXT_ENGLISH][0], RM_ADMINMENU, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMINMENU], MenuText_ADMINMENU[MENUTEXT_ENGLISH][1], RM_ADMINMENU, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMINMENU], MenuText_ADMINMENU[MENUTEXT_ENGLISH][2], RM_ADMINMENU, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMINMENU], MenuText_ADMINMENU[MENUTEXT_ENGLISH][3], RM_ADMINMENU, NULL);
MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_ADMINMENU], 'X', PRESSED, RM_MAINMENU);
MenuElements_createMenuPage(&menuCore->menuArray[RM_CALIBRATIONMENU], MENU_HAS_NO_CURSOR, 2);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_CALIBRATIONMENU], MenuText_CALIBRATIONMENU[MENUTEXT_ENGLISH][0], RM_CALIBRATIONMENU, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_CALIBRATIONMENU], MenuText_CALIBRATIONMENU[MENUTEXT_ENGLISH][1], RM_CALIBRATIONMENU, NULL);
MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_CALIBRATIONMENU], 'X', PRESSED, RM_MAINMENU);
/* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
* 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[MENUTEXT_ENGLISH][0], RM_PRESETMENU, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_PRESETMENU], MenuText_PRESETMENU[MENUTEXT_ENGLISH][1], RM_REPAIRMENU, repairMenu_selectPreset);
@@ -633,10 +947,341 @@ void repairMenu_createMenuEntries(struct MenuCore* menuCore)
MenuElements_addKeyAction_EXECUTEFUNCTION(&menuCore->menuArray[RM_PRESETMENU], '0', RELEASED, repairMenu_solenoidLock);
MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_PRESETMENU], 'R', PRESSED, RM_PRESET_PRINT);
MenuElements_createMenuPage(&menuCore->menuArray[RM_PRESET_PRINT], MENU_HAS_NO_CURSOR, 10);
/* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
* 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 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[MENUTEXT_ENGLISH][0], RM_ADMIN_CATHODEMCP_SELECT, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_CATHODEMCP_SELECT], MenuText_ADMIN_CATHODEMCP_SELECT[MENUTEXT_ENGLISH][1], RM_ADMINMENU, repairMenu_selectCathodeRepair);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_CATHODEMCP_SELECT], MenuText_ADMIN_CATHODEMCP_SELECT[MENUTEXT_ENGLISH][2], RM_ADMINMENU, 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_MAINMENU);
/* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
* 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, 5);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMINMENU], MenuText_ADMINMENU[MENUTEXT_ENGLISH][0], RM_ADMINMENU, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMINMENU], MenuText_ADMINMENU[MENUTEXT_ENGLISH][1], RM_ADMIN_CHANGEPIN, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMINMENU], MenuText_ADMINMENU[MENUTEXT_ENGLISH][2], RM_ADMIN_IOCONTROL, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMINMENU], MenuText_ADMINMENU[MENUTEXT_ENGLISH][3], RM_ADMIN_PRESET_CONFIG_SELECT, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMINMENU], MenuText_ADMINMENU[MENUTEXT_ENGLISH][4], RM_ADMIN_INFO, NULL);
if (PCBA_getInstance()->pcba == PCBA_CathodeMCP)
{
MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_ADMINMENU], 'X', PRESSED, RM_ADMIN_CATHODEMCP_SELECT);
}
else
{
MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_ADMINMENU], 'X', PRESSED, RM_MAINMENU);
}
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_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);
/* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
* ADMIN change pin
* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
*/
MenuElements_createMenuPage(&menuCore->menuArray[RM_ADMIN_CHANGEPIN], MENU_HAS_NO_CURSOR, 5);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_CHANGEPIN], MenuText_ADMINCHANGEPINMENU[MENUTEXT_ENGLISH][0], RM_ADMIN_CHANGEPIN, NULL);
MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_ADMIN_CHANGEPIN], 'X', PRESSED, RM_ADMINMENU);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_CHANGEPIN], '0', PRESSED, 4);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_CHANGEPIN], '1', PRESSED, 4);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_CHANGEPIN], '2', PRESSED, 4);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_CHANGEPIN], '3', PRESSED, 4);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_CHANGEPIN], '4', PRESSED, 4);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_CHANGEPIN], '5', PRESSED, 4);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_CHANGEPIN], '6', PRESSED, 4);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_CHANGEPIN], '7', PRESSED, 4);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_CHANGEPIN], '8', PRESSED, 4);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_CHANGEPIN], '9', PRESSED, 4);
MenuElements_addKeyAction_DIGITREMOVE(&menuCore->menuArray[RM_ADMIN_CHANGEPIN], 'L', PRESSED);
/* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
* 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[MENUTEXT_ENGLISH][0], RM_ADMIN_IOCONTROL, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_IOCONTROL], MenuText_ADMINIOMAINMENU[MENUTEXT_ENGLISH][1], RM_ADMIN_IO_INTERLOCK, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_IOCONTROL], MenuText_ADMINIOMAINMENU[MENUTEXT_ENGLISH][2], RM_ADMIN_IO_SOLENOID, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_IOCONTROL], MenuText_ADMINIOMAINMENU[MENUTEXT_ENGLISH][3], RM_ADMIN_IO_VOLTAGE_IN, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_IOCONTROL], MenuText_ADMINIOMAINMENU[MENUTEXT_ENGLISH][4], RM_ADMIN_IO_VOLTAGE_OUT, NULL);
if (PCBA_getInstance()->pcba == PCBA_Tesla)
{
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_IOCONTROL], MenuText_ADMINIOMAINMENU[MENUTEXT_ENGLISH][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[MENUTEXT_ENGLISH][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[MENUTEXT_ENGLISH][0], RM_ADMIN_IO_SOLENOID, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_IO_SOLENOID], MenuText_ADMINSOLENOIDMENU[MENUTEXT_ENGLISH][1], RM_ADMIN_IO_SOLENOID, NULL);
MenuElements_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 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[MENUTEXT_ENGLISH][0], RM_ADMIN_IO_TESLAGUN, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_IO_TESLAGUN], MenuText_ADMINTESLAGUNMENU[MENUTEXT_ENGLISH][1], RM_ADMIN_IO_TESLAGUN, NULL);
MenuElements_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[MENUTEXT_ENGLISH][0], RM_ADMIN_PRESET_CONFIG_SELECT, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SELECT], MenuText_ADMINPRESETCONFIGSELECTMENU[MENUTEXT_ENGLISH][1], RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART, repairMenu_configPresetFirstSoftstart);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SELECT], MenuText_ADMINPRESETCONFIGSELECTMENU[MENUTEXT_ENGLISH][2], RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART, repairMenu_configPresetFirstSoftstart);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SELECT], MenuText_ADMINPRESETCONFIGSELECTMENU[MENUTEXT_ENGLISH][3], RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART, repairMenu_configPresetFirstSoftstart);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SELECT], MenuText_ADMINPRESETCONFIGSELECTMENU[MENUTEXT_ENGLISH][4], RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART, repairMenu_configPresetFirstSoftstart);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SELECT], MenuText_ADMINPRESETCONFIGSELECTMENU[MENUTEXT_ENGLISH][5], RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART, repairMenu_configPresetFirstSoftstart);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SELECT], MenuText_ADMINPRESETCONFIGSELECTMENU[MENUTEXT_ENGLISH][6], RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART, repairMenu_configPresetFirstSoftstart);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SELECT], MenuText_ADMINPRESETCONFIGSELECTMENU[MENUTEXT_ENGLISH][7], RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART, repairMenu_configPresetFirstSoftstart);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SELECT], MenuText_ADMINPRESETCONFIGSELECTMENU[MENUTEXT_ENGLISH][8], RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART, repairMenu_configPresetFirstSoftstart);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SELECT], MenuText_ADMINPRESETCONFIGSELECTMENU[MENUTEXT_ENGLISH][9], RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART, repairMenu_configPresetFirstSoftstart);
MenuElements_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);
MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SELECT], 'X', PRESSED, RM_ADMINMENU);
/* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
* ADMIN preset config
* Select the repair preset to configure/modify
*
* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
*/
unsigned int numberOfDigits = 0;
if (PCBA_getInstance()->pcba == PCBA_Anode)
{
numberOfDigits = 5;
}
else if (PCBA_getInstance()->pcba == PCBA_CathodeMCP)
{
numberOfDigits = 4;
}
else if (PCBA_getInstance()->pcba == PCBA_Tesla)
{
numberOfDigits = 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, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART], '1', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART], '2', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART], '3', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART], '4', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART], '5', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART], '6', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART], '7', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART], '8', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_SOFTSTART], '9', PRESSED, numberOfDigits);
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, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_DURATION], '1', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_DURATION], '2', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_DURATION], '3', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_DURATION], '4', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_DURATION], '5', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_DURATION], '6', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_DURATION], '7', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_DURATION], '8', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_DURATION], '9', PRESSED, numberOfDigits);
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, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_VOLTAGE], '1', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_VOLTAGE], '2', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_VOLTAGE], '3', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_VOLTAGE], '4', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_VOLTAGE], '5', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_VOLTAGE], '6', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_VOLTAGE], '7', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_VOLTAGE], '8', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_FIRST_VOLTAGE], '9', PRESSED, numberOfDigits);
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, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_SOFTSTART], '1', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_SOFTSTART], '2', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_SOFTSTART], '3', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_SOFTSTART], '4', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_SOFTSTART], '5', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_SOFTSTART], '6', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_SOFTSTART], '7', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_SOFTSTART], '8', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_SOFTSTART], '9', PRESSED, numberOfDigits);
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, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_DURATION], '1', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_DURATION], '2', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_DURATION], '3', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_DURATION], '4', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_DURATION], '5', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_DURATION], '6', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_DURATION], '7', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_DURATION], '8', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_DURATION], '9', PRESSED, numberOfDigits);
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, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_VOLTAGE], '1', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_VOLTAGE], '2', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_VOLTAGE], '3', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_VOLTAGE], '4', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_VOLTAGE], '5', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_VOLTAGE], '6', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_VOLTAGE], '7', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_VOLTAGE], '8', PRESSED, numberOfDigits);
MenuElements_addKeyAction_DIGITINSERT(&menuCore->menuArray[RM_ADMIN_PRESET_CONFIG_SECOND_VOLTAGE], '9', PRESSED, numberOfDigits);
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);
/* -------------------------------------------------------------------------------------------------------------------------------------------------------------------
* 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[MENUTEXT_ENGLISH][0], RM_ADMIN_INFO, NULL);
MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_ADMIN_INFO], 'X', PRESSED, RM_ADMINMENU);
MenuElements_createMenuPage(&menuCore->menuArray[RM_CALIBRATIONMENU], MENU_HAS_NO_CURSOR, 2);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_CALIBRATIONMENU], MenuText_CALIBRATIONMENU[MENUTEXT_ENGLISH][0], RM_CALIBRATIONMENU, NULL);
MenuElements_addMenuPageRow(&menuCore->menuArray[RM_CALIBRATIONMENU], MenuText_CALIBRATIONMENU[MENUTEXT_ENGLISH][1], RM_CALIBRATIONMENU, NULL);
MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_CALIBRATIONMENU], 'X', PRESSED, RM_MAINMENU);
MenuElements_createMenuPage(&menuCore->menuArray[RM_REPAIR_RUNNING], MENU_HAS_NO_CURSOR, 4);
MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_REPAIR_RUNNING], 'X', PRESSED, RM_REPAIR_ASK_PAUSE);