Most parts of the menu structure are functional.
Error handler added Screens for warning, pause, FINISH etc yet to be added git-svn-id: https://svn.vbchaos.nl/svn/hsb/trunk@255 05563f52-14a8-4384-a975-3d1654cca0fa
This commit is contained in:
mmi
@@ -31,8 +31,11 @@
|
||||
#include "repairProcess.h"
|
||||
|
||||
#include "Display.h"
|
||||
#include "Error.h"
|
||||
#include "hsb-mrts.h"
|
||||
|
||||
#include "Logger.h"
|
||||
#include "Interlock.h"
|
||||
#include "internalADC.h"
|
||||
#include "MAX5715.h"
|
||||
|
||||
@@ -64,8 +67,8 @@ static const char cursorValue = 0x7E;
|
||||
|
||||
|
||||
// TEMPORARY PRESET STORAGE
|
||||
static const struct RepairPreset preset1 = {.numberOfStages = 1, .preset[0].softstartDuration = 100, .preset[0].duration = 200, .preset[0].voltage = 100};
|
||||
static const struct RepairPreset preset2 = {.numberOfStages = 1, .preset[0].softstartDuration = 200, .preset[0].duration = 400, .preset[0].voltage = 200};
|
||||
static const struct RepairPreset preset1 = {.numberOfStages = 1, .preset[0].softstartDuration = 100, .preset[0].duration = 200, .preset[0].voltage = 1000};
|
||||
static const struct RepairPreset preset2 = {.numberOfStages = 1, .preset[0].softstartDuration = 200, .preset[0].duration = 400, .preset[0].voltage = 3000};
|
||||
static const struct RepairPreset preset3 = {.numberOfStages = 1, .preset[0].softstartDuration = 300, .preset[0].duration = 600, .preset[0].voltage = 300};
|
||||
static const struct RepairPreset preset4 = {.numberOfStages = 1, .preset[0].softstartDuration = 400, .preset[0].duration = 800, .preset[0].voltage = 400};
|
||||
static const struct RepairPreset preset5 = {.numberOfStages = 1, .preset[0].softstartDuration = 500, .preset[0].duration = 1000, .preset[0].voltage = 500};
|
||||
@@ -80,24 +83,35 @@ static const struct RepairPreset* presetArray[9] = {&preset1, &preset2, &preset3
|
||||
// -----------------------------------------------------------------------------
|
||||
|
||||
static void repairMenu_task(void* parameters);
|
||||
|
||||
static void repairMenu_changeState(struct RepairMenu* self, T_MenuState newState);
|
||||
static void repairMenu_printError(struct RepairMenu* self);
|
||||
static void repairMenu_printWarning(struct RepairMenu* self);
|
||||
static void repairMenu_printRepair(struct RepairMenu* self);
|
||||
static void repairMenu_printMenu(struct RepairMenu* self);
|
||||
static void repairMenu_printCursor(struct RepairMenu* self);
|
||||
static void repairMenu_performAction(struct RepairMenu* self, char key);
|
||||
static struct KeyActionBinding repairMenu_findKeyAction(struct RepairMenu* self, char key);
|
||||
static ErrorStatus repairMenu_performAction(struct RepairMenu* self, char key, Keypad_KeyState keyState);
|
||||
static struct KeyActionBinding repairMenu_findKeyAction(struct RepairMenu* self, char key, Keypad_KeyState keyState);
|
||||
static void repairMenu_scrollIndexHandlerReset (struct RepairMenu* self);
|
||||
static void repairMenu_scrollUpIndexHandler(struct RepairMenu* self);
|
||||
static void repairMenu_scrollDownIndexHandler(struct RepairMenu* self);
|
||||
static void repairMenu_startRepairProcess(struct RepairMenu* self, int cursorIndex);
|
||||
static void repairMenu_abortRepairProcess(struct RepairMenu* self);
|
||||
static ErrorStatus repairMenu_feedProcessSecondsCounter(const void* const data);
|
||||
|
||||
static void repairMenu_selectPreset(struct RepairMenu* self, int cursorIndex);
|
||||
|
||||
static void repairMenu_solenoidLock(struct RepairMenu* self, int cursorIndex);
|
||||
static void repairMenu_solenoidUnlock(struct RepairMenu* self, int cursorIndex);
|
||||
|
||||
static ErrorStatus repairMenu_createMenu(struct RepairMenu* self);
|
||||
static ErrorStatus repairMenu_createMenuPage (struct MenuPage* self, bool hasCursor, int numberOfRows);
|
||||
static ErrorStatus repairMenu_addMenuPageRow (struct MenuPage* self, int rowIndex, char* text, int newState, RepairMenuFunctionCall actionCall);
|
||||
static ErrorStatus repairMenu_addMenuPageKeyAction (struct MenuPage* self, int keyActionIndex, char key, T_KeyAction action, int argument);
|
||||
static ErrorStatus repairMenu_createMenuPage (struct MenuPage* self, bool hasCursor, int maxNumberOfRows);
|
||||
static ErrorStatus repairMenu_addMenuPageRow (struct MenuPage* self, char* text, int newState, RepairMenuFunctionCall actionCall);
|
||||
static ErrorStatus repairMenu_addKeyAction_HOTKEYSELECT (struct MenuPage* self, char key, Keypad_KeyState keyState, int rowToSelect);
|
||||
static ErrorStatus repairMenu_addKeyAction_SELECT (struct MenuPage* self, char key, Keypad_KeyState keyState);
|
||||
static ErrorStatus repairMenu_addKeyAction_GOTOSTATE (struct MenuPage* self, char key, Keypad_KeyState keyState, T_MenuState state);
|
||||
static ErrorStatus repairMenu_addKeyAction_EXECUTEFUNCTION (struct MenuPage* self, char key, Keypad_KeyState keyState, RepairMenuFunctionCall actionPointer);
|
||||
static ErrorStatus repairMenu_addKeyAction_SCROLLUP (struct MenuPage* self, char key, Keypad_KeyState keyState);
|
||||
static ErrorStatus repairMenu_addKeyAction_SCROLLDOWN (struct MenuPage* self, char key, Keypad_KeyState keyState);
|
||||
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// Function definitions
|
||||
@@ -136,15 +150,11 @@ ErrorStatus repairMenu_construct(struct RepairMenu* self, struct Display* displa
|
||||
|
||||
if (returnValue == SUCCESS)
|
||||
{
|
||||
// Create a semaphore to sync access to the display shadow
|
||||
vSemaphoreCreateBinary(self->secondsSyncronisation);
|
||||
xSemaphoreGive(self->secondsSyncronisation);
|
||||
|
||||
// Construct the menu based on PCBA information
|
||||
returnValue = repairMenu_createMenu(self);
|
||||
|
||||
|
||||
self->menuState = MAINMENU;
|
||||
repairMenu_changeState(self, MAINMENU);
|
||||
self->runTask = true;
|
||||
|
||||
BaseType_t rv = xTaskCreate(repairMenu_task, "RepairMenu", stackSize, self, taskPriority, &self->taskHandle);
|
||||
@@ -177,27 +187,17 @@ void repairMenu_destruct (struct RepairMenu* self)
|
||||
}
|
||||
|
||||
|
||||
void repairMenu_feedSecondsCounter(struct RepairMenu* self)
|
||||
void repairMenu_interlockFailed(struct RepairMenu* self, T_INTERLOCK_ID interlockID)
|
||||
{
|
||||
if (self->initialized)
|
||||
repairMenu_changeState(self, ERROR_STATE);
|
||||
if (interlockID == COMMON_INTERLOCK)
|
||||
{
|
||||
xSemaphoreGive(self->secondsSyncronisation);
|
||||
snprintf(self->errorMessage, sizeof(self->errorMessage) / sizeof(self->errorMessage[0]), "COVER OPEN");
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
void repairMenu_feedSecondsCounterFromISR(struct RepairMenu* self)
|
||||
{
|
||||
portBASE_TYPE higherPriorityTaskWoken = pdFALSE;
|
||||
|
||||
if (self->initialized)
|
||||
else if (interlockID == TESLA_INTERLOCK)
|
||||
{
|
||||
xSemaphoreGiveFromISR(self->secondsSyncronisation, &higherPriorityTaskWoken);
|
||||
snprintf(self->errorMessage, sizeof(self->errorMessage) / sizeof(self->errorMessage[0]), "SAFETY TUBE MISSING");
|
||||
}
|
||||
|
||||
portEND_SWITCHING_ISR(higherPriorityTaskWoken);
|
||||
|
||||
}
|
||||
|
||||
|
||||
@@ -205,30 +205,51 @@ static void repairMenu_task(void* parameters)
|
||||
{
|
||||
struct RepairMenu* self = (struct RepairMenu*)parameters;
|
||||
|
||||
// Clear the screen for a new menu
|
||||
Display_clearScreen(self->display);
|
||||
// Print menu content to output device
|
||||
repairMenu_printMenu(self);
|
||||
// Add cursor if necessary
|
||||
repairMenu_printCursor(self);
|
||||
|
||||
while(self->runTask)
|
||||
{
|
||||
char key;
|
||||
Keypad_KeyState keyState;
|
||||
|
||||
// Clear the screen for a new menu
|
||||
Display_clearScreen(self->display);
|
||||
// Print menu content to output device
|
||||
repairMenu_printMenu(self);
|
||||
// Add cursor if necessary
|
||||
repairMenu_printCursor(self);
|
||||
|
||||
while (KeyboardDevice_read(&storm700->keyboardDevice, &key, &keyState) != SUCCESS)
|
||||
// Catch ERROR state
|
||||
if (self->menuState == ERROR_STATE)
|
||||
{
|
||||
vTaskDelay(10);
|
||||
// Show ERROR message
|
||||
repairMenu_printError(self);
|
||||
// Handle error
|
||||
repairMenu_abortRepairProcess(self);
|
||||
}
|
||||
else if (self->menuState == WARNING_STATE)
|
||||
{
|
||||
|
||||
}
|
||||
else if (self->menuState == REPAIR_RUNNING)
|
||||
{
|
||||
// Create the repair screen
|
||||
repairMenu_printRepair(self);
|
||||
}
|
||||
|
||||
if (keyState == self->keyStateTrigger)
|
||||
if (KeyboardDevice_read(&storm700->keyboardDevice, &key, &keyState) == SUCCESS)
|
||||
{
|
||||
repairMenu_performAction(self, key);
|
||||
if (repairMenu_performAction(self, key, keyState) == SUCCESS)
|
||||
{
|
||||
// The key had an action
|
||||
// Clear the screen for a new menu
|
||||
Display_clearScreen(self->display);
|
||||
// Print menu content to output device
|
||||
repairMenu_printMenu(self);
|
||||
// Add cursor if necessary
|
||||
repairMenu_printCursor(self);
|
||||
LOGGER_WARNING(mainLog, "menu index is %d", self->menuState);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
vTaskDelay(50);
|
||||
}
|
||||
|
||||
LOGGER_INFO(mainLog, "Deleting RepairMenu task");
|
||||
@@ -236,6 +257,64 @@ static void repairMenu_task(void* parameters)
|
||||
}
|
||||
|
||||
|
||||
static void repairMenu_changeState(struct RepairMenu* self, T_MenuState newState)
|
||||
{
|
||||
Display_clearScreen(self->display);
|
||||
self->menuState = newState;
|
||||
}
|
||||
|
||||
static void repairMenu_printError(struct RepairMenu* self)
|
||||
{
|
||||
Display_write(self->display, "!!ERROR!!", strlen("!!ERROR!!"), 2, 6);
|
||||
Display_write(self->display, self->errorMessage, strlen(self->errorMessage), 3, 1 + ((self->display->displayDevice->parameters.numberOfColumns - strlen(self->errorMessage)) / 2));
|
||||
}
|
||||
|
||||
|
||||
static void repairMenu_printWarning(struct RepairMenu* self)
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
|
||||
static void repairMenu_printRepair(struct RepairMenu* self)
|
||||
{
|
||||
uint32_t rpSecondsCounter;
|
||||
int hoursToRemain;
|
||||
int minutesToRemain;
|
||||
int secondsToRemain;
|
||||
char buffer[20];
|
||||
repairProcess_getRepairTime(&self->repairProcess, &rpSecondsCounter, &hoursToRemain, &minutesToRemain, &secondsToRemain);
|
||||
|
||||
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), " %02d:%02d:%02d remain", hoursToRemain, minutesToRemain, secondsToRemain);
|
||||
Display_write(self->display, buffer, strlen(buffer), 2, 1);
|
||||
|
||||
if (PCBA_getInstance()->pcba == Tesla)
|
||||
{
|
||||
Display_write(self->display, "R2", strlen("R2"), 3, 10);
|
||||
uint16_t value;
|
||||
ADCChannel_read(self->repairProcess.adc[1], &value);
|
||||
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%05dV", value);
|
||||
Display_write(self->display, buffer, strlen(buffer), 4, 8);
|
||||
}
|
||||
else if ((PCBA_getInstance()->pcba == Anode) || (PCBA_getInstance()->pcba == CathodeMCP))
|
||||
{
|
||||
Display_write(self->display, "R1", strlen("R1"), 3, 3);
|
||||
Display_write(self->display, "R2", strlen("R2"), 3, 10);
|
||||
Display_write(self->display, "R3", strlen("R3"), 3, 17);
|
||||
|
||||
uint16_t value;
|
||||
ADCChannel_read(self->repairProcess.adc[0], &value);
|
||||
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%05dV", value);
|
||||
Display_write(self->display, buffer, strlen(buffer), 4, 1);
|
||||
ADCChannel_read(self->repairProcess.adc[1], &value);
|
||||
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%05dV", value);
|
||||
Display_write(self->display, buffer, strlen(buffer), 4, 8);
|
||||
ADCChannel_read(self->repairProcess.adc[2], &value);
|
||||
snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%05dV", value);
|
||||
Display_write(self->display, buffer, strlen(buffer), 4, 15);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static void repairMenu_printMenu(struct RepairMenu* self)
|
||||
{
|
||||
@@ -260,9 +339,11 @@ static void repairMenu_printCursor(struct RepairMenu* self)
|
||||
}
|
||||
|
||||
|
||||
static void repairMenu_performAction(struct RepairMenu* self, char key)
|
||||
static ErrorStatus repairMenu_performAction(struct RepairMenu* self, char key, Keypad_KeyState keyState)
|
||||
{
|
||||
struct KeyActionBinding keyAction = repairMenu_findKeyAction(self, key);
|
||||
ErrorStatus returnValue = SUCCESS;
|
||||
|
||||
struct KeyActionBinding keyAction = repairMenu_findKeyAction(self, key, keyState);
|
||||
LOGGER_DEBUG(mainLog, "Action: received key %c, action to perform %d,", key, keyAction.action);
|
||||
|
||||
switch (keyAction.action)
|
||||
@@ -270,17 +351,19 @@ static void repairMenu_performAction(struct RepairMenu* self, char key)
|
||||
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);
|
||||
if (self->menuArray[self->menuState].row[keyAction.argument].actionPointer != NULL)
|
||||
T_MenuState tempState = self->menuState;
|
||||
repairMenu_changeState(self, self->menuArray[self->menuState].row[keyAction.argument].newState);
|
||||
if (self->menuArray[tempState].row[keyAction.argument].actionPointer != NULL)
|
||||
{
|
||||
self->menuArray[self->menuState].row[keyAction.argument].actionPointer(self, keyAction.argument);
|
||||
self->menuArray[tempState].row[keyAction.argument].actionPointer(self, keyAction.argument);
|
||||
}
|
||||
self->menuState = self->menuArray[self->menuState].row[keyAction.argument].newState;
|
||||
repairMenu_scrollIndexHandlerReset(self);
|
||||
break;
|
||||
}
|
||||
@@ -288,15 +371,33 @@ static void repairMenu_performAction(struct RepairMenu* self, char key)
|
||||
case SELECT:
|
||||
{
|
||||
LOGGER_INFO(mainLog, "SELECT ITEM %d - going to state %d", self->cursorIndex, self->menuArray[self->menuState].row[self->cursorIndex].newState);
|
||||
if (self->menuArray[self->menuState].row[self->cursorIndex].actionPointer != NULL)
|
||||
T_MenuState tempState = self->menuState;
|
||||
repairMenu_changeState(self, self->menuArray[self->menuState].row[self->cursorIndex].newState);
|
||||
if (self->menuArray[tempState].row[self->cursorIndex].actionPointer != NULL)
|
||||
{
|
||||
self->menuArray[self->menuState].row[self->cursorIndex].actionPointer(self, self->cursorIndex);
|
||||
self->menuArray[tempState].row[self->cursorIndex].actionPointer(self, self->cursorIndex);
|
||||
}
|
||||
self->menuState = self->menuArray[self->menuState].row[self->cursorIndex].newState;
|
||||
repairMenu_scrollIndexHandlerReset(self);
|
||||
break;
|
||||
}
|
||||
|
||||
case GOTO_STATE:
|
||||
{
|
||||
LOGGER_INFO(mainLog, "Going to new state %d directly", keyAction.argument);
|
||||
repairMenu_changeState(self, keyAction.argument);
|
||||
break;
|
||||
}
|
||||
|
||||
case EXECUTE_FUNCTION:
|
||||
{
|
||||
LOGGER_INFO(mainLog, "Executing function directly");
|
||||
if (keyAction.actionPointer != NULL)
|
||||
{
|
||||
keyAction.actionPointer(self, 0);
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
case SCROLL_UP:
|
||||
{
|
||||
LOGGER_INFO(mainLog, "Scrolling up");
|
||||
@@ -315,10 +416,11 @@ static void repairMenu_performAction(struct RepairMenu* self, char key)
|
||||
break;
|
||||
}
|
||||
}
|
||||
return returnValue;
|
||||
}
|
||||
|
||||
|
||||
static struct KeyActionBinding repairMenu_findKeyAction(struct RepairMenu* self, char key)
|
||||
static struct KeyActionBinding repairMenu_findKeyAction(struct RepairMenu* self, char key, Keypad_KeyState keyState)
|
||||
{
|
||||
int loopCounter;
|
||||
struct KeyActionBinding returnValue;
|
||||
@@ -326,7 +428,7 @@ static struct KeyActionBinding repairMenu_findKeyAction(struct RepairMenu* self,
|
||||
|
||||
for (loopCounter = 0; loopCounter < REPAIRMENU_MAX_NUMBER_OF_KEYS; loopCounter++)
|
||||
{
|
||||
if (self->menuArray[self->menuState].keyActionBinding[loopCounter].key == key)
|
||||
if ((self->menuArray[self->menuState].keyActionBinding[loopCounter].key == key) && (self->menuArray[self->menuState].keyActionBinding[loopCounter].keyState == keyState))
|
||||
{
|
||||
returnValue = self->menuArray[self->menuState].keyActionBinding[loopCounter];
|
||||
break;
|
||||
@@ -392,6 +494,7 @@ static void repairMenu_scrollDownIndexHandler(struct RepairMenu* self)
|
||||
|
||||
static void repairMenu_startRepairProcess(struct RepairMenu* self, int cursorIndex)
|
||||
{
|
||||
ErrorStatus returnValue = SUCCESS;
|
||||
self->rpParameters.adcRow1 = &adc1->channel[0];
|
||||
self->rpParameters.adcRow2 = &adc1->channel[1];
|
||||
self->rpParameters.adcRow3 = &adc1->channel[2];
|
||||
@@ -399,9 +502,91 @@ static void repairMenu_startRepairProcess(struct RepairMenu* self, int cursorInd
|
||||
self->rpParameters.dacRow2 = &max5715->dac[1];
|
||||
self->rpParameters.dacRow3 = &max5715->dac[2];
|
||||
|
||||
rp = &self->repairProcess;
|
||||
Observable_addObserver(RTC_getObservable(rtc), repairMenu_feedProcessSecondsCounter);
|
||||
repairProcess_construct(&self->repairProcess, &self->rpParameters, self->repairPreset, 2, 1024);
|
||||
|
||||
// First, Lock the cover
|
||||
if (returnValue == SUCCESS)
|
||||
{
|
||||
hsb_solenoidLock();
|
||||
}
|
||||
|
||||
if (returnValue == SUCCESS)
|
||||
{
|
||||
// Check for INTERLOCK CLOSE
|
||||
if (Interlock_isClosed(interlock))
|
||||
{
|
||||
// Enable Interrupt for interlock switch
|
||||
Interlock_setEXTI(interlock, ENABLE);
|
||||
}
|
||||
else
|
||||
{
|
||||
Error_postError(INTERLOCK_COMMON_FAIL);
|
||||
returnValue = ERROR;
|
||||
}
|
||||
}
|
||||
|
||||
if (returnValue == SUCCESS)
|
||||
{
|
||||
// TESLA has a second interlock that must be closed
|
||||
if (PCBA_getInstance()->pcba == Tesla)
|
||||
{
|
||||
if (Interlock_isClosed(teslalock))
|
||||
{
|
||||
// Enable Interrupt for tesla interlock switch
|
||||
Interlock_setEXTI(teslalock, ENABLE);
|
||||
}
|
||||
else
|
||||
{
|
||||
// Error_postError(INTERLOCK_TESLA_FAIL);
|
||||
// returnValue = ERROR;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// if Interlock(s) closed, continue procedure
|
||||
if (returnValue == SUCCESS)
|
||||
{
|
||||
// Power the circuit
|
||||
if (GPIO_setValue(power6v5Enable, true) != SUCCESS)
|
||||
{
|
||||
Error_postError(POWERENABLE_FAIL);
|
||||
}
|
||||
}
|
||||
|
||||
if (returnValue == SUCCESS)
|
||||
{
|
||||
// For MCP/Cathode, the right settings must be made
|
||||
///TODO
|
||||
}
|
||||
|
||||
// If all is OK, start the repair process
|
||||
if (returnValue == SUCCESS)
|
||||
{
|
||||
rp = &self->repairProcess;
|
||||
Observable_addObserver(RTC_getObservable(rtc), repairMenu_feedProcessSecondsCounter);
|
||||
returnValue = repairProcess_construct(&self->repairProcess, &self->rpParameters, self->repairPreset, 2, 1024);
|
||||
|
||||
if (returnValue == SUCCESS)
|
||||
{
|
||||
// repair process is running
|
||||
repairMenu_changeState(self, REPAIR_RUNNING);
|
||||
}
|
||||
else
|
||||
{
|
||||
Error_postError(REPAIR_FAIL);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static void repairMenu_abortRepairProcess(struct RepairMenu* self)
|
||||
{
|
||||
Interlock_setEXTI(interlock, DISABLE);
|
||||
if (PCBA_getInstance()->pcba == Tesla)
|
||||
{
|
||||
Interlock_setEXTI(teslalock, ENABLE);
|
||||
}
|
||||
|
||||
repairProcess_destruct(&self->repairProcess);
|
||||
}
|
||||
|
||||
static ErrorStatus repairMenu_feedProcessSecondsCounter(const void* const data)
|
||||
@@ -418,85 +603,117 @@ static void repairMenu_selectPreset(struct RepairMenu* self, int cursorIndex)
|
||||
}
|
||||
|
||||
|
||||
static void repairMenu_solenoidLock(struct RepairMenu* self, int cursorIndex)
|
||||
{
|
||||
hsb_solenoidLock();
|
||||
}
|
||||
|
||||
|
||||
static void repairMenu_solenoidUnlock(struct RepairMenu* self, int cursorIndex)
|
||||
{
|
||||
hsb_solenoidUnlock();
|
||||
}
|
||||
|
||||
|
||||
static ErrorStatus repairMenu_createMenu(struct RepairMenu* self)
|
||||
{
|
||||
ErrorStatus returnValue = SUCCESS;
|
||||
|
||||
repairMenu_createMenuPage(&self->menuArray[MAINMENU], MENU_HAS_CURSOR, 4);
|
||||
repairMenu_addMenuPageRow(&self->menuArray[MAINMENU], 0, PCBA_getInstance()->name, MAINMENU, NULL);
|
||||
repairMenu_addMenuPageRow(&self->menuArray[MAINMENU], 1, " 1.Tube repair", REPAIRMENU, NULL);
|
||||
repairMenu_addMenuPageRow(&self->menuArray[MAINMENU], 2, " 2.Administrator", ADMINMENU, NULL);
|
||||
repairMenu_addMenuPageRow(&self->menuArray[MAINMENU], 3, " 3.Calibration", CALIBRATIONMENU, NULL);
|
||||
repairMenu_addMenuPageKeyAction(&self->menuArray[MAINMENU], 0, 'U', SCROLL_UP, 0);
|
||||
repairMenu_addMenuPageKeyAction(&self->menuArray[MAINMENU], 1, 'D', SCROLL_DOWN, 0);
|
||||
repairMenu_addMenuPageKeyAction(&self->menuArray[MAINMENU], 2, 'E', SELECT, 0);
|
||||
repairMenu_addMenuPageKeyAction(&self->menuArray[MAINMENU], 3, '1', HOTKEY_SELECT, 1);
|
||||
repairMenu_addMenuPageKeyAction(&self->menuArray[MAINMENU], 4, '2', HOTKEY_SELECT, 2);
|
||||
repairMenu_addMenuPageKeyAction(&self->menuArray[MAINMENU], 5, '3', HOTKEY_SELECT, 3);
|
||||
repairMenu_addMenuPageRow(&self->menuArray[MAINMENU], PCBA_getInstance()->name, MAINMENU, NULL);
|
||||
repairMenu_addMenuPageRow(&self->menuArray[MAINMENU], " 1.Tube repair", REPAIRMENU, NULL);
|
||||
repairMenu_addMenuPageRow(&self->menuArray[MAINMENU], " 2.Administrator", ADMINMENU, NULL);
|
||||
repairMenu_addMenuPageRow(&self->menuArray[MAINMENU], " 3.Calibration", CALIBRATIONMENU, NULL);
|
||||
repairMenu_addKeyAction_SCROLLUP(&self->menuArray[MAINMENU], 'U', PRESSED);
|
||||
repairMenu_addKeyAction_SCROLLDOWN(&self->menuArray[MAINMENU], 'D', PRESSED);
|
||||
repairMenu_addKeyAction_SELECT(&self->menuArray[MAINMENU], 'E', PRESSED);
|
||||
repairMenu_addKeyAction_HOTKEYSELECT(&self->menuArray[MAINMENU], '1', PRESSED, 1);
|
||||
repairMenu_addKeyAction_HOTKEYSELECT(&self->menuArray[MAINMENU], '2', PRESSED, 2);
|
||||
repairMenu_addKeyAction_HOTKEYSELECT(&self->menuArray[MAINMENU], '3', PRESSED, 3);
|
||||
repairMenu_addKeyAction_EXECUTEFUNCTION(&self->menuArray[MAINMENU], '0', PRESSED, repairMenu_solenoidUnlock);
|
||||
repairMenu_addKeyAction_EXECUTEFUNCTION(&self->menuArray[MAINMENU], '0', RELEASED, repairMenu_solenoidLock);
|
||||
|
||||
|
||||
repairMenu_createMenuPage(&self->menuArray[REPAIRMENU], MENU_HAS_CURSOR, 4);
|
||||
repairMenu_addMenuPageRow(&self->menuArray[REPAIRMENU], 0, "Tube repair", REPAIRMENU, NULL);
|
||||
repairMenu_addMenuPageRow(&self->menuArray[REPAIRMENU], 1, " 1.Select preset", PRESETMENU, NULL);
|
||||
repairMenu_addMenuPageRow(&self->menuArray[REPAIRMENU], 2, " 2.Start", START_REPAIR, repairMenu_startRepairProcess);
|
||||
repairMenu_addMenuPageRow(&self->menuArray[REPAIRMENU], 3, " 3.To main menu", MAINMENU, NULL);
|
||||
repairMenu_addMenuPageKeyAction(&self->menuArray[REPAIRMENU], 0, 'U', SCROLL_UP, 0);
|
||||
repairMenu_addMenuPageKeyAction(&self->menuArray[REPAIRMENU], 1, 'D', SCROLL_DOWN, 0);
|
||||
repairMenu_addMenuPageKeyAction(&self->menuArray[REPAIRMENU], 2, 'E', SELECT, 0);
|
||||
repairMenu_addMenuPageKeyAction(&self->menuArray[REPAIRMENU], 3, '1', HOTKEY_SELECT, 1);
|
||||
repairMenu_addMenuPageKeyAction(&self->menuArray[REPAIRMENU], 4, '2', HOTKEY_SELECT, 2);
|
||||
repairMenu_addMenuPageKeyAction(&self->menuArray[REPAIRMENU], 5, 'X', HOTKEY_SELECT, 3);
|
||||
repairMenu_addMenuPageRow(&self->menuArray[REPAIRMENU], "Tube repair", REPAIRMENU, NULL);
|
||||
repairMenu_addMenuPageRow(&self->menuArray[REPAIRMENU], " 1.Select preset", PRESETMENU, NULL);
|
||||
repairMenu_addMenuPageRow(&self->menuArray[REPAIRMENU], " 2.Start", START_REPAIR, repairMenu_startRepairProcess);
|
||||
repairMenu_addKeyAction_SCROLLUP(&self->menuArray[REPAIRMENU], 'U', PRESSED);
|
||||
repairMenu_addKeyAction_SCROLLDOWN(&self->menuArray[REPAIRMENU], 'D', PRESSED);
|
||||
repairMenu_addKeyAction_SELECT(&self->menuArray[REPAIRMENU], 'E', PRESSED);
|
||||
repairMenu_addKeyAction_HOTKEYSELECT(&self->menuArray[REPAIRMENU], '1', PRESSED, 1);
|
||||
repairMenu_addKeyAction_HOTKEYSELECT(&self->menuArray[REPAIRMENU], '2', PRESSED, 2);
|
||||
repairMenu_addKeyAction_GOTOSTATE(&self->menuArray[REPAIRMENU], 'X', PRESSED, MAINMENU);
|
||||
repairMenu_addKeyAction_EXECUTEFUNCTION(&self->menuArray[REPAIRMENU], '0', PRESSED, repairMenu_solenoidUnlock);
|
||||
repairMenu_addKeyAction_EXECUTEFUNCTION(&self->menuArray[REPAIRMENU], '0', RELEASED, repairMenu_solenoidLock);
|
||||
|
||||
|
||||
repairMenu_createMenuPage(&self->menuArray[ADMINMENU], MENU_HAS_NO_CURSOR, 2);
|
||||
repairMenu_addMenuPageRow(&self->menuArray[ADMINMENU], 0, "Administration", ADMINMENU, NULL);
|
||||
repairMenu_addMenuPageRow(&self->menuArray[ADMINMENU], 1, " 1.To main menu", MAINMENU, NULL);
|
||||
repairMenu_addMenuPageKeyAction(&self->menuArray[ADMINMENU], 0, 'E', SELECT, 0);
|
||||
repairMenu_addMenuPageKeyAction(&self->menuArray[ADMINMENU], 1, '1', HOTKEY_SELECT, 1);
|
||||
repairMenu_addMenuPageKeyAction(&self->menuArray[ADMINMENU], 2, 'X', HOTKEY_SELECT, 1);
|
||||
repairMenu_addMenuPageRow(&self->menuArray[ADMINMENU], "Administration", ADMINMENU, NULL);
|
||||
repairMenu_addMenuPageRow(&self->menuArray[ADMINMENU], " 1.Nothing", ADMINMENU, NULL);
|
||||
repairMenu_addKeyAction_GOTOSTATE(&self->menuArray[ADMINMENU], 'X', PRESSED, MAINMENU);
|
||||
|
||||
repairMenu_createMenuPage(&self->menuArray[CALIBRATIONMENU], MENU_HAS_NO_CURSOR, 2);
|
||||
repairMenu_addMenuPageRow(&self->menuArray[CALIBRATIONMENU], 0, "Calibration", CALIBRATIONMENU, NULL);
|
||||
repairMenu_addMenuPageRow(&self->menuArray[CALIBRATIONMENU], 1, " 1.To main menu", MAINMENU, NULL);
|
||||
repairMenu_addMenuPageKeyAction(&self->menuArray[CALIBRATIONMENU], 0, 'E', SELECT, 0);
|
||||
repairMenu_addMenuPageKeyAction(&self->menuArray[CALIBRATIONMENU], 1, '1', HOTKEY_SELECT, 1);
|
||||
repairMenu_addMenuPageKeyAction(&self->menuArray[CALIBRATIONMENU], 2, 'X', HOTKEY_SELECT, 1);
|
||||
repairMenu_addMenuPageRow(&self->menuArray[CALIBRATIONMENU], "Calibration", CALIBRATIONMENU, NULL);
|
||||
repairMenu_addMenuPageRow(&self->menuArray[CALIBRATIONMENU], " 1.Nothing", CALIBRATIONMENU, NULL);
|
||||
repairMenu_addKeyAction_GOTOSTATE(&self->menuArray[CALIBRATIONMENU], 'X', PRESSED, MAINMENU);
|
||||
|
||||
|
||||
repairMenu_createMenuPage(&self->menuArray[PRESETMENU], MENU_HAS_CURSOR, 11);
|
||||
repairMenu_addMenuPageRow(&self->menuArray[PRESETMENU], 0, "Select preset", PRESETMENU, NULL);
|
||||
repairMenu_addMenuPageRow(&self->menuArray[PRESETMENU], 1, " 1.Preset1", REPAIRMENU, repairMenu_selectPreset);
|
||||
repairMenu_addMenuPageRow(&self->menuArray[PRESETMENU], 2, " 2.Preset2", REPAIRMENU, repairMenu_selectPreset);
|
||||
repairMenu_addMenuPageRow(&self->menuArray[PRESETMENU], 3, " 3.Preset3", REPAIRMENU, repairMenu_selectPreset);
|
||||
repairMenu_addMenuPageRow(&self->menuArray[PRESETMENU], 4, " 4.Preset4", REPAIRMENU, repairMenu_selectPreset);
|
||||
repairMenu_addMenuPageRow(&self->menuArray[PRESETMENU], 5, " 5.Preset5", REPAIRMENU, repairMenu_selectPreset);
|
||||
repairMenu_addMenuPageRow(&self->menuArray[PRESETMENU], 6, " 6.Preset6", REPAIRMENU, repairMenu_selectPreset);
|
||||
repairMenu_addMenuPageRow(&self->menuArray[PRESETMENU], 7, " 7.Preset7", REPAIRMENU, repairMenu_selectPreset);
|
||||
repairMenu_addMenuPageRow(&self->menuArray[PRESETMENU], 8, " 8.Preset8", REPAIRMENU, repairMenu_selectPreset);
|
||||
repairMenu_addMenuPageRow(&self->menuArray[PRESETMENU], 9, " 9.Preset9", REPAIRMENU, repairMenu_selectPreset);
|
||||
repairMenu_addMenuPageRow(&self->menuArray[PRESETMENU], 10, " 10.To repair menu", REPAIRMENU, NULL);
|
||||
repairMenu_addMenuPageKeyAction(&self->menuArray[PRESETMENU], 0, 'U', SCROLL_UP, 0);
|
||||
repairMenu_addMenuPageKeyAction(&self->menuArray[PRESETMENU], 1, 'D', SCROLL_DOWN, 0);
|
||||
repairMenu_addMenuPageKeyAction(&self->menuArray[PRESETMENU], 2, 'E', SELECT, 0);
|
||||
repairMenu_addMenuPageKeyAction(&self->menuArray[PRESETMENU], 3, '1', HOTKEY_SELECT, 1);
|
||||
repairMenu_addMenuPageKeyAction(&self->menuArray[PRESETMENU], 4, '2', HOTKEY_SELECT, 2);
|
||||
repairMenu_addMenuPageKeyAction(&self->menuArray[PRESETMENU], 5, '3', HOTKEY_SELECT, 3);
|
||||
repairMenu_addMenuPageKeyAction(&self->menuArray[PRESETMENU], 6, '4', HOTKEY_SELECT, 4);
|
||||
repairMenu_addMenuPageKeyAction(&self->menuArray[PRESETMENU], 7, '5', HOTKEY_SELECT, 5);
|
||||
repairMenu_addMenuPageKeyAction(&self->menuArray[PRESETMENU], 8, '6', HOTKEY_SELECT, 6);
|
||||
repairMenu_addMenuPageKeyAction(&self->menuArray[PRESETMENU], 9, '7', HOTKEY_SELECT, 7);
|
||||
repairMenu_addMenuPageKeyAction(&self->menuArray[PRESETMENU], 10, '8', HOTKEY_SELECT, 8);
|
||||
repairMenu_addMenuPageKeyAction(&self->menuArray[PRESETMENU], 11, '9', HOTKEY_SELECT, 9);
|
||||
repairMenu_addMenuPageKeyAction(&self->menuArray[PRESETMENU], 12, 'X', HOTKEY_SELECT, 10);
|
||||
repairMenu_createMenuPage(&self->menuArray[PRESETMENU], MENU_HAS_CURSOR, 10);
|
||||
repairMenu_addMenuPageRow(&self->menuArray[PRESETMENU], "Select preset", PRESETMENU, NULL);
|
||||
repairMenu_addMenuPageRow(&self->menuArray[PRESETMENU], " 1.Preset1", REPAIRMENU, repairMenu_selectPreset);
|
||||
repairMenu_addMenuPageRow(&self->menuArray[PRESETMENU], " 2.Preset2", REPAIRMENU, repairMenu_selectPreset);
|
||||
repairMenu_addMenuPageRow(&self->menuArray[PRESETMENU], " 3.Preset3", REPAIRMENU, repairMenu_selectPreset);
|
||||
repairMenu_addMenuPageRow(&self->menuArray[PRESETMENU], " 4.Preset4", REPAIRMENU, repairMenu_selectPreset);
|
||||
repairMenu_addMenuPageRow(&self->menuArray[PRESETMENU], " 5.Preset5", REPAIRMENU, repairMenu_selectPreset);
|
||||
repairMenu_addMenuPageRow(&self->menuArray[PRESETMENU], " 6.Preset6", REPAIRMENU, repairMenu_selectPreset);
|
||||
repairMenu_addMenuPageRow(&self->menuArray[PRESETMENU], " 7.Preset7", REPAIRMENU, repairMenu_selectPreset);
|
||||
repairMenu_addMenuPageRow(&self->menuArray[PRESETMENU], " 8.Preset8", REPAIRMENU, repairMenu_selectPreset);
|
||||
repairMenu_addMenuPageRow(&self->menuArray[PRESETMENU], " 9.Preset9", REPAIRMENU, repairMenu_selectPreset);
|
||||
repairMenu_addKeyAction_SCROLLUP(&self->menuArray[PRESETMENU], 'U', PRESSED);
|
||||
repairMenu_addKeyAction_SCROLLDOWN(&self->menuArray[PRESETMENU], 'D', PRESSED);
|
||||
repairMenu_addKeyAction_SELECT(&self->menuArray[PRESETMENU], 'E', PRESSED);
|
||||
repairMenu_addKeyAction_HOTKEYSELECT(&self->menuArray[PRESETMENU], '1', PRESSED, 1);
|
||||
repairMenu_addKeyAction_HOTKEYSELECT(&self->menuArray[PRESETMENU], '2', PRESSED, 2);
|
||||
repairMenu_addKeyAction_HOTKEYSELECT(&self->menuArray[PRESETMENU], '3', PRESSED, 3);
|
||||
repairMenu_addKeyAction_HOTKEYSELECT(&self->menuArray[PRESETMENU], '4', PRESSED, 4);
|
||||
repairMenu_addKeyAction_HOTKEYSELECT(&self->menuArray[PRESETMENU], '5', PRESSED, 5);
|
||||
repairMenu_addKeyAction_HOTKEYSELECT(&self->menuArray[PRESETMENU], '6', PRESSED, 6);
|
||||
repairMenu_addKeyAction_HOTKEYSELECT(&self->menuArray[PRESETMENU], '7', PRESSED, 7);
|
||||
repairMenu_addKeyAction_HOTKEYSELECT(&self->menuArray[PRESETMENU], '8', PRESSED, 8);
|
||||
repairMenu_addKeyAction_HOTKEYSELECT(&self->menuArray[PRESETMENU], '9', PRESSED, 9);
|
||||
repairMenu_addKeyAction_GOTOSTATE(&self->menuArray[PRESETMENU], 'X', PRESSED, REPAIRMENU);
|
||||
repairMenu_addKeyAction_EXECUTEFUNCTION(&self->menuArray[PRESETMENU], '0', PRESSED, repairMenu_solenoidUnlock);
|
||||
repairMenu_addKeyAction_EXECUTEFUNCTION(&self->menuArray[PRESETMENU], '0', RELEASED, repairMenu_solenoidLock);
|
||||
|
||||
repairMenu_createMenuPage(&self->menuArray[REPAIR_RUNNING], MENU_HAS_NO_CURSOR, 4);
|
||||
repairMenu_addKeyAction_GOTOSTATE(&self->menuArray[REPAIR_RUNNING], 'X', PRESSED, REPAIR_ASK_PAUSE);
|
||||
|
||||
repairMenu_createMenuPage(&self->menuArray[REPAIR_ASK_PAUSE], MENU_HAS_NO_CURSOR, 4);
|
||||
repairMenu_addKeyAction_GOTOSTATE(&self->menuArray[REPAIR_ASK_PAUSE], 'X', PRESSED, REPAIR_PAUSE);
|
||||
|
||||
repairMenu_createMenuPage(&self->menuArray[REPAIR_PAUSE], MENU_HAS_NO_CURSOR, 4);
|
||||
repairMenu_addKeyAction_GOTOSTATE(&self->menuArray[REPAIR_PAUSE], 'X', PRESSED, REPAIR_PAUSE);
|
||||
|
||||
repairMenu_createMenuPage(&self->menuArray[ERROR_STATE], MENU_HAS_NO_CURSOR, 4);
|
||||
repairMenu_addKeyAction_GOTOSTATE(&self->menuArray[ERROR_STATE], 'X', PRESSED, MAINMENU);
|
||||
repairMenu_addKeyAction_GOTOSTATE(&self->menuArray[ERROR_STATE], 'E', PRESSED, REPAIR_RUNNING);
|
||||
|
||||
return returnValue;
|
||||
}
|
||||
|
||||
static ErrorStatus repairMenu_createMenuPage (struct MenuPage* self, bool hasCursor, int numberOfRows)
|
||||
static ErrorStatus repairMenu_createMenuPage (struct MenuPage* self, bool hasCursor, int maxNumberOfRows)
|
||||
{
|
||||
ErrorStatus returnValue = SUCCESS;
|
||||
self->hasCursor = hasCursor;
|
||||
if (numberOfRows <= REPAIRMENU_MAX_NUMBER_OF_ROWS)
|
||||
|
||||
|
||||
if (maxNumberOfRows <= REPAIRMENU_MAX_NUMBER_OF_ROWS)
|
||||
{
|
||||
self->numberOfRows = numberOfRows;
|
||||
self->maxNumberOfKeys = NUMBER_OF_KEY_EVENTS * REPAIRMENU_MAX_NUMBER_OF_KEYS;
|
||||
self->numberOfRows = 0;
|
||||
self->numberOfKeys = 0;
|
||||
self->maxNumberOfRows = maxNumberOfRows;
|
||||
self->hasCursor = hasCursor;
|
||||
}
|
||||
else
|
||||
{
|
||||
@@ -505,14 +722,15 @@ static ErrorStatus repairMenu_createMenuPage (struct MenuPage* self, bool hasCur
|
||||
return returnValue;
|
||||
}
|
||||
|
||||
static ErrorStatus repairMenu_addMenuPageRow (struct MenuPage* self, int rowIndex, char* text, int newState, RepairMenuFunctionCall actionCall)
|
||||
static ErrorStatus repairMenu_addMenuPageRow (struct MenuPage* self, char* text, int newState, RepairMenuFunctionCall actionCall)
|
||||
{
|
||||
ErrorStatus returnValue = SUCCESS;
|
||||
if (rowIndex < self->numberOfRows)
|
||||
if (self->numberOfRows < self->maxNumberOfRows)
|
||||
{
|
||||
memcpy(self->row[rowIndex].text, text, 20);
|
||||
self->row[rowIndex].newState = newState;
|
||||
self->row[rowIndex].actionPointer = actionCall;
|
||||
memcpy(self->row[self->numberOfRows].text, text, 20);
|
||||
self->row[self->numberOfRows].newState = newState;
|
||||
self->row[self->numberOfRows].actionPointer = actionCall;
|
||||
self->numberOfRows++;
|
||||
}
|
||||
else
|
||||
{
|
||||
@@ -521,18 +739,136 @@ static ErrorStatus repairMenu_addMenuPageRow (struct MenuPage* self, int rowInde
|
||||
return returnValue;
|
||||
}
|
||||
|
||||
static ErrorStatus repairMenu_addMenuPageKeyAction (struct MenuPage* self, int keyActionIndex, char key, T_KeyAction action, int argument)
|
||||
|
||||
static ErrorStatus repairMenu_addKeyAction_HOTKEYSELECT (struct MenuPage* self, char key, Keypad_KeyState keyState, int rowToSelect)
|
||||
{
|
||||
ErrorStatus returnValue = SUCCESS;
|
||||
if (keyActionIndex < REPAIRMENU_MAX_NUMBER_OF_KEYS)
|
||||
|
||||
if (self->numberOfKeys < self->maxNumberOfKeys)
|
||||
{
|
||||
self->keyActionBinding[keyActionIndex].key = key;
|
||||
self->keyActionBinding[keyActionIndex].argument = argument;
|
||||
self->keyActionBinding[keyActionIndex].action = action;
|
||||
self->keyActionBinding[self->numberOfKeys].key = key;
|
||||
self->keyActionBinding[self->numberOfKeys].keyState = keyState;
|
||||
self->keyActionBinding[self->numberOfKeys].action = HOTKEY_SELECT;
|
||||
self->keyActionBinding[self->numberOfKeys].argument = rowToSelect;
|
||||
self->keyActionBinding[self->numberOfKeys].actionPointer = NULL;
|
||||
self->numberOfKeys++;
|
||||
}
|
||||
else
|
||||
{
|
||||
returnValue = ERROR;
|
||||
}
|
||||
|
||||
return returnValue;
|
||||
}
|
||||
|
||||
|
||||
static ErrorStatus repairMenu_addKeyAction_SELECT (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 = SELECT;
|
||||
self->keyActionBinding[self->numberOfKeys].argument = 0;
|
||||
self->keyActionBinding[self->numberOfKeys].actionPointer = NULL;
|
||||
self->numberOfKeys++;
|
||||
}
|
||||
else
|
||||
{
|
||||
returnValue = ERROR;
|
||||
}
|
||||
|
||||
return returnValue;
|
||||
}
|
||||
|
||||
|
||||
static ErrorStatus repairMenu_addKeyAction_GOTOSTATE (struct MenuPage* self, char key, Keypad_KeyState keyState, T_MenuState state)
|
||||
{
|
||||
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 = GOTO_STATE;
|
||||
self->keyActionBinding[self->numberOfKeys].argument = state;
|
||||
self->keyActionBinding[self->numberOfKeys].actionPointer = NULL;
|
||||
self->numberOfKeys++;
|
||||
}
|
||||
else
|
||||
{
|
||||
returnValue = ERROR;
|
||||
}
|
||||
|
||||
return returnValue;
|
||||
}
|
||||
|
||||
|
||||
static ErrorStatus repairMenu_addKeyAction_EXECUTEFUNCTION (struct MenuPage* self, char key, Keypad_KeyState keyState, RepairMenuFunctionCall 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 = EXECUTE_FUNCTION;
|
||||
self->keyActionBinding[self->numberOfKeys].argument = 0;
|
||||
self->keyActionBinding[self->numberOfKeys].actionPointer = actionPointer;
|
||||
self->numberOfKeys++;
|
||||
}
|
||||
else
|
||||
{
|
||||
returnValue = ERROR;
|
||||
}
|
||||
|
||||
return returnValue;
|
||||
}
|
||||
|
||||
|
||||
static ErrorStatus repairMenu_addKeyAction_SCROLLUP (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 = SCROLL_UP;
|
||||
self->keyActionBinding[self->numberOfKeys].argument = 0;
|
||||
self->keyActionBinding[self->numberOfKeys].actionPointer = NULL;
|
||||
self->numberOfKeys++;
|
||||
}
|
||||
else
|
||||
{
|
||||
returnValue = ERROR;
|
||||
}
|
||||
|
||||
return returnValue;
|
||||
}
|
||||
|
||||
|
||||
static ErrorStatus repairMenu_addKeyAction_SCROLLDOWN (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 = SCROLL_DOWN;
|
||||
self->keyActionBinding[self->numberOfKeys].argument = 0;
|
||||
self->keyActionBinding[self->numberOfKeys].actionPointer = NULL;
|
||||
self->numberOfKeys++;
|
||||
}
|
||||
else
|
||||
{
|
||||
returnValue = ERROR;
|
||||
}
|
||||
|
||||
return returnValue;
|
||||
}
|
||||
|
||||
|
||||
|
||||
Reference in New Issue
Block a user