OpenSource/floatpump-firmware
1
0
Fork 0
Code Pull Requests Releases 4 Wiki Activity

CLEANUP: Cleaned up menu code

Browse Source
This commit is contained in:
Robin Dietzel 2023-01-06 13:51:07 +01:00
parent 025c5e17d3
commit ff0393db48
17 changed files with 433 additions and 333 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Core/Inc/git_rev.h
View File

@ -7,6 +7,6 @@
// Auto generated header file containing the last git revision
#define GIT_HASH "3e3f570"
#define GIT_HASH "a8757b1"
#endif //FLOATPUMP_GIT_REVISION_TEMPLATE_H

4
Core/Src/main.cpp
View File

@ -91,7 +91,7 @@ int main(void) {
HAL_GPIO_WritePin(LED5_GPIO_Port, LED5_Pin, GPIO_PIN_RESET);
using namespace floatpump::menu;
Menu mainmenu(display);
Menu mainmenu("Hauptmenue");
Menu_Entry_Type_Checkable entry1bool(true);
entry1bool.linkConfig(globalConfig.testbool.getLink());
Menu_Entry entry(&entry1bool, "test");
@ -108,7 +108,7 @@ int main(void) {
mainmenu.addEntry(entry2);
mainmenu.addEntry(entry3);
Menu submenu(display);
Menu submenu("Submenu1");
Menu_Entry_Type_Checkable entrysub(true);
Menu_Entry sube(&entrysub, "yay dies sub!");
submenu.addEntry(sube);

90
Middlewares/floatpump/Inc/Menu.h
View File

@ -5,86 +5,50 @@
#ifndef FLOATPUMP_MENU_H
#define FLOATPUMP_MENU_H
#include <utility>
#include <vector>
#include <typeinfo>
#include "Menu_Entry.h"
#include "LCD_I2C_Driver.h"
namespace floatpump {
namespace menu {
namespace floatpump::menu {
class Menu {
class Menu {
public:
Menu(LCD_I2C_Driver &driver) : m_driver(driver) {
}
public:
void addEntry(Menu_Entry entry) {
m_entries.push_back(entry);
}
explicit Menu(std::string name) : m_name(std::move(name)) {}
void addSubmenu(Menu *submenu) {
submenu->m_parent = this;
m_submenus.push_back(submenu);
}
//Add specific components
void addEntry(const Menu_Entry &entry);
std::string printLine() {
return m_name;
}
void addSubmenu(Menu *submenu);
std::vector<std::string> getDisplayList() {
std::vector<std::string> list;
//Get this menu as string
[[nodiscard]] std::string printLine() const;
//first show submenus
//Get all submenus and entries as string vector
std::vector<std::string> getDisplayList();
for(auto it = m_submenus.begin(); it != m_submenus.end(); ++it) {
list.push_back((*it)->printLine());
}
//Get number of all entries
[[nodiscard]] unsigned int getAllEntriesNum() const;
for(auto it = m_entries.begin(); it != m_entries.end(); ++it) {
list.push_back(it->printLine());
}
//Retrieve specific submenu, returns nullptr on error
Menu *getSubmenu(int index);
//Retrieve specific entry, returns nullptr on error
Menu_Entry *getEntry(int index);
if(m_parent != nullptr) {
list.push_back("<- Go Back");
}
//Returns parent menu pointer or nullptr
Menu *getParent();
return list;
}
private:
std::vector<Menu_Entry> m_entries; //normal menu entries
std::vector<Menu *> m_submenus; //all submenu entries
Menu *m_parent = nullptr; //the parent menu, if it is a submenu
std::string m_name = "Menu"; //the name of this menu (displayed if it is an submenu)
};
int getAllEntriesNum() {
return (m_entries.size() + m_submenus.size()) + ((m_parent != nullptr)? 1 : 0);
}
Menu *getSubmenu(int index) {
if(index >= 0 && index < m_submenus.size()) {
return m_submenus[index];
} else {
return nullptr;
}
}
Menu_Entry *getEntry(int index) {
if(index >= m_submenus.size() && index < m_entries.size() + m_submenus.size()) {
return &m_entries[index - m_submenus.size()];
} else {
return nullptr;
}
}
LCD_I2C_Driver &m_driver;
std::vector<Menu_Entry> m_entries;
std::vector<Menu *> m_submenus;
Menu *m_parent = nullptr;
int m_current_index = 0;
std::string m_name = "Menu";
private:
};
} // floatpump
} // menu
}
#endif //FLOATPUMP_MENU_H

138
Middlewares/floatpump/Inc/Menu_Controller.h
View File

@ -7,119 +7,39 @@
#include "Menu.h"
namespace floatpump {
namespace menu {
namespace floatpump::menu {
class Menu_Controller {
public:
Menu_Controller(Menu *menu, LCD_I2C_Driver &driver): m_menu(menu), m_driver(driver) {};
class Menu_Controller {
public:
Menu_Controller(Menu *menu, LCD_I2C_Driver &driver) : m_menu(menu), m_driver(driver) {};
enum Event {Increase, Decrease, Push};
void execute() {
displayMenu(m_menu);
}
void pushEvent(Event ev) {
switch(ev) {
case Increase:
increase(m_menu); break;
case Decrease:
decrease(m_menu); break;
case Push:
keypress(m_menu); break;
}
}
private:
bool isEntry() {
}
void displayMenu(Menu *m) {
int page = m_current_index / 4;
int pageindex = m_current_index % 4;
for (int i = 0; i < 4; i++) {
m_driver.LCDSetCursor(0, i);
if (pageindex == i) {
m_driver.LCDSendChar(LCD_I2C_Driver::SpecialChars::RightArrow);
} else {
m_driver.LCDSendCString(" ");
}
m_driver.LCDSetCursor(1, i);
int entry_index = (page * 4) + i;
auto menutexts = m->getDisplayList();
if(entry_index < m->getAllEntriesNum()) {
std::string dspstring = menutexts[entry_index];
if (dspstring.length() > 19) {
dspstring = "-- ERR --";
} else {
dspstring.append((19 - dspstring.length()), ' ');
}
m_driver.LCDSendCString(const_cast<char *>(dspstring.c_str()));
} else {
m_driver.LCDSendCString(" ");
}
}
}
void keypress(Menu *m) {
//Enter submenu if entry is submenu
if (m->getSubmenu(m_current_index) != nullptr) {
m_menu = m->getSubmenu(m_current_index);
//Forward press action if entry is entry
} else if (m->getEntry(m_current_index) != nullptr) {
m->getEntry(m_current_index)->action_press();
} else if(m_menu->m_parent != nullptr) {
m_menu = m_menu->m_parent;
}
}
void increase(Menu *m) {
if(m_current_index < m->getAllEntriesNum() - 1) {
if(m->getEntry(m_current_index) != nullptr) {
if(m->getEntry(m_current_index)->isEntered()) {
m->getEntry(m_current_index)->action_increase();
} else {
m_current_index++;
}
} else {
m_current_index++;
}
}
}
void decrease(Menu *m) {
if(m_current_index > 0) {
if(m->getEntry(m_current_index) != nullptr) {
if(m->getEntry(m_current_index)->isEntered()) {
m->getEntry(m_current_index)->action_decrease();
} else {
m_current_index--;
}
} else {
m_current_index--;
}
}
}
private:
LCD_I2C_Driver &m_driver;
int m_current_index = 0;
Menu *m_menu;
//Possible User-Events that could be pushed to the controller
enum Event {
Increase, Decrease, Push
};
} // floatpump
//Execute Menu (call this in a single loop to update the screen)
void execute();
//Push an Event to the Menu_Controller
void pushEvent(Event ev);
private:
//Used to interact with the screen
void displayMenu(Menu *m);
void keypress(Menu *m);
void increase(Menu *m);
void decrease(Menu *m);
private:
LCD_I2C_Driver &m_driver;
int m_current_index = 0;
Menu *m_menu;
};
} // menu
#endif //FLOATPUMP_MENU_CONTROLLER_H

46
Middlewares/floatpump/Inc/Menu_Entry.h
View File

@ -8,43 +8,31 @@
#include <Menu_Entry_Type_Delegate.h>
namespace floatpump {
namespace menu {
namespace floatpump::menu {
class Menu_Entry {
public:
menu::Menu_Entry_Type_Delegate *m_type;
class Menu_Entry {
public:
Menu_Entry(Menu_Entry_Type_Delegate *type, std::string name) : m_type(type), m_name(name) {};
Menu_Entry(Menu_Entry_Type_Delegate *type, std::string name) : m_type(type), m_name(name) {};
std::string printLine() {
int spaces = 19 - (m_name.length() + m_type->toString().length());
std::string spacer;
spacer.append(spaces, ' ');
return m_name + spacer + m_type->toString();
}
void action_press() {
m_type->u_press();
}
//Retreive string for putting on display
std::string printLine();
void action_increase() {
m_type->u_increase(1);
}
void action_press();
void action_decrease() {
m_type->u_decrease(1);
}
void action_increase();
bool isEntered() {
return m_type->isEntered();
}
void action_decrease();
private:
std::string m_name;
};
//Check if currently entered
bool isEntered();
} // floatpump
} // menu
private:
std::string m_name;
menu::Menu_Entry_Type_Delegate *m_type; //Saves type of this menu entry
};
}
#endif //FLOATPUMP_MENU_ENTRY_H

42
Middlewares/floatpump/Inc/Menu_Entry_Type_Checkable.h
View File

@ -7,44 +7,28 @@
#include "Menu_Entry_Type_Delegate.h"
namespace floatpump {
namespace menu {
namespace floatpump::menu {
class Menu_Entry_Type_Checkable : public Menu_Entry_Type_Delegate {
public:
Menu_Entry_Type_Checkable(bool mState) {
m_state = new bool(mState);
}
class Menu_Entry_Type_Checkable : public Menu_Entry_Type_Delegate {
public:
explicit Menu_Entry_Type_Checkable(bool mState);
std::string toString() override {
return std::string((*m_state) ? "ON " : "OFF");
}
std::string toString() override;
void u_press() override {
*m_state = !(*m_state);
}
void u_press() override;
void u_increase(uint16_t steps) override {
void u_increase(uint16_t steps) override;
}
void u_decrease(uint16_t steps) override;
void u_decrease(uint16_t steps) override {
bool isEntered() override;
}
void linkConfig(bool *link);
bool isEntered() override {
return false;
}
private:
bool *m_state;
};
void linkConfig(bool *link) {
m_state = link;
}
private:
bool *m_state;
};
} // floatpump
} // menu
#endif //FLOATPUMP_MENU_ENTRY_TYPE_CHECKABLE_H

6
Middlewares/floatpump/Inc/Menu_Entry_Type_Numeric.h
View File

@ -13,6 +13,8 @@ namespace floatpump {
class Menu_Entry_Type_Numeric : public Menu_Entry_Type_Delegate {
public:
explicit Menu_Entry_Type_Numeric(uint16_t mValue);
std::string toString() override;
void u_press() override;
@ -23,8 +25,10 @@ namespace floatpump {
bool isEntered() override;
void linkConfig(uint16_t *link);
private:
uint16_t m_value = 0;
uint16_t *m_value = 0;
bool m_entered = false;
};

30
Middlewares/floatpump/Inc/Menu_Entry_Type_Percent.h
View File

@ -7,30 +7,30 @@
#include "Menu_Entry_Type_Delegate.h"
namespace floatpump {
namespace menu {
namespace floatpump::menu {
class Menu_Entry_Type_Percent : public floatpump::menu::Menu_Entry_Type_Delegate{
public:
Menu_Entry_Type_Percent(uint8_t val) : m_value(val) {};
class Menu_Entry_Type_Percent : public floatpump::menu::Menu_Entry_Type_Delegate {
public:
explicit Menu_Entry_Type_Percent(uint8_t val);;
std::string toString() override;
std::string toString() override;
void u_press() override;
void u_press() override;
void u_increase(uint16_t steps) override;
void u_increase(uint16_t steps) override;
void u_decrease(uint16_t steps) override;
void u_decrease(uint16_t steps) override;
bool isEntered() override;
bool isEntered() override;
private:
uint8_t m_value = 0;
bool m_entered = false;
};
void linkConfig(uint8_t *link);
private:
uint8_t *m_value = nullptr;
bool m_entered = false;
};
} //menu
} //floatpump

61
Middlewares/floatpump/Inc/Menu_Entry_Type_Time.cpp
View File

@ -1,61 +0,0 @@
//
// Created by robtor on 05.01.23.
//
#include "Menu_Entry_Type_Time.h"
namespace floatpump {
namespace menu {
std::string Menu_Entry_Type_Time::toString() {
switch(m_entered) {
case 0:
return std::string(" " + std::to_string(m_hour) + ":" + std::to_string(m_minute) + ":" + std::to_string(m_second)); break;
case 1:
return std::string("#" + std::to_string(m_hour) + ":" + std::to_string(m_minute) + ":" + std::to_string(m_second)); break;
case 2:
return std::string(" " + std::to_string(m_hour) + "#" + std::to_string(m_minute) + ":" + std::to_string(m_second)); break;
case 3:
return std::string(" " + std::to_string(m_hour) + ":" + std::to_string(m_minute) + "#" + std::to_string(m_second)); break;
}
return std::string();
}
void Menu_Entry_Type_Time::u_press() {
if(m_entered < 3) {
m_entered++;
} else {
m_entered = 0;
}
}
void Menu_Entry_Type_Time::u_increase(uint16_t steps) {
switch(m_entered) {
case 1:
(m_hour < 23) ? m_hour++ : m_hour = 0; break;
case 2:
(m_minute < 59) ? m_minute++ : m_minute = 0; break;
case 3:
(m_second < 59) ? m_second++ : m_second = 0; break;
}
}
void Menu_Entry_Type_Time::u_decrease(uint16_t steps) {
switch(m_entered) {
case 1:
(m_hour > 0) ? m_hour-- : m_hour = 23; break;
case 2:
(m_minute > 0) ? m_minute-- : m_minute = 59; break;
case 3:
(m_second > 0) ? m_second-- : m_second = 59; break;
}
}
bool Menu_Entry_Type_Time::isEntered() {
if(m_entered > 0) {
return true;
} else {
return false;
}
}
} // floatpump
} // menu

12
Middlewares/floatpump/Inc/Menu_Entry_Type_Time.h
View File

@ -7,12 +7,11 @@
#include "Menu_Entry_Type_Delegate.h"
namespace floatpump {
namespace menu {
namespace floatpump::menu {
class Menu_Entry_Type_Time : public Menu_Entry_Type_Delegate{
public:
Menu_Entry_Type_Time(uint8_t hour, uint8_t minute, uint8_t second) : m_hour(hour), m_minute(minute), m_second(second) {};
Menu_Entry_Type_Time(uint8_t hour, uint8_t minute, uint8_t second);;
std::string toString() override;
@ -24,12 +23,13 @@ namespace floatpump {
bool isEntered() override;
void linkConfig(uint8_t *c_hour, uint8_t *c_minute, uint8_t *c_second);
private:
uint8_t m_entered = 0;
uint8_t m_hour, m_minute, m_second;
uint8_t *m_hour, *m_minute, *m_second = nullptr;
};
} // floatpump
} // menu
} // menu
#endif //FLOATPUMP_MENU_ENTRY_TYPE_TIME_H

67
Middlewares/floatpump/Src/Menu.cpp
View File

@ -4,7 +4,66 @@
#include "Menu.h"
namespace floatpump {
namespace menu {
} // floatpump
} // menu
namespace floatpump::menu {
void Menu::addEntry(const Menu_Entry &entry) {
m_entries.push_back(entry);
}
void Menu::addSubmenu(Menu *submenu) {
//Always set this menu as parent of created submenus within this menu
submenu->m_parent = this;
m_submenus.push_back(submenu);
}
std::string Menu::printLine() const {
return m_name;
}
std::vector<std::string> Menu::getDisplayList() {
std::vector<std::string> list;
list.reserve(m_submenus.size() + m_entries.size());
//Append al Submenus
for (auto &m_submenu: m_submenus) {
list.push_back(m_submenu->printLine());
}
//Append all Entries
for (auto &m_entry: m_entries) {
list.push_back(m_entry.printLine());
}
//Append Go-Back-Entry if we are within a submenu
if (m_parent != nullptr) {
list.emplace_back("<- Go Back");
}
return list;
}
unsigned int Menu::getAllEntriesNum() const {
//Add 1 to this if we have a parent menu -> makes Go-Back-Entry selectable
return (m_entries.size() + m_submenus.size()) + ((m_parent != nullptr) ? 1 : 0);
}
Menu *Menu::getSubmenu(int index) {
if (index >= 0 && index < m_submenus.size()) {
return m_submenus[index];
} else {
return nullptr;
}
}
Menu_Entry *Menu::getEntry(int index) {
if (index >= m_submenus.size() && index < m_entries.size() + m_submenus.size()) {
return &m_entries[index - m_submenus.size()];
} else {
return nullptr;
}
}
Menu *Menu::getParent() {
return m_parent;
}
}

107
Middlewares/floatpump/Src/Menu_Controller.cpp
View File

@ -4,7 +4,108 @@
#include "Menu_Controller.h"
namespace floatpump {
namespace menu {
} // floatpump
namespace floatpump::menu {
void Menu_Controller::execute() {
displayMenu(m_menu);
}
void Menu_Controller::pushEvent(Menu_Controller::Event ev) {
switch (ev) {
case Increase:
increase(m_menu);
break;
case Decrease:
decrease(m_menu);
break;
case Push:
keypress(m_menu);
break;
}
}
void Menu_Controller::displayMenu(Menu *m) {
int page = m_current_index / 4; //Currently displayed page
int pageindex = m_current_index % 4; //Current line on page
for (int i = 0; i < 4; i++) {
m_driver.LCDSetCursor(0, i);
//Set arrow marker for currently selected line
if (pageindex == i) {
m_driver.LCDSendChar(LCD_I2C_Driver::SpecialChars::RightArrow);
} else {
m_driver.LCDSendCString((char *) " ");
}
m_driver.LCDSetCursor(1, i);
//Map screen line numbers to index
int entry_index = (page * 4) + i;
//Retreive menu contents
auto menutexts = m->getDisplayList();
if (entry_index < m->getAllEntriesNum()) {
std::string dspstring = menutexts[entry_index];
if (dspstring.length() > 19) {
dspstring = "-- ERR --";
} else {
dspstring.append((19 - dspstring.length()), ' ');
}
m_driver.LCDSendCString(const_cast<char *>(dspstring.c_str()));
} else {
//Clear rest of screen if not fully containing a menu
m_driver.LCDSendCString((char *) " ");
}
}
}
void Menu_Controller::keypress(Menu *m) {
//Enter submenu if entry is submenu
if (m->getSubmenu(m_current_index) != nullptr) {
//Replace containing menu with submenu
m_menu = m->getSubmenu(m_current_index);
m_current_index = 0;
//Forward press action if entry is entry
} else if (m->getEntry(m_current_index) != nullptr) {
m->getEntry(m_current_index)->action_press();
//If we are on the Go-Back-Entry and have a parent: replace menu with parent menu
} else if (m_menu->getParent() != nullptr) {
m_menu = m_menu->getParent();
m_current_index = 0;
}
}
void Menu_Controller::increase(Menu *m) {
if (m_current_index < m->getAllEntriesNum() - 1) {
if (m->getEntry(m_current_index) != nullptr) {
//Forward increase action to entry if we have an entered entry
if (m->getEntry(m_current_index)->isEntered()) {
m->getEntry(m_current_index)->action_increase();
} else {
m_current_index++;
}
} else {
m_current_index++;
}
}
}
void Menu_Controller::decrease(Menu *m) {
if (m_current_index > 0) {
if (m->getEntry(m_current_index) != nullptr) {
//Forward decrease action to entry if we have an entered entry
if (m->getEntry(m_current_index)->isEntered()) {
m->getEntry(m_current_index)->action_decrease();
} else {
m_current_index--;
}
} else {
m_current_index--;
}
}
}
} // menu

24
Middlewares/floatpump/Src/Menu_Entry.cpp
View File

@ -6,5 +6,29 @@
namespace floatpump {
namespace menu {
std::string Menu_Entry::printLine() {
//We have 19 characters width for displaying the entry -> fill with spaces
int spaces = 19 - (m_name.length() + m_type->toString().length());
std::string spacer;
spacer.append(spaces, ' ');
return m_name + spacer + m_type->toString();
}
void Menu_Entry::action_press() {
m_type->u_press();
}
void Menu_Entry::action_increase() {
m_type->u_increase(1);
}
void Menu_Entry::action_decrease() {
m_type->u_decrease(1);
}
bool Menu_Entry::isEntered() {
return m_type->isEntered();
}
} // floatpump
} // menu

27
Middlewares/floatpump/Src/Menu_Entry_Type_Checkable.cpp
View File

@ -8,5 +8,32 @@ namespace floatpump {
namespace menu {
Menu_Entry_Type_Checkable::Menu_Entry_Type_Checkable(bool mState) {
m_state = new bool(mState);
}
std::string Menu_Entry_Type_Checkable::toString() {
return {(*m_state) ? "ON " : "OFF"};
}
void Menu_Entry_Type_Checkable::u_press() {
*m_state = !(*m_state);
}
void Menu_Entry_Type_Checkable::u_increase(uint16_t steps) {
}
void Menu_Entry_Type_Checkable::u_decrease(uint16_t steps) {
}
bool Menu_Entry_Type_Checkable::isEntered() {
return false;
}
void Menu_Entry_Type_Checkable::linkConfig(bool *link) {
m_state = link;
}
} // floatpump
} // menu

15
Middlewares/floatpump/Src/Menu_Entry_Type_Numeric.cpp
View File

@ -6,11 +6,16 @@
namespace floatpump {
namespace menu {
Menu_Entry_Type_Numeric::Menu_Entry_Type_Numeric(uint16_t mValue) {
m_value = new uint16_t(mValue);
}
std::string Menu_Entry_Type_Numeric::toString() {
if(m_entered) {
return "# " + std::to_string(m_value);
if (m_entered) {
return "# " + std::to_string(*m_value);
} else {
return " " + std::to_string(m_value);
return " " + std::to_string(*m_value);
}
}
@ -29,5 +34,9 @@ namespace floatpump {
bool Menu_Entry_Type_Numeric::isEntered() {
return m_entered;
}
void Menu_Entry_Type_Numeric::linkConfig(uint16_t *link) {
m_value = link;
}
} // floatpump
} // menu

22
Middlewares/floatpump/Src/Menu_Entry_Type_Percent.cpp
View File

@ -5,10 +5,10 @@
#include "Menu_Entry_Type_Percent.h"
std::string floatpump::menu::Menu_Entry_Type_Percent::toString() {
if(m_entered) {
return std::string("# " + std::to_string(m_value) + "%");
if (m_entered) {
return std::string("# " + std::to_string(*m_value) + "%");
} else {
return std::string(" " + std::to_string(m_value) + "%");
return std::string(" " + std::to_string(*m_value) + "%");
}
}
@ -17,16 +17,24 @@ void floatpump::menu::Menu_Entry_Type_Percent::u_press() {
}
void floatpump::menu::Menu_Entry_Type_Percent::u_increase(uint16_t steps) {
if(m_value < 100)
m_value++;
if (*m_value < 100)
(*m_value)++;
}
void floatpump::menu::Menu_Entry_Type_Percent::u_decrease(uint16_t steps) {
if(m_value > 0) {
m_value--;
if (*m_value > 0) {
(*m_value)--;
}
}
bool floatpump::menu::Menu_Entry_Type_Percent::isEntered() {
return m_entered;
}
floatpump::menu::Menu_Entry_Type_Percent::Menu_Entry_Type_Percent(uint8_t val) {
m_value = new uint8_t(val);
}
void floatpump::menu::Menu_Entry_Type_Percent::linkConfig(uint8_t *link) {
m_value = link;
}

73
Middlewares/floatpump/Src/Menu_Entry_Type_Time.cpp Normal file
View File

@ -0,0 +1,73 @@
//
// Created by robtor on 05.01.23.
//
#include "Menu_Entry_Type_Time.h"
namespace floatpump {
namespace menu {
std::string Menu_Entry_Type_Time::toString() {
switch(m_entered) {
case 0:
return std::string(" " + std::to_string(*m_hour) + ":" + std::to_string(*m_minute) + ":" + std::to_string(*m_second)); break;
case 1:
return std::string("#" + std::to_string(*m_hour) + ":" + std::to_string(*m_minute) + ":" + std::to_string(*m_second)); break;
case 2:
return std::string(" " + std::to_string(*m_hour) + "#" + std::to_string(*m_minute) + ":" + std::to_string(*m_second)); break;
case 3:
return std::string(" " + std::to_string(*m_hour) + ":" + std::to_string(*m_minute) + "#" + std::to_string(*m_second)); break;
}
return std::string();
}
void Menu_Entry_Type_Time::u_press() {
if(m_entered < 3) {
m_entered++;
} else {
m_entered = 0;
}
}
void Menu_Entry_Type_Time::u_increase(uint16_t steps) {
switch(m_entered) {
case 1:
(*m_hour < 23) ? (*m_hour)++ : *m_hour = 0; break;
case 2:
(*m_minute < 59) ? (*m_minute)++ : *m_minute = 0; break;
case 3:
(*m_second < 59) ? (*m_second)++ : *m_second = 0; break;
}
}
void Menu_Entry_Type_Time::u_decrease(uint16_t steps) {
switch(m_entered) {
case 1:
(*m_hour > 0) ? (*m_hour)-- : *m_hour = 23; break;
case 2:
(*m_minute > 0) ? (*m_minute)-- : *m_minute = 59; break;
case 3:
(*m_second > 0) ? (*m_second)-- : *m_second = 59; break;
}
}
bool Menu_Entry_Type_Time::isEntered() {
if(m_entered > 0) {
return true;
} else {
return false;
}
}
Menu_Entry_Type_Time::Menu_Entry_Type_Time(uint8_t hour, uint8_t minute, uint8_t second) {
m_hour = new uint8_t (hour);
m_minute = new uint8_t (minute);
m_second = new uint8_t (second);
}
void Menu_Entry_Type_Time::linkConfig(uint8_t *c_hour, uint8_t *c_minute, uint8_t *c_second) {
m_hour = c_hour;
m_minute = c_minute;
m_second = c_second;
}
} // floatpump
} // menu