758 lines
25 KiB
C++
758 lines
25 KiB
C++
#include <Arduino.h>
|
|
#include "../DallasTemperature/DallasTemperature.h"
|
|
#include "display.h"
|
|
|
|
Display::Display(
|
|
uint8_t cs,
|
|
uint8_t btnNext,
|
|
uint8_t btnPrev,
|
|
uint8_t btnSelect,
|
|
uint8_t btnCancel,
|
|
uint8_t bgLED,
|
|
parameters *params,
|
|
values *vals,
|
|
modbusParameters *modbus,
|
|
PSensor *sensor,
|
|
valveStates *vStates)
|
|
: U8G2_ST7920_128X64_F_HW_SPI(U8G2_R0, cs)
|
|
, btnNext(btnNext)
|
|
, btnPrev(btnPrev)
|
|
, btnSelect(btnSelect)
|
|
, btnCancel(btnCancel)
|
|
, bgLed(bgLED)
|
|
, _params(params)
|
|
, _vals(vals)
|
|
, _modbusParams(modbus)
|
|
, _pSensor(sensor)
|
|
, _vStates(vStates)
|
|
{
|
|
// Bei 2 MHz funtionierte im Test das Display schon nicht mehr
|
|
// setBusClock(1000000);
|
|
}
|
|
|
|
void Display::process()
|
|
{
|
|
switch (_event()) {
|
|
case _BACK_TO_HOME_SCREEN:
|
|
_selection = 0;
|
|
_home();
|
|
return;
|
|
case U8X8_MSG_GPIO_MENU_NEXT:
|
|
_nextEvent();
|
|
_select();
|
|
break;
|
|
case U8X8_MSG_GPIO_MENU_PREV:
|
|
_prevEvent();
|
|
_select();
|
|
break;
|
|
case U8X8_MSG_GPIO_MENU_SELECT:
|
|
if (_selection) {
|
|
parameters params;
|
|
modbusParameters modbus;
|
|
switch (_selection) {
|
|
case _MENU_MAIN:
|
|
_saveCursorPosForLevel(MenuLevel_1);
|
|
switch (_prevCursor) {
|
|
case _POS_TEMPERATURE_MENU:
|
|
_select(_MENU_TEMPERATURE);
|
|
break;
|
|
case _POS_PRESSURE_MENU:
|
|
_select(_MENU_PRESSURE);
|
|
break;
|
|
case _POS_SYSTEM:
|
|
_restrictInputValue(0, 255);
|
|
_select(_VERIFY_ADMIN);
|
|
break;
|
|
case _POS_RESET:
|
|
_select(_SELECTION_RESET);
|
|
break;
|
|
}
|
|
break;
|
|
case _MENU_TEMPERATURE:
|
|
_saveCursorPosForLevel(MenuLevel_2);
|
|
switch (_prevCursor) {
|
|
case _POS_TEMPERATURE_ENABLED:
|
|
_cursor = _params->tEn;
|
|
_select(_SELECTION_TEMPERATURE_ENABLED);
|
|
break;
|
|
case _POS_TEMPERATURE_SETPOINT:
|
|
_val = _params->ts1;
|
|
_restrictInputValue(_MIN_TEMP_SETPOINT, _MAX_TEMP_SETPOINT, Precision_2);
|
|
_select(_SELECTION_TEMPERATURE_SETPOINT);
|
|
break;
|
|
case _POS_TEMPERATURE_HYSTERESIS:
|
|
_val = _params->th1;
|
|
_restrictInputValue(_MIN_TEMP_HYSTERESIS, _MAX_TEMP_HYSTERESIS, Precision_2);
|
|
_select(_SELECTION_TEMPERATURE_HYSTERESIS);
|
|
break;
|
|
}
|
|
break;
|
|
case _MENU_PRESSURE:
|
|
_saveCursorPosForLevel(MenuLevel_2);
|
|
switch (_prevCursor) {
|
|
case _POS_PRESSURE_ENABLE_INCREASE:
|
|
_cursor = _params->pInc;
|
|
_select(_SELECTION_PRESSURE_ENABLE_INCREASE);
|
|
break;
|
|
case _POS_PRESSURE_ENABLE_DECREASE:
|
|
_cursor = _params->pDec;
|
|
_select(_SELECTION_PRESSURE_ENABLE_DECREASE);
|
|
break;
|
|
case _POS_PRESSURE_SETPOINT:
|
|
_val = _params->ps;
|
|
_restrictInputValue(_MIN_P_SETPOINT, _MAX_P_SETPOINT, Precision_2);
|
|
_select(_SELECTION_PRESSURE_SETPOINT);
|
|
break;
|
|
case _POS_PRESSURE_HYSTERESIS:
|
|
_val = _params->ph;
|
|
_restrictInputValue(_MIN_P_HYSTERESIS, _MAX_P_HYSTERESIS, Precision_2);
|
|
_select(_SELECTION_PRESSURE_HYSTERESIS);
|
|
break;
|
|
}
|
|
break;
|
|
case _MENU_SYSTEM:
|
|
_saveCursorPosForLevel(MenuLevel_2);
|
|
switch (_prevCursor) {
|
|
case _POS_MODBUS_MENU:
|
|
_select(_MENU_SETTINGS_MODBUS);
|
|
break;
|
|
case _POS_P_SENSOR_SELECTION:
|
|
_cursor = (*_pSensor) - 1;
|
|
_select(_SELECTION_P_SENSOR);
|
|
break;
|
|
}
|
|
break;
|
|
case _MENU_SETTINGS_MODBUS:
|
|
_saveCursorPosForLevel(MenuLevel_3);
|
|
switch (_prevCursor) {
|
|
case _POS_MODBUS_ADDRESS:
|
|
_val = _modbusParams->address;
|
|
_restrictInputValue(_MODBUS_ADDR_MIN, _MODBUS_ADDR_MAX);
|
|
_select(_SELECTION_MODBUS_ADDRESS);
|
|
break;
|
|
case _POS_MODBUS_BAUDRATE:
|
|
_baudrateCursorPos();
|
|
_select(_SELECTION_MODBUS_BAUDRATE);
|
|
break;
|
|
case _POS_MODBUS_DELAY:
|
|
_val = _modbusParams->delay;
|
|
_restrictInputValue(_MODBUS_DELAY_MIN, _MODBUS_DELAY_MAX, Precision_1);
|
|
_select(_SELECTION_MODBUS_DELAY);
|
|
break;
|
|
}
|
|
break;
|
|
case _SELECTION_TEMPERATURE_ENABLED:
|
|
params.tEn = _cursor;
|
|
setParams(params);
|
|
_select(_MENU_TEMPERATURE, true);
|
|
break;
|
|
case _SELECTION_TEMPERATURE_SETPOINT:
|
|
// Serial.print("\n_val : "); Serial.println((float) _val);
|
|
// Serial.print("_val / 100: "); Serial.println(((float) _val) / 100);
|
|
params.ts1 = _val;
|
|
setParams(params);
|
|
_select(_MENU_TEMPERATURE, true);
|
|
break;
|
|
case _SELECTION_TEMPERATURE_HYSTERESIS:
|
|
params.th1 = _val;
|
|
setParams(params);
|
|
_select(_MENU_TEMPERATURE, true);
|
|
break;
|
|
case _SELECTION_PRESSURE_ENABLE_INCREASE:
|
|
params.pInc = _cursor;
|
|
setParams(params);
|
|
_select(_MENU_PRESSURE, true);
|
|
break;
|
|
case _SELECTION_PRESSURE_ENABLE_DECREASE:
|
|
params.pDec = _cursor;
|
|
setParams(params);
|
|
_select(_MENU_PRESSURE, true);
|
|
break;
|
|
case _SELECTION_PRESSURE_SETPOINT:
|
|
params.ps = _val;
|
|
setParams(params);
|
|
_select(_MENU_PRESSURE, true);
|
|
break;
|
|
case _SELECTION_PRESSURE_HYSTERESIS:
|
|
params.ph = _val;
|
|
setParams(params);
|
|
_select(_MENU_PRESSURE, true);
|
|
break;
|
|
case _SELECTION_MODBUS_BAUDRATE:
|
|
_setModbusBaudrate();
|
|
_select(_MENU_SETTINGS_MODBUS, true);
|
|
break;
|
|
case _SELECTION_MODBUS_ADDRESS:
|
|
modbus.address = _val;
|
|
setModbusParams(modbus);
|
|
_select(_MENU_SETTINGS_MODBUS, true);
|
|
break;
|
|
case _SELECTION_MODBUS_DELAY:
|
|
modbus.delay = _val;
|
|
setModbusParams(modbus);
|
|
_select(_MENU_SETTINGS_MODBUS, true);
|
|
break;
|
|
case _SELECTION_P_SENSOR:
|
|
switch (_cursor) {
|
|
case _POS_P_SMC_1_5V_0_5BAR:
|
|
setPSensor(SMC_1_5V_0_5BAR);
|
|
break;
|
|
case _POS_P_GEMS_0_5V_0_6BAR:
|
|
setPSensor(GEMS_0_5V_0_6BAR);
|
|
break;
|
|
}
|
|
_restoreCursor();
|
|
_select(_MENU_SYSTEM);
|
|
break;
|
|
case _VERIFY_ADMIN:
|
|
if (_val == _ADMIN_CODE) {
|
|
_select(_MENU_SYSTEM);
|
|
} else {
|
|
_restoreCursor();
|
|
_select(_MENU_MAIN);
|
|
}
|
|
_val = 0;
|
|
break;
|
|
case _SELECTION_RESET:
|
|
if (_cursor == 1) {
|
|
reset();
|
|
} else {
|
|
_restoreCursor();
|
|
_select(_MENU_MAIN);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
case U8X8_MSG_GPIO_MENU_HOME:
|
|
if (_selection) {
|
|
_val = 0;
|
|
if (!_restoreCursor()) {
|
|
_home();
|
|
return;
|
|
}
|
|
switch (_selection) {
|
|
case _MENU_MAIN:
|
|
_selection = 0;
|
|
_home();
|
|
return;
|
|
case _SELECTION_TEMPERATURE_ENABLED:
|
|
case _SELECTION_TEMPERATURE_SETPOINT:
|
|
case _SELECTION_TEMPERATURE_HYSTERESIS:
|
|
_select(_MENU_TEMPERATURE);
|
|
break;
|
|
case _SELECTION_PRESSURE_ENABLE_INCREASE:
|
|
case _SELECTION_PRESSURE_ENABLE_DECREASE:
|
|
case _SELECTION_PRESSURE_SETPOINT:
|
|
case _SELECTION_PRESSURE_HYSTERESIS:
|
|
_select(_MENU_PRESSURE);
|
|
break;
|
|
case _MENU_SETTINGS_MODBUS:
|
|
case _SELECTION_P_SENSOR:
|
|
_select(_MENU_SYSTEM);
|
|
break;
|
|
case _SELECTION_MODBUS_ADDRESS:
|
|
case _SELECTION_MODBUS_BAUDRATE:
|
|
case _SELECTION_MODBUS_DELAY:
|
|
_select(_MENU_SETTINGS_MODBUS);
|
|
break;
|
|
default:
|
|
_select(_MENU_MAIN);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
if (millis() - _prevT > 250) {
|
|
_prevT = millis();
|
|
if (!_selection) {
|
|
_home();
|
|
}
|
|
}
|
|
}
|
|
|
|
void Display::_select(const uint8_t selection, const bool restoreCursor=false)
|
|
{
|
|
if (restoreCursor)
|
|
_restoreCursor();
|
|
_selection = selection;
|
|
_select();
|
|
}
|
|
|
|
void Display::_select()
|
|
{
|
|
setFont(_SEL_FONT);
|
|
setFontRefHeightAll();
|
|
_inputValueActive = false;
|
|
_stepSize = 1;
|
|
_printtime("select screen");
|
|
switch (_selection) {
|
|
case _MENU_MAIN:
|
|
_menu_depth = 0;
|
|
sprintf(_text, "Hauptmenü (%s)", _VERSION_STRING);
|
|
_selCnt = my_UserInterfaceSelectionList(&u8g2, _text, _cursor, "Temperatur\nDruck\nSystem\nReset");
|
|
break;
|
|
case _MENU_TEMPERATURE:
|
|
_menu_depth = 1;
|
|
_selCnt = my_UserInterfaceSelectionList(&u8g2, "Temperatur", _cursor, "Kühlung de/aktivieren\nSollwert\nHysterese");
|
|
break;
|
|
case _SELECTION_TEMPERATURE_ENABLED:
|
|
_menu_depth = 2;
|
|
_selCnt = my_UserInterfaceMessage(&u8g2, "Kühlung", nullptr, "aktivieren", " nein \n ja ", _cursor);
|
|
break;
|
|
case _SELECTION_TEMPERATURE_SETPOINT:
|
|
_menu_depth = 2;
|
|
_inputValue(5, "Temperatur\nSollwert", "__float__");
|
|
break;
|
|
case _SELECTION_TEMPERATURE_HYSTERESIS:
|
|
_menu_depth = 2;
|
|
_inputValue(5, "Temperatur\nHysterese", "__float__");
|
|
break;
|
|
case _MENU_PRESSURE:
|
|
_menu_depth = 1;
|
|
_selCnt = my_UserInterfaceSelectionList(&u8g2, "Druck", _cursor, "Drucksteigerung\nDruckabfall\nSollwert\nHysterese");
|
|
break;
|
|
case _SELECTION_PRESSURE_ENABLE_INCREASE:
|
|
_menu_depth = 2;
|
|
_selCnt = my_UserInterfaceMessage(&u8g2, "Drucksteigerung", nullptr, "aktivieren", " nein \n ja ", _cursor);
|
|
break;
|
|
case _SELECTION_PRESSURE_ENABLE_DECREASE:
|
|
_menu_depth = 2;
|
|
_selCnt = my_UserInterfaceMessage(&u8g2, "Druckabfall", nullptr, "aktivieren", " nein \n ja ", _cursor);
|
|
break;
|
|
case _SELECTION_PRESSURE_SETPOINT:
|
|
_menu_depth = 2;
|
|
_inputValue(5, "Druck\nSollwert", "__float__");
|
|
break;
|
|
case _SELECTION_PRESSURE_HYSTERESIS:
|
|
_menu_depth = 2;
|
|
_inputValue(5, "Druck\nHysterese", "__float__");
|
|
break;
|
|
case _VERIFY_ADMIN:
|
|
_menu_depth = 1;
|
|
_inputValueActive = true;
|
|
sprintf(_text, "%d", _val);
|
|
my_UserInterfaceInputValueString(&u8g2, "Systemeinstellungen\nBerechtigung\nnachweisen:", nullptr, _text);
|
|
break;
|
|
case _MENU_SYSTEM:
|
|
_menu_depth = 1;
|
|
_selCnt = my_UserInterfaceSelectionList(&u8g2, "System", _cursor, "Modbus\nDrucksensor");
|
|
break;
|
|
case _MENU_SETTINGS_MODBUS:
|
|
_menu_depth = 2;
|
|
_selCnt = my_UserInterfaceSelectionList(&u8g2, "Modbus", _cursor, "Adresse\nBaudrate\nAntwort-Delay");
|
|
break;
|
|
case _SELECTION_MODBUS_BAUDRATE:
|
|
_menu_depth = 3;
|
|
_selCnt = my_UserInterfaceSelectionList(&u8g2, "Baudrate", _cursor, "300\n1200\n2400\n4800\n9600\n19200\n38400\n57600\n115200");
|
|
break;
|
|
case _SELECTION_MODBUS_ADDRESS:
|
|
_menu_depth = 3;
|
|
sprintf(_text, "Dezimal: %d", _val);
|
|
_inputValue(1, "Modbus Adresse");
|
|
break;
|
|
case _SELECTION_MODBUS_DELAY:
|
|
_menu_depth = 3;
|
|
sprintf(_text, "%d.%.d", _val / 10, _val % 10);
|
|
_inputValue(1, "Modbus\nAntwort-Verzögerung\nin Millisekunden");
|
|
break;
|
|
case _SELECTION_P_SENSOR:
|
|
_menu_depth = 2;
|
|
_selCnt = my_UserInterfaceSelectionList(&u8g2, "Drucksensor", _cursor, "SMC: 1-5V,0-5 bar\nGems: 0-5V,0-6 bar");
|
|
break;
|
|
case _SELECTION_RESET:
|
|
_menu_depth = 1;
|
|
_selCnt = my_UserInterfaceMessage(&u8g2, "Controller neustarten", "--------------------", "Wirklich neustarten?", " nein \n ja ", _cursor);
|
|
break;
|
|
default:
|
|
_menu_depth = 0;
|
|
}
|
|
}
|
|
|
|
void Display::_home()
|
|
{
|
|
// Das Display hat eine Auflösung von 128 x 64 Pixel
|
|
// Mit der Schriftart u8g2_font_ncenB10_te stellt \xb0 das °-Zeichen dar
|
|
int ts1a = _params->ts1 / 100;
|
|
int ts1b = _params->ts1 % 100;
|
|
int th1a = _params->th1 / 100;
|
|
int th1b = _params->th1 % 100;
|
|
int psa = _params->ps / 100;
|
|
int psb = _params->ps % 100;
|
|
int pha = _params->ph / 100;
|
|
int phb = _params->ph % 100;
|
|
bool cEn = _params->cEn;
|
|
bool tEn = (!cEn) ? false : _params->tEn;
|
|
bool pInc = (!cEn) ? false : _params->pInc;
|
|
bool pDec = (!cEn) ? false : _params->pDec;
|
|
bool pEn = pInc || pDec;
|
|
uint8_t pState = (_vStates->pInc) ? 1 : (_vStates->pDec) ? 2 : 0;
|
|
bool tState = _vStates->t1;
|
|
// %u in sprintf() geht nur bis uint16_t
|
|
String baudStr(_modbusParams->baudrate);
|
|
_printtime("homescreen");
|
|
firstPage();
|
|
do {
|
|
setFont(u8g2_font_fub20_tf);
|
|
if (_vals->t1 == _SENSOR_FAULT)
|
|
sprintf(_text, "--.-- \xb0\C");
|
|
else
|
|
sprintf(_text, "%d.%.2d \xb0\C", _vals->t1 / 100, _vals->t1 % 100);
|
|
drawStr(0, 27, _text);
|
|
if (_vals->p == _SENSOR_FAULT)
|
|
sprintf(_text, "--.-- bar");
|
|
else
|
|
sprintf(_text, "%d.%.2d bar", _vals->p / 100, _vals->p % 100);
|
|
drawStr(0, 57, _text);
|
|
//drawHLine(0, 57, 128);
|
|
setFont(u8g2_font_micro_tr);
|
|
//setFont(u8g2_font_5x7_tr);
|
|
sprintf(_text, "%d.%.2d+-%d.%.2d Regelung %saktiv", ts1a, ts1b, th1a, th1b, (tEn) ? "": "in");
|
|
drawStr(0, 5, _text);
|
|
sprintf(_text, "%d.%.2d+-%d.%.2d P+ %s P- %s", psa, psb, pha, phb, (pInc) ? "ein": "aus", (pDec) ? "ein": "aus");
|
|
drawStr(0, 35, _text);
|
|
// sprintf(_text, "Modbus Adr. %u, Baudr. %u", _modbusParams->address, _modbusParams->baudrate);
|
|
sprintf(_text, "Modbus Adr. %u, Baudr. %s", _modbusParams->address, baudStr.c_str());
|
|
drawStr(0, 64, _text);
|
|
if (cEn) {
|
|
if (tEn) {
|
|
if (tState) {
|
|
setFont(u8g2_font_open_iconic_arrow_2x_t);
|
|
drawStr(112, 25, "\x58"); // Kreislaufsymbol
|
|
}
|
|
} else {
|
|
setFont(u8g2_font_open_iconic_check_2x_t);
|
|
drawStr(112, 25, "\x42"); // X in schwarzem Kreis
|
|
}
|
|
if (!pEn) {
|
|
setFont(u8g2_font_open_iconic_check_2x_t);
|
|
drawStr(112, 55, "\x42"); // X in schwarzem Kreis
|
|
} else if (pState == 1) {
|
|
setFont(u8g2_font_open_iconic_arrow_2x_t);
|
|
drawStr(112, 55, "\x4b"); // Pfeil rauf
|
|
} else if (pState == 2) {
|
|
setFont(u8g2_font_open_iconic_arrow_2x_t);
|
|
drawStr(112, 55, "\x48"); // Pfeil runter
|
|
}
|
|
} else {
|
|
setFont(u8g2_font_open_iconic_check_2x_t);
|
|
// drawStr(112, 25, "\x42"); // X in schwarzem Kreis
|
|
// drawStr(112, 55, "\x42"); // X in schwarzem Kreis
|
|
drawStr(112, 22, "\x42"); // X in schwarzem Kreis
|
|
drawStr(112, 58, "\x42"); // X in schwarzem Kreis
|
|
setFont(u8g2_font_open_iconic_embedded_2x_t);
|
|
drawStr(113, 40, "\x4e"); // Power-Symbol
|
|
// drawLine(0, 0, 128, 64);
|
|
// drawLine(128, 0, 0, 64);
|
|
}
|
|
|
|
} while (nextPage());
|
|
}
|
|
|
|
void Display::init()
|
|
{
|
|
pinMode(bgLed, OUTPUT);
|
|
digitalWrite(bgLed, true);
|
|
begin(btnSelect, btnNext, btnPrev, U8X8_PIN_NONE, U8X8_PIN_NONE, btnCancel);
|
|
}
|
|
|
|
void Display::modbusProblem()
|
|
{
|
|
firstPage();
|
|
do {
|
|
setFont(_STD_FONT);
|
|
uint8_t y = _FIRS_LINE_Y;
|
|
drawStr(0, y, "Problem:");
|
|
y += _STD_LINEHEIGHT;
|
|
drawStr(0, y, "Fehler Modbus");
|
|
} while (nextPage());
|
|
}
|
|
|
|
void Display::oneWireDevicesDetected(uint8_t count)
|
|
{
|
|
setFont(_SEL_FONT);
|
|
setFontRefHeightAll();
|
|
sprintf(_text, "%u", count);
|
|
userInterfaceMessage("OneWire-Sensoren", "Erfolgreich erkannt:", _text, " OK ");
|
|
}
|
|
|
|
void Display::tooMuchOneWireDevicesDetected(uint8_t actual, uint8_t max)
|
|
{
|
|
setFont(_SEL_FONT);
|
|
setFontRefHeightAll();
|
|
sprintf(_text, "%u (max: %u)", actual, max);
|
|
userInterfaceMessage("Fehler OneWire", "Zu viele Sensoren:", _text, " OK ");
|
|
}
|
|
|
|
void Display::noOneWireDevicesDetected()
|
|
{
|
|
setFont(_SEL_FONT);
|
|
setFontRefHeightAll();
|
|
userInterfaceMessage("Fehler OneWire", "Keine Sensoren", "erkannt", " OK ");
|
|
}
|
|
|
|
void Display::greeting()
|
|
{
|
|
firstPage();
|
|
do {
|
|
setFont(_STD_FONT);
|
|
uint8_t y = _FIRS_LINE_Y;
|
|
drawStr(0, y, "Dreher");
|
|
y += _STD_LINEHEIGHT;
|
|
drawStr(0, y, "Brauanlagen");
|
|
} while (nextPage());
|
|
}
|
|
|
|
void Display::bgLight(uint8_t value)
|
|
{
|
|
_bgLightAnalog = value;
|
|
_bgLightBool = (value > 0) ? true : false;
|
|
analogWrite(bgLed, value);
|
|
}
|
|
|
|
void Display::bgLight(bool state)
|
|
{
|
|
_bgLightAnalog = (state) ? 255 : 0;
|
|
_bgLightBool = state;
|
|
digitalWrite(bgLed, state);
|
|
}
|
|
|
|
bool Display::bgLightIncrease(uint8_t step)
|
|
{
|
|
_bgLightBool = true;
|
|
if (_bgLightAnalog == 255) {
|
|
return true;
|
|
}
|
|
int val = (int) _bgLightAnalog;
|
|
if (val + step >= 255) {
|
|
_bgLightAnalog = 255;
|
|
digitalWrite(bgLed, true);
|
|
return true;
|
|
} else {
|
|
_bgLightAnalog += step;
|
|
analogWrite(bgLed, _bgLightAnalog);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool Display::bgLightDecrease(uint8_t step)
|
|
{
|
|
if (_bgLightAnalog == 0) {
|
|
_bgLightBool = false;
|
|
return true;
|
|
}
|
|
int val = (int) _bgLightAnalog;
|
|
if (val - step <= 0) {
|
|
_bgLightAnalog = 0;
|
|
_bgLightBool = false;
|
|
digitalWrite(bgLed, false);
|
|
return true;
|
|
} else {
|
|
_bgLightBool = true;
|
|
_bgLightAnalog -= step;
|
|
analogWrite(bgLed, _bgLightAnalog);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
uint8_t Display::bgLightAnalog()
|
|
{
|
|
return _bgLightAnalog;
|
|
}
|
|
|
|
bool Display::bgLightState()
|
|
{
|
|
return _bgLightBool;
|
|
}
|
|
|
|
void Display::_baudrateCursorPos()
|
|
{
|
|
switch (_modbusParams->baudrate) {
|
|
case 300: _cursor = _POS_BAUDRATE_300; break;
|
|
case 1200: _cursor = _POS_BAUDRATE_1200; break;
|
|
case 2400: _cursor = _POS_BAUDRATE_2400; break;
|
|
case 4800: _cursor = _POS_BAUDRATE_4800; break;
|
|
case 19200: _cursor = _POS_BAUDRATE_19200; break;
|
|
case 38400: _cursor = _POS_BAUDRATE_38400; break;
|
|
case 57600: _cursor = _POS_BAUDRATE_57600; break;
|
|
case 115200: _cursor = _POS_BAUDRATE_115200; break;
|
|
default: _cursor = _POS_BAUDRATE_9600;
|
|
}
|
|
}
|
|
|
|
void Display::_setModbusBaudrate()
|
|
{
|
|
modbusParameters params;
|
|
switch (_cursor) {
|
|
case _POS_BAUDRATE_300: params.baudrate = 300; break;
|
|
case _POS_BAUDRATE_1200: params.baudrate = 1200; break;
|
|
case _POS_BAUDRATE_2400: params.baudrate = 2400; break;
|
|
case _POS_BAUDRATE_4800: params.baudrate = 4800; break;
|
|
case _POS_BAUDRATE_19200: params.baudrate = 19200; break;
|
|
case _POS_BAUDRATE_38400: params.baudrate = 38400; break;
|
|
case _POS_BAUDRATE_57600: params.baudrate = 57600; break;
|
|
case _POS_BAUDRATE_115200: params.baudrate = 115200; break;
|
|
default: params.baudrate = 9600;
|
|
}
|
|
setModbusParams(params);
|
|
}
|
|
|
|
uint8_t Display::_event()
|
|
{
|
|
uint8_t event = getMenuEvent();
|
|
if (event)
|
|
return event;
|
|
bool next = !digitalRead(btnNext);
|
|
bool prev = !digitalRead(btnPrev);
|
|
bool cancel = !digitalRead(btnCancel);
|
|
if (next || prev || cancel) {
|
|
if (millis() - _checkFastStepTime > _BEGIN_FAST_STEPS_DELAY) {
|
|
if (millis() - _lastFastStep > _FAST_STEP_MS) {
|
|
_lastFastStep = millis();
|
|
if (next)
|
|
event = U8X8_MSG_GPIO_MENU_NEXT;
|
|
else if (prev)
|
|
event = U8X8_MSG_GPIO_MENU_PREV;
|
|
else if (cancel)
|
|
event = _BACK_TO_HOME_SCREEN;
|
|
if (millis() - _checkFastStepTime > _BEGIN_BIG_STEPS_DELAY)
|
|
_enableBigSteps = true;
|
|
}
|
|
}
|
|
} else {
|
|
_checkFastStepTime = millis();
|
|
_enableBigSteps = false;
|
|
}
|
|
return event;
|
|
}
|
|
|
|
void Display::_nextEvent()
|
|
{
|
|
if (_selection) {
|
|
if (_inputValueActive) {
|
|
if (_val > _valMin) {
|
|
int step = (_enableBigSteps) ? _BIG_STEP * _stepSize : _stepSize;
|
|
if (_val - step > _valMin)
|
|
_val -= step;
|
|
else
|
|
_val = _valMin;
|
|
}
|
|
} else {
|
|
_cursor++;
|
|
if (_cursor >= _selCnt) {
|
|
_cursor = 0;
|
|
}
|
|
}
|
|
} else {
|
|
_selection = _MENU_MAIN;
|
|
}
|
|
}
|
|
|
|
void Display::_prevEvent()
|
|
{
|
|
if (_selection) {
|
|
if (_inputValueActive) {
|
|
if (_val < _valMax) {
|
|
int step = (_enableBigSteps) ? _BIG_STEP * _stepSize : _stepSize;
|
|
if (_val < step)
|
|
_val = step;
|
|
else if (_val + step < _valMax)
|
|
_val += step;
|
|
else
|
|
_val = _valMax;
|
|
}
|
|
} else {
|
|
if (_cursor == 0) {
|
|
_cursor = _selCnt;
|
|
}
|
|
_cursor--;
|
|
}
|
|
} else {
|
|
_selection = _MENU_MAIN;
|
|
}
|
|
}
|
|
|
|
void Display::_saveCursorPosForLevel(MenuLevel level)
|
|
{
|
|
switch (level) {
|
|
case MenuLevel_1:
|
|
_cur_l1 = _cursor;
|
|
break;
|
|
case MenuLevel_2:
|
|
_cur_l2 = _cursor;
|
|
break;
|
|
case MenuLevel_3:
|
|
_cur_l3 = _cursor;
|
|
break;
|
|
}
|
|
_prevCursor = _cursor;
|
|
_cursor = 0;
|
|
}
|
|
|
|
void Display::_restrictInputValue(int min, int max, Precision p=Precision_0)
|
|
{
|
|
char s1[10];
|
|
char s2[10];
|
|
switch (p) {
|
|
case Precision_1:
|
|
if (min % 10 == 0)
|
|
sprintf(s1, "%d", min / 10);
|
|
else
|
|
sprintf(s1, "%d.%.1d", min / 10, min % 10);
|
|
if (max % 10 == 0)
|
|
sprintf(s2, "%d", max / 10);
|
|
else
|
|
sprintf(s2, "%d.%.1d", max / 10, max % 10);
|
|
break;
|
|
case Precision_2:
|
|
if (min % 100 == 0)
|
|
sprintf(s1, "%d", min / 100);
|
|
else
|
|
sprintf(s1, "%d.%.2d", min / 100, min % 100);
|
|
if (max % 100 == 0)
|
|
sprintf(s2, "%d", max / 100);
|
|
else
|
|
sprintf(s2, "%d.%.2d", max / 100, max % 100);
|
|
break;
|
|
default:
|
|
sprintf(s1, "%d", min);
|
|
sprintf(s2, "%d", max);
|
|
}
|
|
_valMin = min;
|
|
_valMax = max;
|
|
sprintf(_text2, "min: %s, max: %s", s1, s2);
|
|
}
|
|
|
|
void Display::_inputValue(const uint8_t stepSize, const char *title, const char *val=nullptr, const char *text=nullptr)
|
|
{
|
|
if (!val) {
|
|
val = _text;
|
|
} else if (val == "__float__") {
|
|
sprintf(_text, "%d.%.2d", _val / 100, _val % 100);
|
|
val = _text;
|
|
}
|
|
if (!text)
|
|
text = _text2;
|
|
_inputValueActive = true;
|
|
_stepSize = stepSize;
|
|
my_UserInterfaceInputValueString(&u8g2, title, text, val);
|
|
}
|
|
|
|
uint8_t Display::_restoreCursor()
|
|
{
|
|
switch (_menu_depth) {
|
|
case 1:
|
|
_cursor = _cur_l1;
|
|
break;
|
|
case 2:
|
|
_cursor = _cur_l2;
|
|
break;
|
|
case 3:
|
|
_cursor = _cur_l3;
|
|
break;
|
|
default:
|
|
_cursor = 0;
|
|
_selection = 0;
|
|
}
|
|
return _menu_depth;
|
|
}
|