From 27755498e63e4f8b23b898dd41d2a5198f20eb39 Mon Sep 17 00:00:00 2001 From: mmi Date: Fri, 3 Nov 2017 08:07:27 +0000 Subject: [PATCH] - Moved the menu texts to dedicated file to support future language switch option - split the menu into core, elements as generic modules git-svn-id: https://svn.vbchaos.nl/svn/hsb/trunk@270 05563f52-14a8-4384-a975-3d1654cca0fa --- .../0 - Code/Platform/src/InternalFlash.c | 6 - .../0 - Code/hsb-mrts/Makefile | 2 + .../0 - Code/hsb-mrts/inc/MenuCore.h | 199 ++++ .../0 - Code/hsb-mrts/inc/MenuElements.h | 76 ++ .../0 - Code/hsb-mrts/inc/MenuText.h | 149 +++ .../hsb-mrts/inc/SignalProfileGenerator.h | 3 + .../0 - Code/hsb-mrts/inc/repairMenu.h | 90 +- .../0 - Code/hsb-mrts/src/DAConverter.c | 1 - .../0 - Code/hsb-mrts/src/MenuCore.c | 362 +++++++ .../0 - Code/hsb-mrts/src/MenuElements.c | 221 +++++ .../hsb-mrts/src/SignalProfileGenerator.c | 15 + .../0 - Code/hsb-mrts/src/main.c | 2 - .../0 - Code/hsb-mrts/src/repairMenu.c | 899 +++++------------- .../0 - Code/hsb-mrts/src/repairMenus.c | 21 +- .../0 - Code/hsb-mrts/src/repairProcess.c | 2 +- 15 files changed, 1292 insertions(+), 756 deletions(-) create mode 100644 S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/MenuCore.h create mode 100644 S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/MenuElements.h create mode 100644 S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/MenuText.h create mode 100644 S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/MenuCore.c create mode 100644 S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/MenuElements.c diff --git a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/Platform/src/InternalFlash.c b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/Platform/src/InternalFlash.c index 3bf2a88..36cf3d0 100644 --- a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/Platform/src/InternalFlash.c +++ b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/Platform/src/InternalFlash.c @@ -115,7 +115,6 @@ ErrorStatus InternalFlash_write(const struct InternalFlash* self, uint32_t* buff { // Start address is NOT OK returnValue = ERROR; - LOGGER_DEBUG(mainLog, "StartAddress error %X (%X %X)", _address, self->startAddress, self->endAddress); } } if (returnValue == SUCCESS) @@ -125,7 +124,6 @@ ErrorStatus InternalFlash_write(const struct InternalFlash* self, uint32_t* buff { // End address is NOT OK returnValue = ERROR; - LOGGER_DEBUG(mainLog, "EndAddress error %X (%X)", _endAddress, self->endAddress); } } @@ -133,7 +131,6 @@ ErrorStatus InternalFlash_write(const struct InternalFlash* self, uint32_t* buff if (returnValue == SUCCESS) { - LOGGER_DEBUG(mainLog, "Writing on address %X with length %d until address %X", _address, length *4, _endAddress); // Unlock the FLASH bank FLASH_Unlock(); @@ -142,14 +139,11 @@ ErrorStatus InternalFlash_write(const struct InternalFlash* self, uint32_t* buff int bufferIndex = 0; while((_address < _endAddress) && (FLASHStatus == FLASH_COMPLETE)) { - LOGGER_DEBUG(mainLog, "address %X --- Data %d", _address, buffer[bufferIndex]); FLASHStatus = FLASH_ProgramWord(_address, buffer[bufferIndex++]); // 32bit data register requires increment by 4 for next word address _address = _address + 4; - vTaskDelay(100); } - LOGGER_DEBUG(mainLog, "Writing done = flash status is %d", FLASHStatus); // After programming, lock the FLASH FLASH_Lock(); } diff --git a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/Makefile b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/Makefile index cc2dc87..37163cf 100644 --- a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/Makefile +++ b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/Makefile @@ -22,6 +22,8 @@ DisplayContent.o \ Error.o \ FreeRTOSFixes.o \ hwValidationMenu.o \ +MenuCore.o \ +MenuElements.o \ repairMenu.o \ repairMenus.o \ RepairPreset.o \ diff --git a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/MenuCore.h b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/MenuCore.h new file mode 100644 index 0000000..1130671 --- /dev/null +++ b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/MenuCore.h @@ -0,0 +1,199 @@ +// ----------------------------------------------------------------------------- +/// @file MenuCore.h +/// @brief File 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) 2015 Micro-Key bv +// ----------------------------------------------------------------------------- + +/// @defgroup {group_name} {group_description} +/// Description + +/// @file MenuCore.h +/// @ingroup {group_name} + +#ifndef MENUCORE_H_ +#define MENUCORE_H_ + + +// ----------------------------------------------------------------------------- +// Include files +// ----------------------------------------------------------------------------- + +#include + +#include "stm32f10x.h" + +#include "Display.h" +#include "KeyboardDevice.h" +// ----------------------------------------------------------------------------- +// Constant and macro definitions +// ----------------------------------------------------------------------------- + +#define MENUCORE_MAX_NUMBER_OF_ROWS (11) +#define MENUCORE_MAX_NUMBER_OF_KEYS (16) +#define MENUCORE_DISPLAY_ROW_LENGTH (20) + +// ----------------------------------------------------------------------------- +// Type definitions. +// ----------------------------------------------------------------------------- + +typedef enum +{ + RM_MAINMENU = 0, + RM_CATHODEMCP_SELECT, + RM_REPAIRMENU, + RM_ADMINMENU, + RM_CALIBRATIONMENU, + RM_PRESETMENU, + RM_PRESET_PRINT, + RM_START_REPAIR, + RM_REPAIR_RUNNING, + RM_REPAIR_ASK_PAUSE, + RM_REPAIR_PAUSE, + RM_FINISH_CONTROL, + RM_FINISH, + RM_ERROR_STATE, + RM_WARNING_STATE, + RM_NO_MENU, + RM_NUMBER_OF_MENUS +} T_MenuState; + + +typedef enum +{ + NO_ACTION = 0, + HOTKEY_SELECT, + SELECT, + GOTO_STATE, + EXECUTE_FUNCTION, + SCROLL_UP, + SCROLL_DOWN, + DIGIT_INSERT +} T_KeyAction; + +struct MenuCore; +typedef void (*MenuCoreFunctionCall)(struct MenuCore* self); + +struct MenuRow +{ + char text[MENUCORE_DISPLAY_ROW_LENGTH]; + int newState; + MenuCoreFunctionCall actionPointer; +}; + +struct KeyActionBinding +{ + char key; + Keypad_KeyState keyState; + T_KeyAction action; + int argument; + MenuCoreFunctionCall actionPointer; +}; + +struct MenuPage +{ + bool hasCursor; + int numberOfRows; + int maxNumberOfRows; + int numberOfKeys; + int maxNumberOfKeys; + struct MenuRow row[MENUCORE_MAX_NUMBER_OF_ROWS]; + struct KeyActionBinding keyActionBinding[NUMBER_OF_KEY_EVENTS * MENUCORE_MAX_NUMBER_OF_KEYS]; +}; + +struct MenuCore +{ + TaskHandle_t taskHandle; + int TaskPriority; + uint16_t stackSize; + bool runTask; + bool initialized; + struct Display* display; + struct KeyboardDevice* keyboardDevice; + int cursorIndex; + int scrollOffset; + T_MenuState menuState; + uint32_t popUpCounter; + T_MenuState lastMenuState; + struct MenuPage menuArray[RM_NUMBER_OF_MENUS]; + MenuCoreFunctionCall _handleStateFunction; + char errorMessage[MENUCORE_DISPLAY_ROW_LENGTH]; + char warningMessage[MENUCORE_DISPLAY_ROW_LENGTH]; +}; + +// ----------------------------------------------------------------------------- +// Function declarations +// ----------------------------------------------------------------------------- + + +/** ---------------------------------------------------------------------------- + * MenuCore_construct + * Description of function + * + * @param self Menu core object to construct + * @param display Display device to use for output + * @param keyboardDevice KeyboardDevice for menu input + * @param taskPriority Priority for the menu task + * @param stacksize Task stacksize + * @param createMenu Functionpointer to a function that + * creates the menu entries + * must be provided in order to generate + * the entries of the menu at the right + * time. + * @param stateHandle Functionpointer to a function that gets + * called from the menu task everytime + * PRIOR to the keyboard readout. + * Handy for display printouts or other + * functionality that is state-dependent + * + * @return ErrorStatus SUCCESS if construction was successful + * ERROR otherwise + * + * @todo + * ----------------------------------------------------------------------------- + */ +extern ErrorStatus MenuCore_construct(struct MenuCore* self, struct Display* display, struct KeyboardDevice* keyboardDevice, int taskPriority, uint16_t stackSize, MenuCoreFunctionCall createMenu, MenuCoreFunctionCall stateHandle); + + +/** ---------------------------------------------------------------------------- + * MenuCore_destruct + * Destructor for menu Core + * + * @param self Menu core object to destruct + * + * @return void + * + * @todo + * ----------------------------------------------------------------------------- + */ +extern void MenuCore_destruct(struct MenuCore* self); + + +/** ---------------------------------------------------------------------------- + * MenuCore_changeState + * Requests the menu to change its state + * + * @param self Menu core object + * @param newState New state of the menu + * + * @return void + * + * @todo + * ----------------------------------------------------------------------------- + */ +extern void MenuCore_changeState(struct MenuCore* self, T_MenuState newState); + + +#endif /* MENUCORE_H_ */ diff --git a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/MenuElements.h b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/MenuElements.h new file mode 100644 index 0000000..693ee1f --- /dev/null +++ b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/MenuElements.h @@ -0,0 +1,76 @@ +// ----------------------------------------------------------------------------- +/// @file MenuElements.h +/// @brief File 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) 2015 Micro-Key bv +// ----------------------------------------------------------------------------- + +/// @defgroup {group_name} {group_description} +/// Description + +/// @file MenuElements.h +/// @ingroup {group_name} + +#ifndef MENUELEMENTS_H_ +#define MENUELEMENTS_H_ + + +// ----------------------------------------------------------------------------- +// Include files +// ----------------------------------------------------------------------------- + +#include "MenuCore.h" + +// ----------------------------------------------------------------------------- +// Constant and macro definitions +// ----------------------------------------------------------------------------- + + + +// ----------------------------------------------------------------------------- +// Type definitions. +// ----------------------------------------------------------------------------- + + + +// ----------------------------------------------------------------------------- +// Function declarations +// ----------------------------------------------------------------------------- + + +extern ErrorStatus MenuElements_createMenuPage (struct MenuPage* self, bool hasCursor, int maxNumberOfRows); + + +extern ErrorStatus MenuElements_addMenuPageRow (struct MenuPage* self, const char* text, int newState, MenuCoreFunctionCall actionCall); + + +extern ErrorStatus MenuElements_addKeyAction_HOTKEYSELECT (struct MenuPage* self, char key, Keypad_KeyState keyState, int rowToSelect); + + +extern ErrorStatus MenuElements_addKeyAction_SELECT (struct MenuPage* self, char key, Keypad_KeyState keyState); + + +extern ErrorStatus MenuElements_addKeyAction_GOTOSTATE (struct MenuPage* self, char key, Keypad_KeyState keyState, T_MenuState state); + + +extern ErrorStatus MenuElements_addKeyAction_EXECUTEFUNCTION (struct MenuPage* self, char key, Keypad_KeyState keyState, MenuCoreFunctionCall actionPointer); + + +extern ErrorStatus MenuElements_addKeyAction_SCROLLUP (struct MenuPage* self, char key, Keypad_KeyState keyState); + + +extern ErrorStatus MenuElements_addKeyAction_SCROLLDOWN (struct MenuPage* self, char key, Keypad_KeyState keyState); + +#endif /* MENUELEMENTS_H_ */ diff --git a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/MenuText.h b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/MenuText.h new file mode 100644 index 0000000..63c7cf2 --- /dev/null +++ b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/MenuText.h @@ -0,0 +1,149 @@ +// ----------------------------------------------------------------------------- +/// @file MenuText.h +/// @brief File 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) 2015 Micro-Key bv +// ----------------------------------------------------------------------------- + +/// @defgroup {group_name} {group_description} +/// Description + +/// @file MenuText.h +/// @ingroup {group_name} + +#ifndef MENUTEXT_H_ +#define MENUTEXT_H_ + + +// ----------------------------------------------------------------------------- +// Include files +// ----------------------------------------------------------------------------- + +#include "MenuCore.h" + +// ----------------------------------------------------------------------------- +// Constant and macro definitions +// ----------------------------------------------------------------------------- + +#define MENUTEXT_NUMBER_OF_LANGUAGES (2) +#define MENUTEXT_ENGLISH (0) + +// ----------------------- +// OPERATOR MENU +// ----------------------- +static const char MenuText_MAINMENU[MENUTEXT_NUMBER_OF_LANGUAGES][MENUCORE_MAX_NUMBER_OF_ROWS][MENUCORE_DISPLAY_ROW_LENGTH] = +{ + { + "", + " 1.Tube repair", + " 2.Administrator", + " 3.Calibration" + }, + { + //FRENCH TBW + } +}; + +static const char MenuText_CATHODEMCP_SELECT[MENUTEXT_NUMBER_OF_LANGUAGES][MENUCORE_MAX_NUMBER_OF_ROWS][MENUCORE_DISPLAY_ROW_LENGTH] = +{ + { + "Tube repair", + " 1.Cathode repair", + " 2.MCP repair", + }, + { + //FRENCH TBW + } +}; + + +static const char MenuText_REPAIRMENU[MENUTEXT_NUMBER_OF_LANGUAGES][MENUCORE_MAX_NUMBER_OF_ROWS][MENUCORE_DISPLAY_ROW_LENGTH] = +{ + { + "Tube repair", + " 1.Select preset", + " 2.Start", + }, + { + //FRENCH TBW + } +}; + + +static const char MenuText_PRESETMENU[MENUTEXT_NUMBER_OF_LANGUAGES][MENUCORE_MAX_NUMBER_OF_ROWS][MENUCORE_DISPLAY_ROW_LENGTH] = +{ + { + "Select preset", + " 1.Preset 1", + " 2.Preset 2", + " 3.Preset 3", + " 4.Preset 4", + " 5.Preset 5", + " 6.Preset 6", + " 7.Preset 7", + " 8.Preset 8", + " 9.Preset 9", + }, + { + //FRENCH TBW + } +}; + + + +// ----------------------- +// ADMINISTRATION MENU +// ----------------------- +static const char MenuText_ADMINMENU[MENUTEXT_NUMBER_OF_LANGUAGES][MENUCORE_MAX_NUMBER_OF_ROWS][MENUCORE_DISPLAY_ROW_LENGTH] = +{ + { + "Administration", + " 1.Change Pin", + " 2.I/O control", + " 3.Info & Version" + }, + { + //FRENCH TBW + } +}; + + +// ----------------------- +// CALIBRATION MENU +// ----------------------- +static const char MenuText_CALIBRATIONMENU[MENUTEXT_NUMBER_OF_LANGUAGES][MENUCORE_MAX_NUMBER_OF_ROWS][MENUCORE_DISPLAY_ROW_LENGTH] = +{ + { + "Calibration", + " 1.NOTHING YET", + + }, + { + //FRENCH TBW + } +}; + +// ----------------------------------------------------------------------------- +// Type definitions. +// ----------------------------------------------------------------------------- + + + +// ----------------------------------------------------------------------------- +// Function declarations +// ----------------------------------------------------------------------------- + + +#endif /* MENUTEXT_H_ */ diff --git a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/SignalProfileGenerator.h b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/SignalProfileGenerator.h index 7113dbc..cfbea7a 100644 --- a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/SignalProfileGenerator.h +++ b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/SignalProfileGenerator.h @@ -100,6 +100,9 @@ extern void SignalProfileGenerator_calculate(struct SignalProfileGenerator* self extern void SignalProfileGenerator_pause(struct SignalProfileGenerator* self); +extern bool SignalProfileGenerator_isPaused(struct SignalProfileGenerator* self); + + extern void SignalProfileGenerator_continue(struct SignalProfileGenerator* self); diff --git a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/repairMenu.h b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/repairMenu.h index 0010d50..b95a66e 100644 --- a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/repairMenu.h +++ b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/inc/repairMenu.h @@ -38,6 +38,7 @@ #include "semphr.h" #include "stm32f10x.h" +#include "MenuCore.h" #include "RepairPreset.h" #include "repairProcess.h" @@ -51,8 +52,6 @@ // Constant and macro definitions // ----------------------------------------------------------------------------- -#define REPAIRMENU_MAX_NUMBER_OF_ROWS (11) -#define REPAIRMENU_MAX_NUMBER_OF_KEYS (16) // ----------------------------------------------------------------------------- // Type definitions. @@ -60,93 +59,16 @@ - -typedef enum -{ - MAINMENU = 0, - RM_CATHODEMCP_SELECT, - REPAIRMENU, - ADMINMENU, - CALIBRATIONMENU, - PRESETMENU, - RM_PRESET_PRINT, - START_REPAIR, - REPAIR_RUNNING, - REPAIR_ASK_PAUSE, - REPAIR_PAUSE, - FINISH_CONTROL, - FINISH, - ERROR_STATE, - WARNING_STATE, - NO_MENU, - NUMBER_OF_MENUS -} T_MenuState; - -struct RepairMenu; -typedef void (*RepairMenuFunctionCall)(struct RepairMenu* self, int cursorIndex); - -typedef enum -{ - NO_ACTION = 0, - HOTKEY_SELECT, - SELECT, - GOTO_STATE, - EXECUTE_FUNCTION, - SCROLL_UP, - SCROLL_DOWN, - DIGIT_INSERT -} T_KeyAction; - -struct MenuRow -{ - char text[20]; - int newState; - RepairMenuFunctionCall actionPointer; -}; - - -struct KeyActionBinding -{ - char key; - Keypad_KeyState keyState; - T_KeyAction action; - int argument; - RepairMenuFunctionCall actionPointer; -}; - - -struct MenuPage -{ - bool hasCursor; - int numberOfRows; - int maxNumberOfRows; - int numberOfKeys; - int maxNumberOfKeys; - struct MenuRow row[REPAIRMENU_MAX_NUMBER_OF_ROWS]; - struct KeyActionBinding keyActionBinding[NUMBER_OF_KEY_EVENTS * REPAIRMENU_MAX_NUMBER_OF_KEYS]; -}; - struct RepairMenu { - TaskHandle_t taskHandle; - int TaskPriority; - uint16_t stackSize; - bool runTask; bool initialized; - struct Display* display; - struct KeyboardDevice* keyboardDevice; struct MemoryDevice* memoryDevice; struct CachedStorage presetStorage; - T_MenuState menuState; - int cursorIndex; - int scrollOffset; SemaphoreHandle_t repairScreenUpdateSemaphore; const struct RepairPreset* repairPreset; struct RepairProcessParameters rpParameters; - struct MenuPage menuArray[NUMBER_OF_MENUS]; - char errorMessage[20]; - char warningMessage[20]; Observer observer; + struct MenuCore* menuCore; }; // ----------------------------------------------------------------------------- @@ -170,7 +92,7 @@ struct RepairMenu * @todo * ----------------------------------------------------------------------------- */ -extern ErrorStatus repairMenu_construct(struct RepairMenu* self, struct Display* display, struct KeyboardDevice* keyboardDevice, struct MemoryDevice* memoryDevice, int taskPriority, uint16_t stackSize, Observer repairScreenUpdateObserver); +extern ErrorStatus repairMenu_construct(struct RepairMenu* self, struct MenuCore* menuCore, struct MemoryDevice* memoryDevice, Observer repairScreenUpdateObserver); /** ---------------------------------------------------------------------------- @@ -238,4 +160,10 @@ extern void repairMenu_interlockFailed(struct RepairMenu* self, T_INTERLOCK_ID i extern void repairMenu_processFailed(struct RepairMenu* self); + +extern void repairMenu_menuStateHandle(struct MenuCore* menuCore); + + +extern void repairMenu_createMenuEntries(struct MenuCore* menuCore); + #endif /* INC_REPAIRMENU_H_ */ diff --git a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/DAConverter.c b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/DAConverter.c index 76ea669..a27c78a 100644 --- a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/DAConverter.c +++ b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/DAConverter.c @@ -93,7 +93,6 @@ extern ErrorStatus DAConverter_setOutputVoltage(const struct DAConverter* self, uint32_t dacValue; dacValue = calculateDACValue(self, voltage); DACDevice_write(self->dacDevice, dacValue); - LOGGER_DEBUG(mainLog, "Voltage %d --- value %X", voltage, (unsigned int)dacValue); } } else diff --git a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/MenuCore.c b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/MenuCore.c new file mode 100644 index 0000000..d5e161d --- /dev/null +++ b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/MenuCore.c @@ -0,0 +1,362 @@ +// ----------------------------------------------------------------------------- +/// @file MenuCore.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 MenuCore.c +/// @ingroup {group_name} + + +// ----------------------------------------------------------------------------- +// Include files +// ----------------------------------------------------------------------------- + +#include "MenuCore.h" + +#include "Logger.h" + +// ----------------------------------------------------------------------------- +// Constant and macro definitions +// ----------------------------------------------------------------------------- + + + +// ----------------------------------------------------------------------------- +// Type definitions +// ----------------------------------------------------------------------------- + + +// ----------------------------------------------------------------------------- +// File-scope variables +// ----------------------------------------------------------------------------- + +static const char cursorValue[2] = {0x7E, '\0'}; + +// ----------------------------------------------------------------------------- +// Function declarations +// ----------------------------------------------------------------------------- + +// TASK prototype +static void MenuCore_task(void* parameters); +// Additional functions +static void MenuCore_printMenu(struct MenuCore* self); +static void MenuCore_printCursor(struct MenuCore* self); +static ErrorStatus MenuCore_performAction(struct MenuCore* self, char key, Keypad_KeyState keyState); +static struct KeyActionBinding MenuCore_findKeyAction(struct MenuCore* self, char key, Keypad_KeyState keyState); +static void MenuCore_scrollIndexHandlerReset (struct MenuCore* self); +static void MenuCore_scrollUpIndexHandler(struct MenuCore* self); +static void MenuCore_scrollDownIndexHandler(struct MenuCore* self); + +// ----------------------------------------------------------------------------- +// Function definitions +// ----------------------------------------------------------------------------- + + +ErrorStatus MenuCore_construct(struct MenuCore* self, struct Display* display, struct KeyboardDevice* keyboardDevice, int taskPriority, uint16_t stackSize, MenuCoreFunctionCall createMenu, MenuCoreFunctionCall stateHandle) +{ + ErrorStatus returnValue = SUCCESS; + + if (!self->initialized) + { + if (returnValue == SUCCESS) + { + if (display->initialized) + { + self->display = display; + } + else + { + returnValue = ERROR; + } + } + + if (returnValue == SUCCESS) + { + if (keyboardDevice->initialized) + { + self->keyboardDevice = keyboardDevice; + } + else + { + returnValue = ERROR; + } + } + + if (returnValue == SUCCESS) + { + // Let Task run as soon as it has been created + self->runTask = true; + // Create the menucore task + BaseType_t rv = xTaskCreate(MenuCore_task, "MenuCore", stackSize, self, taskPriority, &self->taskHandle); + if (rv != pdTRUE) + { + returnValue = ERROR; + LOGGER_ERROR(mainLog, "FAILED to start repair Menu with code %d", (int)rv); + } + else + { + LOGGER_INFO(mainLog, "MenuCore task started"); + // Create the menu entries + createMenu(self); + // Set all internal variables + self->_handleStateFunction = stateHandle; + self->scrollOffset = 0; + self->cursorIndex = 1; + self->menuState = 0; + // Menu core is initialised - Menu core is good to go + self->initialized = true; + } + } + } + else + { + returnValue = ERROR; + } + return returnValue; +} + + +void MenuCore_destruct(struct MenuCore* self) +{ + +} + + + +static void MenuCore_task(void* parameters) +{ + struct MenuCore* self = (struct MenuCore*)parameters; + + // Clear the screen for a new menu + Display_clearScreen(self->display); + // Print menu content to output device + MenuCore_printMenu(self); + // Add cursor if necessary + MenuCore_printCursor(self); + + while(self->runTask) + { + char key; + Keypad_KeyState keyState; + + // Take care of potential actions that must be taken prior to reading the keyboard/input + self->_handleStateFunction(self); + + if (KeyboardDevice_read(self->keyboardDevice, &key, &keyState) == SUCCESS) + { + if (MenuCore_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 + MenuCore_printMenu(self); + // Add cursor if necessary + MenuCore_printCursor(self); + } + } + vTaskDelay(50); + } + + LOGGER_INFO(mainLog, "Deleting MenuCore task"); + vTaskDelete(NULL); +} + + +void MenuCore_changeState(struct MenuCore* self, T_MenuState newState) +{ + Display_clearScreen(self->display); + self->menuState = newState; + LOGGER_WARNING(mainLog, "New menu index is %d", self->menuState); +} + +static void MenuCore_printMenu(struct MenuCore* self) +{ + int loopCounter; + + // Always print Row1 (index0), ignoring the scrolling index + Display_write(self->display, self->menuArray[self->menuState].row[0].text, 1, 1); + + 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); + } +} + + +static void MenuCore_printCursor(struct MenuCore* self) +{ + if (self->menuArray[self->menuState].hasCursor) + { + Display_write(self->display, cursorValue, 1 + self->cursorIndex - self->scrollOffset, 1); + } +} + + +static ErrorStatus MenuCore_performAction(struct MenuCore* self, char key, Keypad_KeyState keyState) +{ + 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; + 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) + { + self->menuArray[tempState].row[keyAction.argument].actionPointer(self); + } + MenuCore_scrollIndexHandlerReset(self); + break; + } + + 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; + MenuCore_changeState(self, self->menuArray[self->menuState].row[self->cursorIndex].newState); + if (self->menuArray[tempState].row[self->cursorIndex].actionPointer != NULL) + { + self->menuArray[tempState].row[self->cursorIndex].actionPointer(self); + } + MenuCore_scrollIndexHandlerReset(self); + break; + } + + case GOTO_STATE: + { + LOGGER_INFO(mainLog, "Going to new state %d directly", keyAction.argument); + MenuCore_changeState(self, keyAction.argument); +// MenuCore_scrollIndexHandlerReset(self); + break; + } + + case EXECUTE_FUNCTION: + { + LOGGER_INFO(mainLog, "Executing function directly"); + if (keyAction.actionPointer != NULL) + { + keyAction.actionPointer(self); + } + break; + } + + 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"); + break; + } + } + return returnValue; +} + + +static struct KeyActionBinding MenuCore_findKeyAction(struct MenuCore* self, char key, Keypad_KeyState keyState) +{ + int loopCounter; + struct KeyActionBinding returnValue; + returnValue.action = NO_ACTION; + + for (loopCounter = 0; loopCounter < MENUCORE_MAX_NUMBER_OF_KEYS; loopCounter++) + { + 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; + } + } + return returnValue; +} + + +static void MenuCore_scrollIndexHandlerReset (struct MenuCore* self) +{ + self->cursorIndex = 1; + self->scrollOffset = 0; +} + +static void MenuCore_scrollUpIndexHandler(struct MenuCore* self) +{ + if (self->cursorIndex - self->scrollOffset > 1) + { + if (self->cursorIndex > 1) + { + self->cursorIndex--; + } + } + else + { + if (self->cursorIndex > 1) + { + self->cursorIndex--; + } + + if (self->scrollOffset > 0) + { + self->scrollOffset--; + } + } +} + + +static void MenuCore_scrollDownIndexHandler(struct MenuCore* self) +{ + if (self->cursorIndex < self->display->displayDevice->parameters.numberOfRows - 1) + { + if (self->cursorIndex < self->menuArray[self->menuState].numberOfRows - 1) + { + self->cursorIndex++; + } + } + else + { + if (self->cursorIndex < self->menuArray[self->menuState].numberOfRows - 1) + { + self->cursorIndex++; + } + + if (self->scrollOffset < (self->menuArray[self->menuState].numberOfRows - self->display->displayDevice->parameters.numberOfRows)) + { + self->scrollOffset++; + } + } +} diff --git a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/MenuElements.c b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/MenuElements.c new file mode 100644 index 0000000..6342de9 --- /dev/null +++ b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/MenuElements.c @@ -0,0 +1,221 @@ +// ----------------------------------------------------------------------------- +/// @file MenuElements.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 MenuElements.c +/// @ingroup {group_name} + + +// ----------------------------------------------------------------------------- +// Include files +// ----------------------------------------------------------------------------- + +#include "string.h" + +#include "MenuElements.h" + +// ----------------------------------------------------------------------------- +// Constant and macro definitions +// ----------------------------------------------------------------------------- + + + +// ----------------------------------------------------------------------------- +// Type definitions +// ----------------------------------------------------------------------------- + + +// ----------------------------------------------------------------------------- +// File-scope variables +// ----------------------------------------------------------------------------- + + + +// ----------------------------------------------------------------------------- +// Function declarations +// ----------------------------------------------------------------------------- + + + +// ----------------------------------------------------------------------------- +// Function definitions +// ----------------------------------------------------------------------------- + + +ErrorStatus MenuElements_createMenuPage (struct MenuPage* self, bool hasCursor, int maxNumberOfRows) +{ + ErrorStatus returnValue = SUCCESS; + + if (maxNumberOfRows <= MENUCORE_MAX_NUMBER_OF_ROWS) + { + self->maxNumberOfKeys = NUMBER_OF_KEY_EVENTS * MENUCORE_MAX_NUMBER_OF_KEYS; + self->numberOfRows = 0; + self->numberOfKeys = 0; + self->maxNumberOfRows = maxNumberOfRows; + self->hasCursor = hasCursor; + } + else + { + returnValue = ERROR; + } + return returnValue; +} + + +ErrorStatus MenuElements_addMenuPageRow (struct MenuPage* self, const char* text, int newState, MenuCoreFunctionCall actionCall) +{ + ErrorStatus returnValue = SUCCESS; + if (self->numberOfRows < self->maxNumberOfRows) + { + memcpy(self->row[self->numberOfRows].text, text, 20); + self->row[self->numberOfRows].newState = newState; + self->row[self->numberOfRows].actionPointer = actionCall; + self->numberOfRows++; + } + else + { + returnValue = ERROR; + } + return returnValue; +} + + +ErrorStatus MenuElements_addKeyAction_HOTKEYSELECT (struct MenuPage* self, char key, Keypad_KeyState keyState, int rowToSelect) +{ + 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 = HOTKEY_SELECT; + self->keyActionBinding[self->numberOfKeys].argument = rowToSelect; + self->keyActionBinding[self->numberOfKeys].actionPointer = NULL; + self->numberOfKeys++; + } + else + { + returnValue = ERROR; + } + return returnValue; +} + + +ErrorStatus MenuElements_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; +} + + +ErrorStatus MenuElements_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; +} + + +ErrorStatus MenuElements_addKeyAction_EXECUTEFUNCTION (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 = EXECUTE_FUNCTION; + self->keyActionBinding[self->numberOfKeys].argument = 0; + self->keyActionBinding[self->numberOfKeys].actionPointer = actionPointer; + self->numberOfKeys++; + } + else + { + returnValue = ERROR; + } + return returnValue; +} + + +ErrorStatus MenuElements_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; +} + + +ErrorStatus MenuElements_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; +} diff --git a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/SignalProfileGenerator.c b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/SignalProfileGenerator.c index 2069fab..9fbbdb6 100644 --- a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/SignalProfileGenerator.c +++ b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/SignalProfileGenerator.c @@ -249,6 +249,21 @@ void SignalProfileGenerator_pause(struct SignalProfileGenerator* self) } +bool SignalProfileGenerator_isPaused(struct SignalProfileGenerator* self) +{ + bool returnValue; + if (self->currentState == SPG_PAUSE) + { + returnValue = true; + } + else + { + returnValue = false; + } + return returnValue; +} + + void SignalProfileGenerator_continue(struct SignalProfileGenerator* self) { self->currentState = SPG_PAUSE_RESTORE; diff --git a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/main.c b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/main.c index 2f8eec1..23a1498 100644 --- a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/main.c +++ b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/main.c @@ -180,8 +180,6 @@ static ErrorStatus systeminfoCommandHandler(void) vTaskDelay(10); OS_logTaskInfo(mainDisplay->taskHandle); vTaskDelay(10); - OS_logTaskInfo(repairMenus_getMainRepairMenu()->taskHandle); - vTaskDelay(10); OS_logTaskInfo(repairProcesses_getMainRepairProcess()->taskHandle); diff --git a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/repairMenu.c b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/repairMenu.c index af0de79..79a5367 100644 --- a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/repairMenu.c +++ b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/repairMenu.c @@ -28,6 +28,7 @@ #include "stdio.h" #include "string.h" #include "repairMenu.h" +#include "repairMenus.h" #include "RepairPreset.h" #include "repairProcess.h" #include "repairProcesses.h" @@ -38,6 +39,9 @@ #include "Display.h" #include "Error.h" #include "hsb-mrts.h" +#include "MenuCore.h" +#include "MenuElements.h" +#include "MenuText.h" #include "CoverSolenoid.h" #include "Logger.h" @@ -70,50 +74,30 @@ // File-scope variables // ----------------------------------------------------------------------------- -static const char cursorValue[2] = {0x7E, '\0'}; // ----------------------------------------------------------------------------- // Function declarations // ----------------------------------------------------------------------------- -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_printAskPause(struct RepairMenu* self); -static void repairMenu_printPause(struct RepairMenu* self); -static void repairMenu_printFinish(struct RepairMenu* self); -static void repairMenu_printPreset(struct RepairMenu* self); -static void repairMenu_printMenu(struct RepairMenu* self); -static void repairMenu_printCursor(struct RepairMenu* self); -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_printError(struct MenuCore* self); +static void repairMenu_printWarning(struct MenuCore* self); +static void repairMenu_printRepair(struct MenuCore* self); +static void repairMenu_printAskPause(struct MenuCore* self); +static void repairMenu_printPause(struct MenuCore* self); +static void repairMenu_printFinish(struct MenuCore* self); +static void repairMenu_printPreset(struct MenuCore* self); -static void repairMenu_selectCathodeRepair(struct RepairMenu* self, int cursorIndex); -static void repairMenu_selectMCPRepair(struct RepairMenu* self, int cursorIndex); -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 void repairMenu_startRepairProcess(struct RepairMenu* self, int cursorIndex); -static void repairMenu_stopRepairProcess(struct RepairMenu* self, int cursorIndex); -static void repairMenu_abortRepairProcessAndGotoMainMenu(struct RepairMenu* self, int cursorIndex); -static void repairMenu_pauseRepairProcess(struct RepairMenu* self, int cursorIndex); -static void repairMenu_continueRepairProcess(struct RepairMenu* self, int cursorIndex); - -static ErrorStatus repairMenu_createMenu(struct RepairMenu* self); -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); +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_startRepairProcess(struct MenuCore* self); +static void repairMenu_stopRepairProcess(struct MenuCore* self); +static void repairMenu_abortRepairProcessAndGotoMainMenu(struct MenuCore* self); +static void repairMenu_pauseRepairProcess(struct MenuCore* self); +static void repairMenu_continueRepairProcess(struct MenuCore* self); // ----------------------------------------------------------------------------- @@ -121,7 +105,7 @@ static ErrorStatus repairMenu_addKeyAction_SCROLLDOWN (struct MenuPage* self, ch // ----------------------------------------------------------------------------- -ErrorStatus repairMenu_construct(struct RepairMenu* self, struct Display* display, struct KeyboardDevice* keyboardDevice, struct MemoryDevice* memoryDevice, int taskPriority, uint16_t stackSize, Observer repairScreenUpdateObserver) +ErrorStatus repairMenu_construct(struct RepairMenu* self, struct MenuCore* menuCore, struct MemoryDevice* memoryDevice, Observer repairScreenUpdateObserver) { ErrorStatus returnValue = SUCCESS; @@ -129,21 +113,9 @@ ErrorStatus repairMenu_construct(struct RepairMenu* self, struct Display* displa { if (returnValue == SUCCESS) { - if (display->initialized) + if (menuCore->initialized) { - self->display = display; - } - else - { - returnValue = ERROR; - } - } - - if (returnValue == SUCCESS) - { - if (keyboardDevice->initialized) - { - self->keyboardDevice = keyboardDevice; + self->menuCore = menuCore; } else { @@ -182,28 +154,11 @@ ErrorStatus repairMenu_construct(struct RepairMenu* self, struct Display* displa self->repairPreset = RepairPresets_getPreset(1); } - // Construct the menu based on PCBA information - returnValue = repairMenu_createMenu(self); + MenuCore_changeState(self->menuCore, RM_MAINMENU); - - repairMenu_changeState(self, MAINMENU); - self->runTask = true; - - BaseType_t rv = xTaskCreate(repairMenu_task, "RepairMenu", stackSize, self, taskPriority, &self->taskHandle); - if (rv != pdTRUE) - { - returnValue = ERROR; - LOGGER_ERROR(mainLog, "FAILED to start repair Menu with code %d", (int)rv); - } - else - { - vSemaphoreCreateBinary(self->repairScreenUpdateSemaphore); - self->observer = repairScreenUpdateObserver; - self->initialized = true; - self->cursorIndex = 1; - self->scrollOffset = 0; - LOGGER_INFO(mainLog, "Repair Menu task started"); - } + vSemaphoreCreateBinary(self->repairScreenUpdateSemaphore); + self->observer = repairScreenUpdateObserver; + self->initialized = true; } } else @@ -218,159 +173,56 @@ ErrorStatus repairMenu_construct(struct RepairMenu* self, struct Display* displa void repairMenu_destruct (struct RepairMenu* self) { repairProcesses_abortMainRepairProcess(); - self->runTask = false; self->initialized = false; } void repairMenu_interlockFailed(struct RepairMenu* self, T_INTERLOCK_ID interlockID) { - repairMenu_changeState(self, ERROR_STATE); + MenuCore_changeState(self->menuCore, RM_ERROR_STATE); if (interlockID == COMMON_INTERLOCK) { - snprintf(self->errorMessage, sizeof(self->errorMessage) / sizeof(self->errorMessage[0]), "COVER OPEN"); + snprintf(self->menuCore->errorMessage, sizeof(self->menuCore->errorMessage) / sizeof(self->menuCore->errorMessage[0]), "COVER OPEN"); } } void repairMenu_processFailed(struct RepairMenu* self) { - repairMenu_changeState(self, ERROR_STATE); - snprintf(self->errorMessage, sizeof(self->errorMessage) / sizeof(self->errorMessage[0]), "PROCESS FAILED"); + MenuCore_changeState(self->menuCore, RM_ERROR_STATE); + snprintf(self->menuCore->errorMessage, sizeof(self->menuCore->errorMessage) / sizeof(self->menuCore->errorMessage[0]), "PROCESS FAILED"); } -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); - int tempScreenCounter = 0; - T_MenuState tempMenuState = MAINMENU; - - while(self->runTask) - { - char key; - Keypad_KeyState keyState; - - // Catch ERROR state - if (self->menuState == ERROR_STATE) - { - // Show ERROR message - repairMenu_printError(self); - // Handle error - repairMenu_stopRepairProcess(self, 0); - } - else if (self->menuState == WARNING_STATE) - { - - } - - else if (self->menuState == RM_PRESET_PRINT) - { - repairMenu_printPreset(self); - } - - else if (self->menuState == REPAIR_RUNNING) - { - // Check the remaining repair time - uint32_t remainingTime = repairProcess_getRemainingRepairTime(repairProcesses_getMainRepairProcess()); - if (remainingTime > REPAIRMENU_POPUPSCREEN_TIME) - { - tempScreenCounter = remainingTime - REPAIRMENU_POPUPSCREEN_TIME; - tempMenuState = self->menuState; - } - if (remainingTime == 0) - { - // repair is finished - repairMenu_changeState(self, FINISH_CONTROL); - } - else - { - // Create the repair screen - repairMenu_printRepair(self); - } - } - else if (self->menuState == REPAIR_ASK_PAUSE) - { - uint32_t remainingTime = repairProcess_getRemainingRepairTime(repairProcesses_getMainRepairProcess()); - repairMenu_printAskPause(self); - if (tempScreenCounter >= remainingTime) - { - // POPUP screen time is over, return to previous state - repairMenu_changeState(self, tempMenuState); - } - } - else if (self->menuState == REPAIR_PAUSE) - { - repairMenu_printPause(self); - } - else if (self->menuState == FINISH_CONTROL) - { - repairMenu_stopRepairProcess(self, 0); - repairMenu_changeState(self, FINISH); - } - else if (self->menuState == FINISH) - { - repairMenu_printFinish(self); - } - - if (KeyboardDevice_read(&storm700->keyboardDevice, &key, &keyState) == SUCCESS) - { - 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); - } - } - vTaskDelay(50); - } - - LOGGER_INFO(mainLog, "Deleting RepairMenu task"); - vTaskDelete(NULL); -} -static void repairMenu_changeState(struct RepairMenu* self, T_MenuState newState) -{ - Display_clearScreen(self->display); - self->menuState = newState; - LOGGER_WARNING(mainLog, "New menu index is %d", self->menuState); -} -static void repairMenu_printError(struct RepairMenu* self) + + +static void repairMenu_printError(struct MenuCore* self) { Display_write(self->display, "!!ERROR!!", 2, 6); Display_write(self->display, self->errorMessage, 3, 1 + ((self->display->displayDevice->parameters.numberOfColumns - strlen(self->errorMessage)) / 2)); } -static void repairMenu_printWarning(struct RepairMenu* self) +static void repairMenu_printWarning(struct MenuCore* self) { } -static void repairMenu_printRepair(struct RepairMenu* self) +static void repairMenu_printRepair(struct MenuCore* self) { int loopCounter = 0; char buffer[20]; + struct RepairMenu* repairMenu = repairMenus_getMainRepairMenu(); struct RepairProcess* repairProcess = repairProcesses_getMainRepairProcess(); if (repairProcess_isProcessRunning(repairProcess)) { - if (xSemaphoreTake(self->repairScreenUpdateSemaphore, 0) != pdTRUE) + if (xSemaphoreTake(repairMenu->repairScreenUpdateSemaphore, 0) != pdTRUE) { // Taking semaphore failed - no update on the screen } @@ -379,7 +231,7 @@ static void repairMenu_printRepair(struct RepairMenu* self) struct Time remainingTime; RTC_calculateTimeFromSeconds(repairProcess_getRemainingRepairTime(repairProcess), &remainingTime); - snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%1d", self->repairPreset->presetNumber); + snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%1d", repairMenu->repairPreset->presetNumber); Display_write(self->display, buffer, 1, 1); snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "%02d:%02d:%02d remain ", remainingTime.hours, remainingTime.minutes, remainingTime.seconds); @@ -423,14 +275,14 @@ static void repairMenu_printRepair(struct RepairMenu* self) } -static void repairMenu_printAskPause(struct RepairMenu* self) +static void repairMenu_printAskPause(struct MenuCore* self) { Display_write(self->display, "REPAIR BUSY", 2, 6); Display_write(self->display, "Hit X to PAUSE", 3, 2); } -static void repairMenu_printPause(struct RepairMenu* self) +static void repairMenu_printPause(struct MenuCore* self) { Display_write(self->display, "!!PAUSE!!", 2, 6); Display_write(self->display, "Hit ENT to continue", 3, 2); @@ -438,7 +290,7 @@ static void repairMenu_printPause(struct RepairMenu* self) } -static void repairMenu_printFinish(struct RepairMenu* self) +static void repairMenu_printFinish(struct MenuCore* self) { Display_write(self->display, "REPAIR FINISHED", 2, 6); Display_write(self->display, "Hit ENT to continue", 4, 2); @@ -446,7 +298,7 @@ static void repairMenu_printFinish(struct RepairMenu* self) } -static void repairMenu_printPreset(struct RepairMenu* self) +static void repairMenu_printPreset(struct MenuCore* self) { int loopCounter; char buffer[self->display->displayDevice->parameters.numberOfColumns]; @@ -477,232 +329,62 @@ static void repairMenu_printPreset(struct RepairMenu* self) } -static void repairMenu_printMenu(struct RepairMenu* self) -{ - int loopCounter; - // Always print Row1 (index0), ignoring the scrolling index - Display_write(self->display, self->menuArray[self->menuState].row[0].text, 1, 1); - - 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); - } -} - - -static void repairMenu_printCursor(struct RepairMenu* self) -{ - if (self->menuArray[self->menuState].hasCursor) - { - Display_write(self->display, cursorValue, 1 + self->cursorIndex - self->scrollOffset, 1); - } -} - - -static ErrorStatus repairMenu_performAction(struct RepairMenu* self, char key, Keypad_KeyState keyState) -{ - 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) - { - 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); - 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[tempState].row[keyAction.argument].actionPointer(self, keyAction.argument); - } - repairMenu_scrollIndexHandlerReset(self); - break; - } - - 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; - repairMenu_changeState(self, self->menuArray[self->menuState].row[self->cursorIndex].newState); - if (self->menuArray[tempState].row[self->cursorIndex].actionPointer != NULL) - { - self->menuArray[tempState].row[self->cursorIndex].actionPointer(self, self->cursorIndex); - } - 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"); - repairMenu_scrollUpIndexHandler(self); - break; - } - case SCROLL_DOWN: - { - LOGGER_INFO(mainLog, "Scrolling down"); - repairMenu_scrollDownIndexHandler(self); - break; - } - case DIGIT_INSERT: - { - LOGGER_INFO(mainLog, "Key is allowed as insert"); - break; - } - } - return returnValue; -} - - -static struct KeyActionBinding repairMenu_findKeyAction(struct RepairMenu* self, char key, Keypad_KeyState keyState) -{ - int loopCounter; - struct KeyActionBinding returnValue; - returnValue.action = NO_ACTION; - - for (loopCounter = 0; loopCounter < REPAIRMENU_MAX_NUMBER_OF_KEYS; loopCounter++) - { - 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; - } - } - return returnValue; -} - - -static void repairMenu_scrollIndexHandlerReset (struct RepairMenu* self) -{ - self->cursorIndex = 1; - self->scrollOffset = 0; -} - -static void repairMenu_scrollUpIndexHandler(struct RepairMenu* self) -{ - if (self->cursorIndex - self->scrollOffset > 1) - { - if (self->cursorIndex > 1) - { - self->cursorIndex--; - } - } - else - { - if (self->cursorIndex > 1) - { - self->cursorIndex--; - } - - if (self->scrollOffset > 0) - { - self->scrollOffset--; - } - } -} - - -static void repairMenu_scrollDownIndexHandler(struct RepairMenu* self) -{ - if (self->cursorIndex < self->display->displayDevice->parameters.numberOfRows - 1) - { - if (self->cursorIndex < self->menuArray[self->menuState].numberOfRows - 1) - { - self->cursorIndex++; - } - } - else - { - if (self->cursorIndex < self->menuArray[self->menuState].numberOfRows - 1) - { - self->cursorIndex++; - } - - if (self->scrollOffset < (self->menuArray[self->menuState].numberOfRows - self->display->displayDevice->parameters.numberOfRows)) - { - self->scrollOffset++; - } - } -} - - -static void repairMenu_selectCathodeRepair(struct RepairMenu* self, int cursorIndex) +static void repairMenu_selectCathodeRepair(struct MenuCore* self) { RepairPresets_loadPresets(REPAIR_PRESETS_CATHODE); - self->repairPreset = RepairPresets_getPreset(1); + struct RepairMenu* tempMenu = repairMenus_getMainRepairMenu(); + tempMenu->repairPreset = RepairPresets_getPreset(1); CathodeMCP_switchToCathode(); } -static void repairMenu_selectMCPRepair(struct RepairMenu* self, int cursorIndex) +static void repairMenu_selectMCPRepair(struct MenuCore* self) { RepairPresets_loadPresets(REPAIR_PRESETS_MCP); - self->repairPreset = RepairPresets_getPreset(1); + struct RepairMenu* tempMenu = repairMenus_getMainRepairMenu(); + tempMenu->repairPreset = RepairPresets_getPreset(1); CathodeMCP_switchToMCP(); } -static void repairMenu_selectPreset(struct RepairMenu* self, int cursorIndex) +static void repairMenu_selectPreset(struct MenuCore* self) { - self->repairPreset = RepairPresets_getPreset(cursorIndex); - LOGGER_INFO(mainLog, "Preset %d selected", cursorIndex); + struct RepairMenu* tempMenu = repairMenus_getMainRepairMenu(); + tempMenu->repairPreset = RepairPresets_getPreset(self->cursorIndex); Display_clearScreen(self->display); char buffer[20]; - snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "Preset %d selected", cursorIndex); - Display_write(self->display, buffer, 2, 2); + snprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), "Preset %d selected", self->cursorIndex); + Display_write(self->display, buffer, 3, 2); vTaskDelay(2000); } -static void repairMenu_solenoidLock(struct RepairMenu* self, int cursorIndex) +static void repairMenu_solenoidLock(struct MenuCore* self) { CoverSolenoid_lock(); } -static void repairMenu_solenoidUnlock(struct RepairMenu* self, int cursorIndex) +static void repairMenu_solenoidUnlock(struct MenuCore* self) { CoverSolenoid_unlock(); } -static void repairMenu_startRepairProcess(struct RepairMenu* self, int cursorIndex) +static void repairMenu_startRepairProcess(struct MenuCore* self) { ErrorStatus returnValue = SUCCESS; - self->rpParameters.adcR1 = adcRow1; - self->rpParameters.adcR2 = adcRow2; - self->rpParameters.adcR3 = adcRow3; - self->rpParameters.dacR1 = dacRow1; - self->rpParameters.dacR2 = dacRow2; - self->rpParameters.dacR3 = dacRow3; + + struct RepairMenu* repairMenu = repairMenus_getMainRepairMenu(); + + repairMenu->rpParameters.adcR1 = adcRow1; + repairMenu->rpParameters.adcR2 = adcRow2; + repairMenu->rpParameters.adcR3 = adcRow3; + repairMenu->rpParameters.dacR1 = dacRow1; + repairMenu->rpParameters.dacR2 = dacRow2; + repairMenu->rpParameters.dacR3 = dacRow3; if (returnValue == SUCCESS) { @@ -722,7 +404,7 @@ static void repairMenu_startRepairProcess(struct RepairMenu* self, int cursorInd // If all is OK, start the repair process if (returnValue == SUCCESS) { - returnValue = repairProcesses_startMainRepairProcess(self->repairPreset, &self->rpParameters); + returnValue = repairProcesses_startMainRepairProcess(repairMenu->repairPreset, &repairMenu->rpParameters); if (returnValue != SUCCESS) { Error_postError(REPAIR_FAIL); @@ -731,12 +413,12 @@ static void repairMenu_startRepairProcess(struct RepairMenu* self, int cursorInd if (returnValue == SUCCESS) { - returnValue = repairProcesses_mainRepairProcessAddObserver(self->observer); + returnValue = repairProcesses_mainRepairProcessAddObserver(repairMenu->observer); if (returnValue == SUCCESS) { // repair process is running - repairMenu_changeState(self, REPAIR_RUNNING); + MenuCore_changeState(self, RM_REPAIR_RUNNING); } else { @@ -746,334 +428,235 @@ static void repairMenu_startRepairProcess(struct RepairMenu* self, int cursorInd } -static void repairMenu_stopRepairProcess(struct RepairMenu* self, int cursorIndex) +static void repairMenu_stopRepairProcess(struct MenuCore* self) { if (PCBA_getInstance()->pcba == PCBA_Tesla) { TeslaGunSafety_block(); } - repairProcesses_mainRepairProcessRemoveObserver(self->observer); + struct RepairMenu* tempMenu = repairMenus_getMainRepairMenu(); + repairProcesses_mainRepairProcessRemoveObserver(tempMenu->observer); repairProcesses_abortMainRepairProcess(); hsb_disableSafety(); } -static void repairMenu_abortRepairProcessAndGotoMainMenu(struct RepairMenu* self, int cursorIndex) +static void repairMenu_abortRepairProcessAndGotoMainMenu(struct MenuCore* self) { - repairMenu_stopRepairProcess(self, cursorIndex); - repairMenu_changeState(self, MAINMENU); + repairMenu_stopRepairProcess(self); + MenuCore_changeState(self, RM_MAINMENU); } -static void repairMenu_pauseRepairProcess(struct RepairMenu* self, int cursorIndex) +static void repairMenu_pauseRepairProcess(struct MenuCore* self) { - repairMenu_changeState(self, REPAIR_PAUSE); + MenuCore_changeState(self, RM_REPAIR_PAUSE); repairProcess_pauseProcess(repairProcesses_getMainRepairProcess()); hsb_disableSafety(); } -static void repairMenu_continueRepairProcess(struct RepairMenu* self, int cursorIndex) +static void repairMenu_continueRepairProcess(struct MenuCore* self) { hsb_enableSafety(); - repairMenu_changeState(self, REPAIR_RUNNING); + MenuCore_changeState(self, RM_REPAIR_RUNNING); repairProcess_continueProcess(repairProcesses_getMainRepairProcess()); } - -static ErrorStatus repairMenu_createMenu(struct RepairMenu* self) +void repairMenu_menuStateHandle(struct MenuCore* self) { - ErrorStatus returnValue = SUCCESS; - repairMenu_createMenuPage(&self->menuArray[MAINMENU], MENU_HAS_CURSOR, 4); - repairMenu_addMenuPageRow(&self->menuArray[MAINMENU], PCBA_getInstance()->name, MAINMENU, NULL); + // Catch ERROR state + if (self->menuState == RM_ERROR_STATE) + { + // Show ERROR message + repairMenu_printError(self); + // Handle error + repairMenu_stopRepairProcess(self); + } + else if (self->menuState == RM_WARNING_STATE) + { + repairMenu_printWarning(self); + } + + else if (self->menuState == RM_PRESET_PRINT) + { + repairMenu_printPreset(self); + } + + else if (self->menuState == RM_REPAIR_RUNNING) + { + // Check the remaining repair time + uint32_t remainingTime = repairProcess_getRemainingRepairTime(repairProcesses_getMainRepairProcess()); + if (remainingTime > REPAIRMENU_POPUPSCREEN_TIME) + { + self->popUpCounter = remainingTime - REPAIRMENU_POPUPSCREEN_TIME; + self->lastMenuState = self->menuState; + } + if (remainingTime == 0) + { + // repair is finished + MenuCore_changeState(self, RM_FINISH_CONTROL); + } + else + { + // Create the repair screen + repairMenu_printRepair(self); + } + } + else if (self->menuState == RM_REPAIR_ASK_PAUSE) + { + uint32_t remainingTime = repairProcess_getRemainingRepairTime(repairProcesses_getMainRepairProcess()); + repairMenu_printAskPause(self); + if (self->popUpCounter >= remainingTime) + { + // POPUP screen time is over, return to previous state + MenuCore_changeState(self, self->lastMenuState); + } + } + else if (self->menuState == RM_REPAIR_PAUSE) + { + repairMenu_printPause(self); + } + else if (self->menuState == RM_FINISH_CONTROL) + { + repairMenu_stopRepairProcess(self); + MenuCore_changeState(self, RM_FINISH); + } + else if (self->menuState == RM_FINISH) + { + repairMenu_printFinish(self); + } +} + + + +void repairMenu_createMenuEntries(struct MenuCore* menuCore) +{ + + 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 - repairMenu_addMenuPageRow(&self->menuArray[MAINMENU], " 1.Tube repair", RM_CATHODEMCP_SELECT, NULL); + MenuElements_addMenuPageRow(&menuCore->menuArray[RM_MAINMENU], MenuText_MAINMENU[MENUTEXT_ENGLISH][1], RM_CATHODEMCP_SELECT, NULL); } else { - repairMenu_addMenuPageRow(&self->menuArray[MAINMENU], " 1.Tube repair", REPAIRMENU, NULL); + MenuElements_addMenuPageRow(&menuCore->menuArray[RM_MAINMENU], MenuText_MAINMENU[MENUTEXT_ENGLISH][1], RM_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); + 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); + MenuElements_addKeyAction_SELECT(&menuCore->menuArray[RM_MAINMENU], 'E', PRESSED); + MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_MAINMENU], '1', PRESSED, 1); + MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_MAINMENU], '2', PRESSED, 2); + MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_MAINMENU], '3', PRESSED, 3); + MenuElements_addKeyAction_EXECUTEFUNCTION(&menuCore->menuArray[RM_MAINMENU], '0', PRESSED, repairMenu_solenoidUnlock); + MenuElements_addKeyAction_EXECUTEFUNCTION(&menuCore->menuArray[RM_MAINMENU], '0', RELEASED, repairMenu_solenoidLock); - repairMenu_createMenuPage(&self->menuArray[RM_CATHODEMCP_SELECT], MENU_HAS_CURSOR, 3); - repairMenu_addMenuPageRow(&self->menuArray[RM_CATHODEMCP_SELECT], "Tube repair", RM_CATHODEMCP_SELECT, NULL); - repairMenu_addMenuPageRow(&self->menuArray[RM_CATHODEMCP_SELECT], " 1.Cathode repair", REPAIRMENU, repairMenu_selectCathodeRepair); - repairMenu_addMenuPageRow(&self->menuArray[RM_CATHODEMCP_SELECT], " 2.MCP repair", REPAIRMENU, repairMenu_selectMCPRepair); - repairMenu_addKeyAction_SCROLLUP(&self->menuArray[RM_CATHODEMCP_SELECT], 'U', PRESSED); - repairMenu_addKeyAction_SCROLLDOWN(&self->menuArray[RM_CATHODEMCP_SELECT], 'D', PRESSED); - repairMenu_addKeyAction_SELECT(&self->menuArray[RM_CATHODEMCP_SELECT], 'E', PRESSED); - repairMenu_addKeyAction_HOTKEYSELECT(&self->menuArray[RM_CATHODEMCP_SELECT], '1', PRESSED, 1); - repairMenu_addKeyAction_HOTKEYSELECT(&self->menuArray[RM_CATHODEMCP_SELECT], '2', PRESSED, 2); - repairMenu_addKeyAction_GOTOSTATE(&self->menuArray[RM_CATHODEMCP_SELECT], 'X', PRESSED, MAINMENU); - repairMenu_addKeyAction_EXECUTEFUNCTION(&self->menuArray[RM_CATHODEMCP_SELECT], '0', PRESSED, repairMenu_solenoidUnlock); - repairMenu_addKeyAction_EXECUTEFUNCTION(&self->menuArray[RM_CATHODEMCP_SELECT], '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); - repairMenu_createMenuPage(&self->menuArray[REPAIRMENU], MENU_HAS_CURSOR, 4); - 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); + 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); + MenuElements_addMenuPageRow(&menuCore->menuArray[RM_REPAIRMENU], MenuText_REPAIRMENU[MENUTEXT_ENGLISH][2], RM_START_REPAIR, repairMenu_startRepairProcess); + MenuElements_addKeyAction_SCROLLUP(&menuCore->menuArray[RM_REPAIRMENU], 'U', PRESSED); + MenuElements_addKeyAction_SCROLLDOWN(&menuCore->menuArray[RM_REPAIRMENU], 'D', PRESSED); + MenuElements_addKeyAction_SELECT(&menuCore->menuArray[RM_REPAIRMENU], 'E', PRESSED); + MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_REPAIRMENU], '1', PRESSED, 1); + MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_REPAIRMENU], '2', PRESSED, 2); if (PCBA_getInstance()->pcba == PCBA_CathodeMCP) { // For Cathode/MCP PCBA, the type of repair must can be selected - repairMenu_addKeyAction_GOTOSTATE(&self->menuArray[REPAIRMENU], 'X', PRESSED, RM_CATHODEMCP_SELECT); + MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_REPAIRMENU], 'X', PRESSED, RM_CATHODEMCP_SELECT); } else { - repairMenu_addKeyAction_GOTOSTATE(&self->menuArray[REPAIRMENU], 'X', PRESSED, MAINMENU); + MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_REPAIRMENU], 'X', PRESSED, RM_MAINMENU); } - repairMenu_addKeyAction_EXECUTEFUNCTION(&self->menuArray[REPAIRMENU], '0', PRESSED, repairMenu_solenoidUnlock); - repairMenu_addKeyAction_EXECUTEFUNCTION(&self->menuArray[REPAIRMENU], '0', RELEASED, repairMenu_solenoidLock); + MenuElements_addKeyAction_EXECUTEFUNCTION(&menuCore->menuArray[RM_REPAIRMENU], '0', PRESSED, repairMenu_solenoidUnlock); + MenuElements_addKeyAction_EXECUTEFUNCTION(&menuCore->menuArray[RM_REPAIRMENU], '0', RELEASED, repairMenu_solenoidLock); - repairMenu_createMenuPage(&self->menuArray[ADMINMENU], MENU_HAS_NO_CURSOR, 2); - 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); + 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); - repairMenu_createMenuPage(&self->menuArray[CALIBRATIONMENU], MENU_HAS_NO_CURSOR, 2); - 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); + 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); - 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_addKeyAction_GOTOSTATE(&self->menuArray[PRESETMENU], 'R', PRESSED, RM_PRESET_PRINT); + 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); + MenuElements_addMenuPageRow(&menuCore->menuArray[RM_PRESETMENU], MenuText_PRESETMENU[MENUTEXT_ENGLISH][2], RM_REPAIRMENU, repairMenu_selectPreset); + MenuElements_addMenuPageRow(&menuCore->menuArray[RM_PRESETMENU], MenuText_PRESETMENU[MENUTEXT_ENGLISH][3], RM_REPAIRMENU, repairMenu_selectPreset); + MenuElements_addMenuPageRow(&menuCore->menuArray[RM_PRESETMENU], MenuText_PRESETMENU[MENUTEXT_ENGLISH][4], RM_REPAIRMENU, repairMenu_selectPreset); + MenuElements_addMenuPageRow(&menuCore->menuArray[RM_PRESETMENU], MenuText_PRESETMENU[MENUTEXT_ENGLISH][5], RM_REPAIRMENU, repairMenu_selectPreset); + MenuElements_addMenuPageRow(&menuCore->menuArray[RM_PRESETMENU], MenuText_PRESETMENU[MENUTEXT_ENGLISH][6], RM_REPAIRMENU, repairMenu_selectPreset); + MenuElements_addMenuPageRow(&menuCore->menuArray[RM_PRESETMENU], MenuText_PRESETMENU[MENUTEXT_ENGLISH][7], RM_REPAIRMENU, repairMenu_selectPreset); + MenuElements_addMenuPageRow(&menuCore->menuArray[RM_PRESETMENU], MenuText_PRESETMENU[MENUTEXT_ENGLISH][8], RM_REPAIRMENU, repairMenu_selectPreset); + MenuElements_addMenuPageRow(&menuCore->menuArray[RM_PRESETMENU], MenuText_PRESETMENU[MENUTEXT_ENGLISH][9], RM_REPAIRMENU, repairMenu_selectPreset); + MenuElements_addKeyAction_SCROLLUP(&menuCore->menuArray[RM_PRESETMENU], 'U', PRESSED); + MenuElements_addKeyAction_SCROLLDOWN(&menuCore->menuArray[RM_PRESETMENU], 'D', PRESSED); + MenuElements_addKeyAction_SELECT(&menuCore->menuArray[RM_PRESETMENU], 'E', PRESSED); + MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_PRESETMENU], '1', PRESSED, 1); + MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_PRESETMENU], '2', PRESSED, 2); + MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_PRESETMENU], '3', PRESSED, 3); + MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_PRESETMENU], '4', PRESSED, 4); + MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_PRESETMENU], '5', PRESSED, 5); + MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_PRESETMENU], '6', PRESSED, 6); + MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_PRESETMENU], '7', PRESSED, 7); + MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_PRESETMENU], '8', PRESSED, 8); + MenuElements_addKeyAction_HOTKEYSELECT(&menuCore->menuArray[RM_PRESETMENU], '9', PRESSED, 9); + MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_PRESETMENU], 'X', PRESSED, RM_REPAIRMENU); + MenuElements_addKeyAction_EXECUTEFUNCTION(&menuCore->menuArray[RM_PRESETMENU], '0', PRESSED, repairMenu_solenoidUnlock); + MenuElements_addKeyAction_EXECUTEFUNCTION(&menuCore->menuArray[RM_PRESETMENU], '0', RELEASED, repairMenu_solenoidLock); + MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_PRESETMENU], 'R', PRESSED, RM_PRESET_PRINT); - repairMenu_createMenuPage(&self->menuArray[RM_PRESET_PRINT], MENU_HAS_NO_CURSOR, 10); - repairMenu_addKeyAction_GOTOSTATE(&self->menuArray[RM_PRESET_PRINT], 'X', PRESSED, PRESETMENU); - repairMenu_addKeyAction_GOTOSTATE(&self->menuArray[RM_PRESET_PRINT], 'L', PRESSED, PRESETMENU); + MenuElements_createMenuPage(&menuCore->menuArray[RM_PRESET_PRINT], MENU_HAS_NO_CURSOR, 10); + MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_PRESET_PRINT], 'X', PRESSED, RM_PRESETMENU); + MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_PRESET_PRINT], 'L', PRESSED, RM_PRESETMENU); - repairMenu_createMenuPage(&self->menuArray[REPAIR_RUNNING], MENU_HAS_NO_CURSOR, 4); - repairMenu_addKeyAction_GOTOSTATE(&self->menuArray[REPAIR_RUNNING], 'X', PRESSED, REPAIR_ASK_PAUSE); + 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); - repairMenu_createMenuPage(&self->menuArray[REPAIR_ASK_PAUSE], MENU_HAS_NO_CURSOR, 4); - repairMenu_addKeyAction_EXECUTEFUNCTION(&self->menuArray[REPAIR_ASK_PAUSE], 'X', PRESSED, repairMenu_pauseRepairProcess); + MenuElements_createMenuPage(&menuCore->menuArray[RM_REPAIR_ASK_PAUSE], MENU_HAS_NO_CURSOR, 4); + MenuElements_addKeyAction_EXECUTEFUNCTION(&menuCore->menuArray[RM_REPAIR_ASK_PAUSE], 'X', PRESSED, repairMenu_pauseRepairProcess); - repairMenu_createMenuPage(&self->menuArray[REPAIR_PAUSE], MENU_HAS_NO_CURSOR, 4); - repairMenu_addKeyAction_EXECUTEFUNCTION(&self->menuArray[REPAIR_PAUSE], 'X', PRESSED, repairMenu_abortRepairProcessAndGotoMainMenu); - repairMenu_addKeyAction_EXECUTEFUNCTION(&self->menuArray[REPAIR_PAUSE], 'E', PRESSED, repairMenu_continueRepairProcess); - repairMenu_addKeyAction_EXECUTEFUNCTION(&self->menuArray[REPAIR_PAUSE], '0', PRESSED, repairMenu_solenoidUnlock); - repairMenu_addKeyAction_EXECUTEFUNCTION(&self->menuArray[REPAIR_PAUSE], '0', RELEASED, repairMenu_solenoidLock); + MenuElements_createMenuPage(&menuCore->menuArray[RM_REPAIR_PAUSE], MENU_HAS_NO_CURSOR, 4); + MenuElements_addKeyAction_EXECUTEFUNCTION(&menuCore->menuArray[RM_REPAIR_PAUSE], 'X', PRESSED, repairMenu_abortRepairProcessAndGotoMainMenu); + MenuElements_addKeyAction_EXECUTEFUNCTION(&menuCore->menuArray[RM_REPAIR_PAUSE], 'E', PRESSED, repairMenu_continueRepairProcess); + MenuElements_addKeyAction_EXECUTEFUNCTION(&menuCore->menuArray[RM_REPAIR_PAUSE], '0', PRESSED, repairMenu_solenoidUnlock); + MenuElements_addKeyAction_EXECUTEFUNCTION(&menuCore->menuArray[RM_REPAIR_PAUSE], '0', RELEASED, repairMenu_solenoidLock); - repairMenu_createMenuPage(&self->menuArray[FINISH], MENU_HAS_NO_CURSOR, 4); - repairMenu_addKeyAction_GOTOSTATE(&self->menuArray[FINISH], 'E', PRESSED, MAINMENU); + MenuElements_createMenuPage(&menuCore->menuArray[RM_FINISH], MENU_HAS_NO_CURSOR, 4); + MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_FINISH], 'E', PRESSED, RM_MAINMENU); - repairMenu_createMenuPage(&self->menuArray[ERROR_STATE], MENU_HAS_NO_CURSOR, 4); - repairMenu_addKeyAction_GOTOSTATE(&self->menuArray[ERROR_STATE], 'X', PRESSED, MAINMENU); + MenuElements_createMenuPage(&menuCore->menuArray[RM_ERROR_STATE], MENU_HAS_NO_CURSOR, 4); + MenuElements_addKeyAction_GOTOSTATE(&menuCore->menuArray[RM_ERROR_STATE], 'X', PRESSED, RM_MAINMENU); - return returnValue; -} - -static ErrorStatus repairMenu_createMenuPage (struct MenuPage* self, bool hasCursor, int maxNumberOfRows) -{ - ErrorStatus returnValue = SUCCESS; - - - if (maxNumberOfRows <= REPAIRMENU_MAX_NUMBER_OF_ROWS) - { - self->maxNumberOfKeys = NUMBER_OF_KEY_EVENTS * REPAIRMENU_MAX_NUMBER_OF_KEYS; - self->numberOfRows = 0; - self->numberOfKeys = 0; - self->maxNumberOfRows = maxNumberOfRows; - self->hasCursor = hasCursor; - } - else - { - returnValue = ERROR; - } - return returnValue; -} - -static ErrorStatus repairMenu_addMenuPageRow (struct MenuPage* self, char* text, int newState, RepairMenuFunctionCall actionCall) -{ - ErrorStatus returnValue = SUCCESS; - if (self->numberOfRows < self->maxNumberOfRows) - { - memcpy(self->row[self->numberOfRows].text, text, 20); - self->row[self->numberOfRows].newState = newState; - self->row[self->numberOfRows].actionPointer = actionCall; - self->numberOfRows++; - } - else - { - returnValue = ERROR; - } - return returnValue; } -static ErrorStatus repairMenu_addKeyAction_HOTKEYSELECT (struct MenuPage* self, char key, Keypad_KeyState keyState, int rowToSelect) -{ - 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 = 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; -} diff --git a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/repairMenus.c b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/repairMenus.c index 2ac3132..7fd5ada 100644 --- a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/repairMenus.c +++ b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/repairMenus.c @@ -30,6 +30,7 @@ #include "hsb-mrts.h" #include "Error.h" +#include "MenuCore.h" #include "repairMenus.h" #include "repairMenu.h" @@ -49,6 +50,9 @@ // Type definitions // ----------------------------------------------------------------------------- +static struct MenuCore _menuCore = {.initialized = false}; +struct MenuCore* const menuCore = &_menuCore; + static struct RepairMenu _mainMenu = {.initialized = false}; struct RepairMenu* const mainMenu = &_mainMenu; @@ -62,8 +66,8 @@ struct RepairMenu* const mainMenu = &_mainMenu; // Function declarations // ----------------------------------------------------------------------------- -static ErrorStatus repairMenu_errorReceive(const void* const data); -static ErrorStatus repairMenu_freeMainMenuRepairScreenUpdateSemaphore(const void* const data); +static ErrorStatus repairMenus_errorReceive(const void* const data); +static ErrorStatus repairMenus_freeMainMenuRepairScreenUpdateSemaphore(const void* const data); // ----------------------------------------------------------------------------- // Function definitions @@ -75,13 +79,16 @@ ErrorStatus repairMenus_construct(void) if (returnValue == SUCCESS) { + // Create the Menu core + returnValue = MenuCore_construct(menuCore, mainDisplay, &storm700->keyboardDevice, HSB_MAINMENU_TASK_PRIORITY, HSB_MAINMENU_TASK_STACKSIZE, repairMenu_createMenuEntries, repairMenu_menuStateHandle); + // Create first repair menu - returnValue = repairMenu_construct(mainMenu, mainDisplay, &storm700->keyboardDevice, &iFlash->memoryDevice, HSB_MAINMENU_TASK_PRIORITY, HSB_MAINMENU_TASK_STACKSIZE, repairMenu_freeMainMenuRepairScreenUpdateSemaphore); + returnValue = repairMenu_construct(mainMenu, menuCore,&iFlash->memoryDevice, repairMenus_freeMainMenuRepairScreenUpdateSemaphore); } if (returnValue == SUCCESS) { - returnValue = Observable_addObserver(Error_getObservable(), repairMenu_errorReceive); + returnValue = Observable_addObserver(Error_getObservable(), repairMenus_errorReceive); } return returnValue; @@ -90,7 +97,7 @@ ErrorStatus repairMenus_construct(void) void repairMenus_destruct(void) { - Observable_deleteObserver(Error_getObservable(), repairMenu_errorReceive); + Observable_deleteObserver(Error_getObservable(), repairMenus_errorReceive); repairMenu_destruct(mainMenu); } @@ -101,7 +108,7 @@ struct RepairMenu* repairMenus_getMainRepairMenu(void) } -static ErrorStatus repairMenu_errorReceive(const void* const data) +static ErrorStatus repairMenus_errorReceive(const void* const data) { T_ErrorCode errorCode = (T_ErrorCode)data; @@ -122,7 +129,7 @@ static ErrorStatus repairMenu_errorReceive(const void* const data) } -static ErrorStatus repairMenu_freeMainMenuRepairScreenUpdateSemaphore(const void* const data) +static ErrorStatus repairMenus_freeMainMenuRepairScreenUpdateSemaphore(const void* const data) { ErrorStatus returnValue = SUCCESS; if (xSemaphoreGive(mainMenu->repairScreenUpdateSemaphore) != pdTRUE) diff --git a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/repairProcess.c b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/repairProcess.c index 1b60f8b..784bdee 100644 --- a/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/repairProcess.c +++ b/S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/hsb-mrts/src/repairProcess.c @@ -231,7 +231,7 @@ static void repairProcess_task(void* parameters) LOGGER_DEBUG(mainLog, "Signal: %d, TimeToRemain %d", self->signalProfileGenerator.signal, (unsigned int)SignalProfileGenerator_getRemainingTime(&self->signalProfileGenerator)); // Check for correct signal -// if (self->signalProfileGenerator.signal >= 0) + if (!SignalProfileGenerator_isPaused(&self->signalProfileGenerator)) { // Regulation is unique for each row // For TESLA repair only row 1 (out of 0,1,2) is used