981 lines
45 KiB
C++
981 lines
45 KiB
C++
#include "display.hpp"
|
|
|
|
CUDDisplay::CUDDisplay(cud_display_conf_t *conf) : ESPMegaDisplay(conf->uart, conf->communication_baudrate, conf->ota_baudrate, conf->tx, conf->rx)
|
|
{
|
|
this->conf = conf;
|
|
// Initialize Light Group and Fan Group
|
|
this->light_group = {
|
|
.element_id = {LCD_DASHBOARD_ELEMENT_LIGHT_1, LCD_DASHBOARD_ELEMENT_LIGHT_2, LCD_DASHBOARD_ELEMENT_LIGHT_3, LCD_DASHBOARD_ELEMENT_LIGHT_4},
|
|
.element_name = {LCD_DASHBOARD_ELEMENT_NAME_LIGHT_1, LCD_DASHBOARD_ELEMENT_NAME_LIGHT_2, LCD_DASHBOARD_ELEMENT_NAME_LIGHT_3, LCD_DASHBOARD_ELEMENT_NAME_LIGHT_4},
|
|
.picture_on = {LCD_DASHBOARD_PIC_LIGHT_1_ON, LCD_DASHBOARD_PIC_LIGHT_2_ON, LCD_DASHBOARD_PIC_LIGHT_3_ON, LCD_DASHBOARD_PIC_LIGHT_4_ON},
|
|
.picture_on_pressed = {LCD_DASHBOARD_PIC_LIGHT_1_ON_PRESSED, LCD_DASHBOARD_PIC_LIGHT_2_ON_PRESSED, LCD_DASHBOARD_PIC_LIGHT_3_ON_PRESSED, LCD_DASHBOARD_PIC_LIGHT_4_ON_PRESSED},
|
|
.picture_off = {LCD_DASHBOARD_PIC_LIGHT_1_OFF, LCD_DASHBOARD_PIC_LIGHT_2_OFF, LCD_DASHBOARD_PIC_LIGHT_3_OFF, LCD_DASHBOARD_PIC_LIGHT_4_OFF},
|
|
.picture_off_pressed = {LCD_DASHBOARD_PIC_LIGHT_1_OFF_PRESSED, LCD_DASHBOARD_PIC_LIGHT_2_OFF_PRESSED, LCD_DASHBOARD_PIC_LIGHT_3_OFF_PRESSED, LCD_DASHBOARD_PIC_LIGHT_4_OFF_PRESSED}};
|
|
this->fan_group = {
|
|
.element_id = {LCD_DASHBOARD_ELEMENT_FAN_1, LCD_DASHBOARD_ELEMENT_FAN_2, LCD_DASHBOARD_ELEMENT_FAN_3},
|
|
.element_name = {LCD_DASHBOARD_ELEMENT_NAME_FAN_1, LCD_DASHBOARD_ELEMENT_NAME_FAN_2, LCD_DASHBOARD_ELEMENT_NAME_FAN_3},
|
|
.picture_on = {LCD_DASHBOARD_PIC_FAN_1_ON, LCD_DASHBOARD_PIC_FAN_2_ON, LCD_DASHBOARD_PIC_FAN_3_ON},
|
|
.picture_on_pressed = {LCD_DASHBOARD_PIC_FAN_1_ON_PRESSED, LCD_DASHBOARD_PIC_FAN_2_ON_PRESSED, LCD_DASHBOARD_PIC_FAN_3_ON_PRESSED},
|
|
.picture_off = {LCD_DASHBOARD_PIC_FAN_1_OFF, LCD_DASHBOARD_PIC_FAN_2_OFF, LCD_DASHBOARD_PIC_FAN_3_OFF},
|
|
.picture_off_pressed = {LCD_DASHBOARD_PIC_FAN_1_OFF_PRESSED, LCD_DASHBOARD_PIC_FAN_2_OFF_PRESSED, LCD_DASHBOARD_PIC_FAN_3_OFF_PRESSED}};
|
|
}
|
|
|
|
CUDDisplay::~CUDDisplay()
|
|
{
|
|
if (ac_lock_topic != nullptr)
|
|
{
|
|
free(ac_lock_topic);
|
|
}
|
|
if (ac_lock_set_topic != nullptr)
|
|
{
|
|
free(ac_lock_set_topic);
|
|
}
|
|
if (ac_lock_request_topic != nullptr)
|
|
{
|
|
free(ac_lock_request_topic);
|
|
}
|
|
if (ac_temp_upper_bound_topic != nullptr)
|
|
{
|
|
free(ac_temp_upper_bound_topic);
|
|
}
|
|
if (ac_temp_upper_bound_set_topic != nullptr)
|
|
{
|
|
free(ac_temp_upper_bound_set_topic);
|
|
}
|
|
if (ac_temp_upper_bound_request_topic != nullptr)
|
|
{
|
|
free(ac_temp_upper_bound_request_topic);
|
|
}
|
|
if (ac_temp_lower_bound_topic != nullptr)
|
|
{
|
|
free(ac_temp_lower_bound_topic);
|
|
}
|
|
if (ac_temp_lower_bound_set_topic != nullptr)
|
|
{
|
|
free(ac_temp_lower_bound_set_topic);
|
|
}
|
|
if (ac_temp_lower_bound_request_topic != nullptr)
|
|
{
|
|
free(ac_temp_lower_bound_request_topic);
|
|
}
|
|
}
|
|
|
|
void CUDDisplay::begin(cud_display_cards_t cards)
|
|
{
|
|
// Save Cards
|
|
this->cards = cards;
|
|
// Register callbacks
|
|
ESP_LOGV("CUD Display", "Registering callbacks");
|
|
auto binded_input_callback = std::bind(&CUDDisplay::handle_input_change, this, std::placeholders::_1, std::placeholders::_2);
|
|
auto binded_output_callback = std::bind(&CUDDisplay::handle_output_change, this, std::placeholders::_1, std::placeholders::_2);
|
|
auto binded_aqi_callback = std::bind(&CUDDisplay::handle_aqi_change, this, std::placeholders::_1);
|
|
auto binded_payload_callback = std::bind(&CUDDisplay::handle_payload, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3);
|
|
auto binded_touch_callback = std::bind(&CUDDisplay::handle_touch, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3);
|
|
auto binded_ac_callback = std::bind(&CUDDisplay::handle_ac_change, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3);
|
|
auto binded_ac_sensor_callback = std::bind(&CUDDisplay::handle_ac_sensor, this, std::placeholders::_1, std::placeholders::_2);
|
|
auto binded_handle_mqtt_connected = std::bind(&CUDDisplay::handle_mqtt_connected, this);
|
|
ESP_LOGV("CUD Display", "Registering Input Card Callbacks");
|
|
this->cards.inputCard->registerCallback(binded_input_callback);
|
|
ESP_LOGV("CUD Display", "Registering Output Card Callbacks");
|
|
this->cards.outputCard->registerChangeCallback(binded_output_callback);
|
|
ESP_LOGV("CUD Display", "Registering AQI Callbacks");
|
|
this->conf->aqi->registerCallback(binded_aqi_callback);
|
|
ESP_LOGV("CUD Display", "Registering MQTT Connected Callbacks");
|
|
this->cards.iot->registerSubscribeCallback(binded_handle_mqtt_connected);
|
|
ESP_LOGV("CUD Display", "Registering Display Payload Callbacks");
|
|
this->registerPayloadCallback(binded_payload_callback);
|
|
ESP_LOGV("CUD Display", "Registering Display Touch Callbacks");
|
|
this->registerTouchCallback(binded_touch_callback);
|
|
ESP_LOGV("CUD Display", "Registering AC Callbacks");
|
|
this->cards.ac->registerChangeCallback(binded_ac_callback);
|
|
ESP_LOGV("CUD Display", "Registering AC Sensor Callbacks");
|
|
this->cards.ac->registerSensorCallback(binded_ac_sensor_callback);
|
|
// Initialize Smart Variables
|
|
ESP_LOGV("CUD Display", "Initializing Smart Variables");
|
|
// Get Base Topic
|
|
char *base_topic = this->cards.iot->getMqttConfig()->base_topic;
|
|
uint8_t base_topic_length = strlen(base_topic);
|
|
// Smart Variables
|
|
// AC Lock
|
|
this->ac_lock.begin(10);
|
|
this->ac_lock.bindFRAM(this->cards.fram, AC_LOCK_FRAM_ADDR);
|
|
this->ac_lock.setValueAutoSave(true);
|
|
ac_lock_topic = (char *)malloc(base_topic_length + strlen(AC_LOCK_RELATIVE_TOPIC) + 3);
|
|
sprintf(ac_lock_topic, "%s%s", base_topic, AC_LOCK_RELATIVE_TOPIC);
|
|
this->ac_lock.enableIoT(this->cards.iot, ac_lock_topic);
|
|
ac_lock_set_topic = (char *)malloc(base_topic_length + strlen(AC_LOCK_RELATIVE_TOPIC) + sizeof("/set") + 3);
|
|
sprintf(ac_lock_set_topic, "%s%s/set", base_topic, AC_LOCK_RELATIVE_TOPIC);
|
|
this->ac_lock.enableSetValue(ac_lock_set_topic);
|
|
ac_lock_request_topic = (char *)malloc(base_topic_length + strlen(AC_LOCK_RELATIVE_TOPIC) + sizeof("/request") + 3);
|
|
sprintf(ac_lock_request_topic, "%s%s/request", base_topic, AC_LOCK_RELATIVE_TOPIC);
|
|
this->ac_lock.enableValueRequest(ac_lock_request_topic);
|
|
auto binded_ac_lock_callback = std::bind(&CUDDisplay::handle_lock_change, this, std::placeholders::_1);
|
|
this->ac_lock.registerCallback(binded_ac_lock_callback);
|
|
// AC Temp Lower Bound
|
|
this->ac_temp_lower_bound.begin(6);
|
|
this->ac_temp_lower_bound.bindFRAM(this->cards.fram, AC_DISPLAY_TEMP_LOWER_BOUND_ADDR);
|
|
this->ac_temp_lower_bound.setValueAutoSave(true);
|
|
ac_temp_lower_bound_topic = (char *)malloc(base_topic_length + strlen(AC_TEMP_LOWER_BOUND_RELATIVE_TOPIC) + 3);
|
|
sprintf(ac_temp_lower_bound_topic, "%s%s", base_topic, AC_TEMP_LOWER_BOUND_RELATIVE_TOPIC);
|
|
this->ac_temp_lower_bound.enableIoT(this->cards.iot, ac_temp_lower_bound_topic);
|
|
ac_temp_lower_bound_set_topic = (char *)malloc(base_topic_length + strlen(AC_TEMP_LOWER_BOUND_RELATIVE_TOPIC) + sizeof("/set") + 3);
|
|
sprintf(ac_temp_lower_bound_set_topic, "%s%s/set", base_topic, AC_TEMP_LOWER_BOUND_RELATIVE_TOPIC);
|
|
this->ac_temp_lower_bound.enableSetValue(ac_temp_lower_bound_set_topic);
|
|
ac_temp_lower_bound_request_topic = (char *)malloc(base_topic_length + strlen(AC_TEMP_LOWER_BOUND_RELATIVE_TOPIC) + sizeof("/request") + 3);
|
|
sprintf(ac_temp_lower_bound_request_topic, "%s%s/request", base_topic, AC_TEMP_LOWER_BOUND_RELATIVE_TOPIC);
|
|
this->ac_temp_lower_bound.enableValueRequest(ac_temp_lower_bound_request_topic);
|
|
auto binded_ac_temp_lower_bound_callback = std::bind(&CUDDisplay::handle_bound_change, this, std::placeholders::_1);
|
|
this->ac_temp_lower_bound.registerCallback(binded_ac_temp_lower_bound_callback);
|
|
// AC Temp Upper Bound
|
|
this->ac_temp_upper_bound.begin(6);
|
|
this->ac_temp_upper_bound.bindFRAM(this->cards.fram, AC_DISPLAY_TEMP_UPPER_BOUND_ADDR);
|
|
this->ac_temp_upper_bound.setValueAutoSave(true);
|
|
ac_temp_upper_bound_topic = (char *)malloc(base_topic_length + strlen(AC_TEMP_UPPER_BOUND_RELATIVE_TOPIC) + 3);
|
|
sprintf(ac_temp_upper_bound_topic, "%s%s", base_topic, AC_TEMP_UPPER_BOUND_RELATIVE_TOPIC);
|
|
this->ac_temp_upper_bound.enableIoT(this->cards.iot, ac_temp_upper_bound_topic);
|
|
ac_temp_upper_bound_set_topic = (char *)malloc(base_topic_length + strlen(AC_TEMP_UPPER_BOUND_RELATIVE_TOPIC) + sizeof("/set") + 3);
|
|
sprintf(ac_temp_upper_bound_set_topic, "%s%s/set", base_topic, AC_TEMP_UPPER_BOUND_RELATIVE_TOPIC);
|
|
this->ac_temp_upper_bound.enableSetValue(ac_temp_upper_bound_set_topic);
|
|
ac_temp_upper_bound_request_topic = (char *)malloc(base_topic_length + strlen(AC_TEMP_UPPER_BOUND_RELATIVE_TOPIC) + sizeof("/request") + 3);
|
|
sprintf(ac_temp_upper_bound_request_topic, "%s%s/request", base_topic, AC_TEMP_UPPER_BOUND_RELATIVE_TOPIC);
|
|
this->ac_temp_upper_bound.enableValueRequest(ac_temp_upper_bound_request_topic);
|
|
auto binded_ac_temp_upper_bound_callback = std::bind(&CUDDisplay::handle_bound_change, this, std::placeholders::_1);
|
|
this->ac_temp_upper_bound.registerCallback(binded_ac_temp_upper_bound_callback);
|
|
|
|
// Check Bound Validity
|
|
// Lower Bound must be less than Upper Bound
|
|
// Lower Bound can't be less than AC_MIN_TEMP
|
|
// Upper Bound can't be more than AC_MAX_TEMP
|
|
// If any of the bound is invalid, set all to default
|
|
if (this->ac_temp_lower_bound.getIntValue() < AC_MIN_TEMP || this->ac_temp_upper_bound.getIntValue() > AC_MAX_TEMP || this->ac_temp_lower_bound.getIntValue() >= this->ac_temp_upper_bound.getIntValue())
|
|
{
|
|
ESP_LOGW("CUD Display", "Temperature Bounds are invalid, setting to default");
|
|
this->ac_temp_lower_bound.setIntValue(DEFAULT_TEMP_LOWER_BOUND);
|
|
this->ac_temp_upper_bound.setIntValue(DEFAULT_TEMP_UPPER_BOUND);
|
|
}
|
|
|
|
// Initialize the display
|
|
ESP_LOGV("CUD Display", "Initializing display");
|
|
this->display_init();
|
|
}
|
|
|
|
void CUDDisplay::loop()
|
|
{
|
|
ESPMegaDisplay::loop();
|
|
// Check if the AC button press is pending
|
|
if (this->ac_button_press_pending)
|
|
{
|
|
// Check if the delay has passed
|
|
if (millis() - this->last_ac_button_press > AC_TEMP_PRESS_DELAY)
|
|
{
|
|
ESP_LOGV("CUD Display", "Sending pending temperature");
|
|
// Send the pending temperature
|
|
this->cards.ac->setTemperature(this->pending_temperature);
|
|
// Reset the pending flag
|
|
this->ac_button_press_pending = false;
|
|
}
|
|
}
|
|
// Check if MQTT is connected
|
|
static uint32_t last_mqtt_connected_check = 0;
|
|
if (last_mqtt_connected_check == 0)
|
|
{
|
|
last_mqtt_connected_check = millis() + 15000; // Wait 15 seconds before checking
|
|
}
|
|
static bool first_disconnect = true;
|
|
if (millis() - last_mqtt_connected_check > 3000)
|
|
{
|
|
ESP_LOGD("CUD Display", "Checking MQTT Connection, Connection is %s", this->cards.iot->mqttConnected() ? "true" : "false");
|
|
if (!this->cards.iot->mqttConnected())
|
|
{
|
|
this->standalone = true;
|
|
if (first_disconnect)
|
|
{
|
|
// When MQTT is disconnected, enter standalone mode
|
|
// In standalone mode, socket contactor is turned on
|
|
// A/C lock is lifted
|
|
// A/C temperature range limits are lifted
|
|
this->refresh_display_ac();
|
|
this->cards.outputCard->setState(this->conf->socket_contactor_pin, true);
|
|
first_disconnect = false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
standalone = false;
|
|
if (first_disconnect == false)
|
|
{
|
|
// When MQTT is connected, exit standalone mode
|
|
// In standalone mode, socket contactor is turned off
|
|
// A/C lock is set
|
|
// A/C temperature range limits are set
|
|
first_disconnect = true;
|
|
// Rebound the temperature
|
|
if (this->cards.ac->getTemperature() < this->get_ac_temp_lower_bound())
|
|
{
|
|
this->cards.ac->setTemperature(this->get_ac_temp_lower_bound());
|
|
}
|
|
else if (this->cards.ac->getTemperature() > this->get_ac_temp_upper_bound())
|
|
{
|
|
this->cards.ac->setTemperature(this->get_ac_temp_upper_bound());
|
|
}
|
|
this->refresh_display_ac();
|
|
}
|
|
}
|
|
last_mqtt_connected_check = millis();
|
|
}
|
|
}
|
|
|
|
void CUDDisplay::display_init()
|
|
{
|
|
// Perform a reset on the display
|
|
ESP_LOGV("CUD Display", "Resetting display");
|
|
this->reset();
|
|
vTaskDelay(1000 / portTICK_PERIOD_MS);
|
|
// Set the display to the main screen
|
|
ESP_LOGV("CUD Display", "Setting display to main screen");
|
|
this->jumpToPage(LCD_PAGE_ID_DASHBOARD);
|
|
// Send the initial states to the display
|
|
ESP_LOGV("CUD Display", "Sending initial states to display");
|
|
this->refresh_display();
|
|
}
|
|
|
|
bool CUDDisplay::get_lights_state()
|
|
{
|
|
for (int i = 0; i < 4; i++)
|
|
{
|
|
if (this->cards.outputCard->getState(this->conf->light_pins[i]))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool CUDDisplay::get_fans_state()
|
|
{
|
|
for (int i = 0; i < 3; i++)
|
|
{
|
|
if (this->cards.outputCard->getState(this->conf->fan_pins[i]))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void CUDDisplay::handle_input_change(uint8_t pin, bool state)
|
|
{
|
|
// This is not needed for now. We are only handling outputs
|
|
// Putting this here in case we need to handle inputs in the future
|
|
}
|
|
|
|
void CUDDisplay::handle_output_change(uint8_t pin, bool state)
|
|
{
|
|
// Check if it is a light or fan
|
|
// If it's a light, call set_display_light_state
|
|
// If it's a fan, call set_display_fan_state
|
|
// If it's the air purifier, call set_display_air_purifier_state
|
|
// If it's the mosquito zapper, call set_display_mosquito_zapper_state
|
|
|
|
// Check if it's the air purifier
|
|
if (pin == this->conf->air_purifier_pin)
|
|
{
|
|
this->set_display_air_purifier_state(state);
|
|
this->refresh_display_allsystem();
|
|
return;
|
|
}
|
|
|
|
// Check if it's the mosquito zapper
|
|
if (pin == this->conf->mosquito_zapper_pin)
|
|
{
|
|
this->set_display_mosquito_zapper_state(state);
|
|
this->refresh_display_allsystem();
|
|
return;
|
|
}
|
|
|
|
// Check if it's the socket contactor
|
|
if (pin == this->conf->socket_contactor_pin)
|
|
{
|
|
this->refresh_display_socket();
|
|
return;
|
|
}
|
|
|
|
// Loop through each to check if the pin is a light
|
|
for (int i = 0; i < 4; i++)
|
|
{
|
|
if (pin == this->conf->light_pins[i])
|
|
{
|
|
this->set_display_light_state(i, state);
|
|
this->set_display_light_all_state();
|
|
this->refresh_display_allsystem();
|
|
return;
|
|
}
|
|
}
|
|
// Loop through each to check if the pin is a fan
|
|
for (int i = 0; i < 3; i++)
|
|
{
|
|
if (pin == this->conf->fan_pins[i])
|
|
{
|
|
this->set_display_fan_state(i, state);
|
|
this->set_display_fan_all_state();
|
|
this->refresh_display_allsystem();
|
|
return;
|
|
}
|
|
}
|
|
// The pin is not the one that our display is handling, so we can ignore it
|
|
}
|
|
|
|
void CUDDisplay::handle_touch(uint8_t page_id, uint8_t element_id, uint8_t touch_type)
|
|
{
|
|
// Check if element_id is the light all button
|
|
if (element_id == LCD_DASHBOARD_ELEMENT_LIGHT_ALL)
|
|
{
|
|
// If it is, toggle all the lights
|
|
bool light_on = this->get_lights_state();
|
|
for (int i = 0; i < 4; i++)
|
|
{
|
|
this->cards.outputCard->setState(this->conf->light_pins[i], !light_on);
|
|
}
|
|
return;
|
|
}
|
|
// Check if element_id is the fan all button
|
|
else if (element_id == LCD_DASHBOARD_ELEMENT_FAN_ALL)
|
|
{
|
|
// If it is, toggle all the fans
|
|
bool fan_on = this->get_fans_state();
|
|
for (int i = 0; i < 3; i++)
|
|
{
|
|
this->cards.outputCard->setState(this->conf->fan_pins[i], !fan_on);
|
|
}
|
|
return;
|
|
}
|
|
// Check if element_id is the air purifier button
|
|
else if (element_id == LCD_DASHBOARD_ELEMENT_AIR_PURIFIER)
|
|
{
|
|
// If it is, toggle the air purifier
|
|
this->cards.outputCard->setState(this->conf->air_purifier_pin, !this->cards.outputCard->getState(this->conf->air_purifier_pin));
|
|
return;
|
|
}
|
|
// Check if element_id is the mosquito zapper button
|
|
else if (element_id == LCD_DASHBOARD_ELEMENT_MOSQUITO_ZAPPER)
|
|
{
|
|
// If it is, toggle the mosquito zapper
|
|
this->cards.outputCard->setState(this->conf->mosquito_zapper_pin, !this->cards.outputCard->getState(this->conf->mosquito_zapper_pin));
|
|
return;
|
|
}
|
|
// Check if element_id is a light button
|
|
for (int i = 0; i < 4; i++)
|
|
{
|
|
if (element_id == this->light_group.element_id[i])
|
|
{
|
|
// If it is, toggle the light
|
|
this->cards.outputCard->setState(this->conf->light_pins[i], !this->cards.outputCard->getState(this->conf->light_pins[i]));
|
|
return;
|
|
}
|
|
}
|
|
// Check if element_id is a fan button
|
|
for (int i = 0; i < 3; i++)
|
|
{
|
|
if (element_id == this->fan_group.element_id[i])
|
|
{
|
|
// If it is, toggle the fan
|
|
this->cards.outputCard->setState(this->conf->fan_pins[i], !this->cards.outputCard->getState(this->conf->fan_pins[i]));
|
|
return;
|
|
}
|
|
}
|
|
// Check if element_id is the AC state button
|
|
if (element_id == LCD_DASHBOARD_ELEMENT_AC_STATE)
|
|
{
|
|
// Is the control locked? If it is, we can ignore the touch
|
|
if (this->get_ac_lock())
|
|
return;
|
|
// Toggle the AC
|
|
// Is the AC on?
|
|
if (this->cards.ac->getMode() != 0)
|
|
{
|
|
// If it is, turn it off
|
|
this->cards.ac->setMode(0);
|
|
}
|
|
else
|
|
{
|
|
// If it is not, turn it on
|
|
this->cards.ac->setMode(previous_mode);
|
|
}
|
|
return;
|
|
}
|
|
// Check if element_id is the AC mode fan button
|
|
if (element_id == LCD_DASHBOARD_ELEMENT_AC_MODE_FAN)
|
|
{
|
|
// Is the control locked? If it is, we can ignore the touch
|
|
if (this->get_ac_lock())
|
|
return;
|
|
// Set the AC mode to fan
|
|
this->cards.ac->setMode(1);
|
|
return;
|
|
}
|
|
// Check if element_id is the AC mode cool button
|
|
if (element_id == LCD_DASHBOARD_ELEMENT_AC_MODE_COOL)
|
|
{
|
|
// Is the control locked? If it is, we can ignore the touch
|
|
if (this->get_ac_lock())
|
|
return;
|
|
// Set the AC mode to cool
|
|
this->cards.ac->setMode(2);
|
|
return;
|
|
}
|
|
// Check if element_id is the AC fan speed auto button
|
|
if (element_id == LCD_DASHBOARD_ELEMENT_AC_FAN_SPEED_AUTO)
|
|
{
|
|
// Is the control locked? If it is, we can ignore the touch
|
|
if (this->get_ac_lock())
|
|
return;
|
|
// Set the AC fan speed to auto
|
|
this->cards.ac->setFanSpeed(0);
|
|
return;
|
|
}
|
|
// Check if element_id is the AC fan speed low button
|
|
if (element_id == LCD_DASHBOARD_ELEMENT_AC_FAN_SPEED_LOW)
|
|
{
|
|
// Is the control locked? If it is, we can ignore the touch
|
|
if (this->get_ac_lock())
|
|
return;
|
|
// Set the AC fan speed to low
|
|
this->cards.ac->setFanSpeed(1);
|
|
return;
|
|
}
|
|
// Check if element_id is the AC fan speed medium button
|
|
if (element_id == LCD_DASHBOARD_ELEMENT_AC_FAN_SPEED_MEDIUM)
|
|
{
|
|
// Is the control locked? If it is, we can ignore the touch
|
|
if (this->get_ac_lock())
|
|
return;
|
|
// Set the AC fan speed to medium
|
|
this->cards.ac->setFanSpeed(2);
|
|
return;
|
|
}
|
|
// Check if element_id is the AC fan speed high button
|
|
if (element_id == LCD_DASHBOARD_ELEMENT_AC_FAN_SPEED_HIGH)
|
|
{
|
|
// Is the control locked? If it is, we can ignore the touch
|
|
if (this->get_ac_lock())
|
|
return;
|
|
// Set the AC fan speed to high
|
|
this->cards.ac->setFanSpeed(3);
|
|
return;
|
|
}
|
|
// Check if element_id is the AC temperature up button
|
|
if (element_id == LCD_DASHBOARD_ELEMENT_AC_TEMP_UP_BUTTON)
|
|
{
|
|
// Is the control locked? If it is, we can ignore the touch
|
|
if (this->get_ac_lock())
|
|
return;
|
|
uint8_t newTemp = this->cards.ac->getTemperature();
|
|
if (this->ac_button_press_pending)
|
|
{
|
|
// If the button press is pending, use the pending temperature as base
|
|
newTemp = this->pending_temperature;
|
|
}
|
|
newTemp++;
|
|
// Does the temperature exceed the upper bound?, if it does, bound it
|
|
if (newTemp > this->get_ac_temp_upper_bound())
|
|
{
|
|
newTemp = this->get_ac_temp_upper_bound();
|
|
}
|
|
ESP_LOGD("CUD Display", "New Temp: %d", newTemp);
|
|
// Increase the AC temperature
|
|
pending_temperature = newTemp;
|
|
ac_button_press_pending = true;
|
|
last_ac_button_press = millis();
|
|
// Send the new temperature to the Display
|
|
this->takeSerialMutex();
|
|
this->displayAdapter->printf("%s.txt=\"%d\"", LCD_DASHBOARD_ELEMENT_NAME_AC_TEMPERATURE, newTemp);
|
|
this->sendStopBytes();
|
|
this->giveSerialMutex();
|
|
return;
|
|
}
|
|
// Check if element_id is the AC temperature down button
|
|
if (element_id == LCD_DASHBOARD_ELEMENT_AC_TEMP_DOWN_BUTTON)
|
|
{
|
|
// Is the control locked? If it is, we can ignore the touch
|
|
if (this->get_ac_lock())
|
|
return;
|
|
uint8_t newTemp = this->cards.ac->getTemperature();
|
|
if (this->ac_button_press_pending)
|
|
{
|
|
// If the button press is pending, use the pending temperature as base
|
|
newTemp = this->pending_temperature;
|
|
}
|
|
newTemp--;
|
|
// Does the temperature exceed the lower bound?, if it does, bound it
|
|
ESP_LOGD("CUD Display", "Requested Temp: %d, Lower Bound: %d", newTemp, this->get_ac_temp_lower_bound());
|
|
if (newTemp < this->get_ac_temp_lower_bound())
|
|
{
|
|
newTemp = this->get_ac_temp_lower_bound();
|
|
}
|
|
ESP_LOGD("CUD Display", "New Temp: %d", newTemp);
|
|
// Decrease the AC temperature
|
|
pending_temperature = newTemp;
|
|
ac_button_press_pending = true;
|
|
last_ac_button_press = millis();
|
|
// Send the new temperature to the Display
|
|
this->takeSerialMutex();
|
|
this->displayAdapter->printf("%s.txt=\"%d\"", LCD_DASHBOARD_ELEMENT_NAME_AC_TEMPERATURE, newTemp);
|
|
this->sendStopBytes();
|
|
this->giveSerialMutex();
|
|
return;
|
|
}
|
|
if (element_id == LCD_DASHBOARD_ELEMENT_ALL_SYSTEM_TOGGLE)
|
|
{
|
|
this->system_toggle();
|
|
return;
|
|
}
|
|
// The element_id is not the one that our display is handling, so we can ignore it
|
|
}
|
|
|
|
void CUDDisplay::handle_lock_change(char *value)
|
|
{
|
|
this->refresh_display_ac();
|
|
}
|
|
|
|
void CUDDisplay::handle_bound_change(char *value)
|
|
{
|
|
// Bound is changed, check if the bounds are valid
|
|
// Lower Bound must be less than Upper Bound
|
|
// Lower Bound can't be less than AC_MIN_TEMP
|
|
// Upper Bound can't be more than AC_MAX_TEMP
|
|
// If any of the bound is invalid, set all to default
|
|
if (this->ac_temp_lower_bound.getIntValue() < AC_MIN_TEMP || this->ac_temp_lower_bound.getIntValue() >= this->ac_temp_upper_bound.getIntValue())
|
|
{
|
|
ESP_LOGV("CUD Display", "Invalid Lower Bound, Setting to Default");
|
|
this->ac_temp_lower_bound.setIntValue(DEFAULT_TEMP_LOWER_BOUND);
|
|
}
|
|
|
|
if (this->ac_temp_upper_bound.getIntValue() > AC_MAX_TEMP || this->ac_temp_lower_bound.getIntValue() >= this->ac_temp_upper_bound.getIntValue())
|
|
{
|
|
ESP_LOGV("CUD Display", "Invalid Upper Bound, Setting to Default");
|
|
this->ac_temp_upper_bound.setIntValue(DEFAULT_TEMP_UPPER_BOUND);
|
|
}
|
|
// Does the current temperature exceed the new upper bound?, if it does, bound it
|
|
if (this->cards.ac->getTemperature() > this->ac_temp_upper_bound.getIntValue())
|
|
{
|
|
this->cards.ac->setTemperature(this->ac_temp_upper_bound.getIntValue());
|
|
}
|
|
// Does the current temperature exceed the new lower bound?, if it does, bound it
|
|
if (this->cards.ac->getTemperature() < this->ac_temp_lower_bound.getIntValue())
|
|
{
|
|
this->cards.ac->setTemperature(this->ac_temp_lower_bound.getIntValue());
|
|
}
|
|
}
|
|
|
|
void CUDDisplay::handle_aqi_change(char *value)
|
|
{
|
|
ESP_LOGV("CUD Display", "AQI Changed: %s", value);
|
|
// Update the AQI value on the display
|
|
uint16_t aqi = atoi(value);
|
|
this->takeSerialMutex();
|
|
this->displayAdapter->printf("%s.txt=\"%03d\"", LCD_DASHBOARD_ELEMENT_NAME_AQI_TEXT, (int)aqi);
|
|
this->sendStopBytes();
|
|
// Update the AQI picture on the display
|
|
if (aqi <= 50)
|
|
{
|
|
this->displayAdapter->printf("%s.pic=%d", LCD_DASHBOARD_ELEMENT_NAME_AQI_PICTURE, LCD_DASHBOARD_PIC_AQI_GOOD);
|
|
this->sendStopBytes();
|
|
this->displayAdapter->printf("%s.pco=%d", LCD_DASHBOARD_ELEMENT_NAME_AQI_TEXT, LCD_DASHBOARD_COLOR_AQI_TEXT_GOOD);
|
|
this->sendStopBytes();
|
|
}
|
|
else if (aqi <= 100)
|
|
{
|
|
this->displayAdapter->printf("%s.pic=%d", LCD_DASHBOARD_ELEMENT_NAME_AQI_PICTURE, LCD_DASHBOARD_PIC_AQI_MODERATE);
|
|
this->sendStopBytes();
|
|
this->displayAdapter->printf("%s.pco=%d", LCD_DASHBOARD_ELEMENT_NAME_AQI_TEXT, LCD_DASHBOARD_COLOR_AQI_TEXT_MODERATE);
|
|
this->sendStopBytes();
|
|
}
|
|
else if (aqi <= 150)
|
|
{
|
|
this->displayAdapter->printf("%s.pic=%d", LCD_DASHBOARD_ELEMENT_NAME_AQI_PICTURE, LCD_DASHBOARD_PIC_AQI_UNHEALTHY_FOR_SENSITIVE_GROUPS);
|
|
this->sendStopBytes();
|
|
this->displayAdapter->printf("%s.pco=%d", LCD_DASHBOARD_ELEMENT_NAME_AQI_TEXT, LCD_DASHBOARD_COLOR_AQI_TEXT_UNHEALTHY_FOR_SENSITIVE_GROUPS);
|
|
this->sendStopBytes();
|
|
}
|
|
else if (aqi <= 200)
|
|
{
|
|
this->displayAdapter->printf("%s.pic=%d", LCD_DASHBOARD_ELEMENT_NAME_AQI_PICTURE, LCD_DASHBOARD_PIC_AQI_UNHEALTHY);
|
|
this->sendStopBytes();
|
|
this->displayAdapter->printf("%s.pco=%d", LCD_DASHBOARD_ELEMENT_NAME_AQI_TEXT, LCD_DASHBOARD_COLOR_AQI_TEXT_UNHEALTHY);
|
|
this->sendStopBytes();
|
|
}
|
|
else if (aqi <= 300)
|
|
{
|
|
this->displayAdapter->printf("%s.pic=%d", LCD_DASHBOARD_ELEMENT_NAME_AQI_PICTURE, LCD_DASHBOARD_PIC_AQI_VERY_UNHEALTHY);
|
|
this->sendStopBytes();
|
|
this->displayAdapter->printf("%s.pco=%d", LCD_DASHBOARD_ELEMENT_NAME_AQI_TEXT, LCD_DASHBOARD_COLOR_AQI_TEXT_VERY_UNHEALTHY);
|
|
this->sendStopBytes();
|
|
}
|
|
else
|
|
{
|
|
this->displayAdapter->printf("%s.pic=%d", LCD_DASHBOARD_ELEMENT_NAME_AQI_PICTURE, LCD_DASHBOARD_PIC_AQI_HAZARDOUS);
|
|
this->sendStopBytes();
|
|
this->displayAdapter->printf("%s.pco=%d", LCD_DASHBOARD_ELEMENT_NAME_AQI_TEXT, LCD_DASHBOARD_COLOR_AQI_TEXT_HAZARDOUS);
|
|
this->sendStopBytes();
|
|
}
|
|
this->giveSerialMutex();
|
|
}
|
|
|
|
/**
|
|
* @brief Handle the payload from the display that is not handled by the parent class
|
|
*
|
|
* @param type Payload type
|
|
* @param payload The payload itself
|
|
* @param length The length of the payload excluding the type
|
|
*/
|
|
void CUDDisplay::handle_payload(uint8_t type, uint8_t *payload, uint8_t length)
|
|
{
|
|
// If payload of type 0x92 is received
|
|
// Reset the display and reinitialize it
|
|
if (type == 0x92)
|
|
{
|
|
this->display_init();
|
|
}
|
|
}
|
|
|
|
void CUDDisplay::handle_ac_change(uint8_t mode, uint8_t fan_speed, uint8_t temperature)
|
|
{
|
|
// Set the previous mode to the current mode if the current mode is not 0
|
|
if (mode != 0)
|
|
{
|
|
previous_mode = mode;
|
|
}
|
|
this->refresh_display_ac();
|
|
this->refresh_display_allsystem();
|
|
}
|
|
|
|
void CUDDisplay::handle_ac_sensor(float temperature, float humidity)
|
|
{
|
|
// Is the temperature valid?
|
|
// A temperature of -999.0 means the sensor is not connected
|
|
ESP_LOGV("CUD Display", "AC Sensor Temperature: %f", temperature);
|
|
if (temperature == -999.0)
|
|
{
|
|
// If the temperature is not valid, Send NA to the display
|
|
this->takeSerialMutex();
|
|
this->displayAdapter->printf("%s.txt=\"NA\"", LCD_DASHBOARD_ELEMENT_NAME_ROOM_TEMPERATURE);
|
|
this->sendStopBytes();
|
|
this->giveSerialMutex();
|
|
return;
|
|
}
|
|
// Temperature is valid, send it to the display
|
|
this->takeSerialMutex();
|
|
this->displayAdapter->printf("%s.txt=\"%d\"", LCD_DASHBOARD_ELEMENT_NAME_ROOM_TEMPERATURE, (int)temperature);
|
|
this->sendStopBytes();
|
|
this->giveSerialMutex();
|
|
}
|
|
|
|
void CUDDisplay::handle_mqtt_connected()
|
|
{
|
|
// Refresh the display
|
|
this->refresh_display_ac();
|
|
}
|
|
|
|
void CUDDisplay::set_display_light_state(uint8_t row, bool state)
|
|
{
|
|
this->takeSerialMutex();
|
|
this->displayAdapter->printf("%s.pic=%d", this->light_group.element_name[row], state ? this->light_group.picture_on[row] : this->light_group.picture_off[row]);
|
|
this->sendStopBytes();
|
|
this->displayAdapter->printf("%s.pic2=%d", this->light_group.element_name[row], state ? this->light_group.picture_on_pressed[row] : this->light_group.picture_off_pressed[row]);
|
|
this->sendStopBytes();
|
|
this->giveSerialMutex();
|
|
}
|
|
|
|
void CUDDisplay::set_display_light_all_state()
|
|
{
|
|
bool light_on = this->get_lights_state();
|
|
this->takeSerialMutex();
|
|
this->displayAdapter->printf("%s.pic=%d", LCD_DASHBOARD_ELEMENT_NAME_LIGHT_ALL, light_on ? LCD_DASHBOARD_PIC_LIGHT_ALL_ON : LCD_DASHBOARD_PIC_LIGHT_ALL_OFF);
|
|
this->sendStopBytes();
|
|
this->displayAdapter->printf("%s.pic2=%d", LCD_DASHBOARD_ELEMENT_NAME_LIGHT_ALL, light_on ? LCD_DASHBOARD_PIC_LIGHT_ALL_ON_PRESSED : LCD_DASHBOARD_PIC_LIGHT_ALL_OFF_PRESSED);
|
|
this->sendStopBytes();
|
|
this->giveSerialMutex();
|
|
}
|
|
|
|
void CUDDisplay::set_display_fan_state(uint8_t row, bool state)
|
|
{
|
|
this->takeSerialMutex();
|
|
this->displayAdapter->printf("%s.pic=%d", this->fan_group.element_name[row], state ? this->fan_group.picture_on[row] : this->fan_group.picture_off[row]);
|
|
this->sendStopBytes();
|
|
this->displayAdapter->printf("%s.pic2=%d", this->fan_group.element_name[row], state ? this->fan_group.picture_on_pressed[row] : this->fan_group.picture_off_pressed[row]);
|
|
this->sendStopBytes();
|
|
this->giveSerialMutex();
|
|
}
|
|
|
|
void CUDDisplay::set_display_fan_all_state()
|
|
{
|
|
bool fan_on = this->get_fans_state();
|
|
this->takeSerialMutex();
|
|
this->displayAdapter->printf("%s.pic=%d", LCD_DASHBOARD_ELEMENT_NAME_FAN_ALL, fan_on ? LCD_DASHBOARD_PIC_FAN_ALL_ON : LCD_DASHBOARD_PIC_FAN_ALL_OFF);
|
|
this->sendStopBytes();
|
|
this->displayAdapter->printf("%s.pic2=%d", LCD_DASHBOARD_ELEMENT_NAME_FAN_ALL, fan_on ? LCD_DASHBOARD_PIC_FAN_ALL_ON_PRESSED : LCD_DASHBOARD_PIC_FAN_ALL_OFF_PRESSED);
|
|
this->sendStopBytes();
|
|
this->giveSerialMutex();
|
|
}
|
|
|
|
void CUDDisplay::set_display_mosquito_zapper_state(bool state)
|
|
{
|
|
this->takeSerialMutex();
|
|
this->displayAdapter->printf("%s.pic=%d", LCD_DASHBOARD_ELEMENT_NAME_MOSQUITO_ZAPPER, state ? LCD_DASHBOARD_PIC_MOSQUITO_ZAPPER_ON : LCD_DASHBOARD_PIC_MOSQUITO_ZAPPER_OFF);
|
|
this->sendStopBytes();
|
|
this->displayAdapter->printf("%s.pic2=%d", LCD_DASHBOARD_ELEMENT_NAME_MOSQUITO_ZAPPER, state ? LCD_DASHBOARD_PIC_MOSQUITO_ZAPPER_ON_PRESSED : LCD_DASHBOARD_PIC_MOSQUITO_ZAPPER_OFF_PRESSED);
|
|
this->sendStopBytes();
|
|
this->giveSerialMutex();
|
|
}
|
|
|
|
void CUDDisplay::set_display_air_purifier_state(bool state)
|
|
{
|
|
this->takeSerialMutex();
|
|
this->displayAdapter->printf("%s.pic=%d", LCD_DASHBOARD_ELEMENT_NAME_AIR_PURIFIER, state ? LCD_DASHBOARD_PIC_AIR_PURIFIER_ON : LCD_DASHBOARD_PIC_AIR_PURIFIER_OFF);
|
|
this->sendStopBytes();
|
|
this->displayAdapter->printf("%s.pic2=%d", LCD_DASHBOARD_ELEMENT_NAME_AIR_PURIFIER, state ? LCD_DASHBOARD_PIC_AIR_PURIFIER_ON_PRESSED : LCD_DASHBOARD_PIC_AIR_PURIFIER_OFF_PRESSED);
|
|
this->sendStopBytes();
|
|
this->giveSerialMutex();
|
|
}
|
|
|
|
void CUDDisplay::refresh_display()
|
|
{
|
|
// Send every states to the display
|
|
ESP_LOGV("CUD Display", "Refreshing all light button states");
|
|
this->set_display_light_all_state();
|
|
ESP_LOGV("CUD Display", "Refreshing all fan button states");
|
|
this->set_display_fan_all_state();
|
|
ESP_LOGV("CUD Display", "Refreshing air purifier state");
|
|
this->set_display_air_purifier_state(this->cards.outputCard->getState(this->conf->air_purifier_pin));
|
|
ESP_LOGV("CUD Display", "Refreshing mosquito zapper state");
|
|
this->set_display_mosquito_zapper_state(this->cards.outputCard->getState(this->conf->mosquito_zapper_pin));
|
|
ESP_LOGV("CUD Display", "Refreshing light states");
|
|
for (int i = 0; i < 4; i++)
|
|
{
|
|
this->set_display_light_state(i, this->cards.outputCard->getState(this->conf->light_pins[i]));
|
|
}
|
|
ESP_LOGV("CUD Display", "Refreshing Fan state");
|
|
for (int i = 0; i < 3; i++)
|
|
{
|
|
this->set_display_fan_state(i, this->cards.outputCard->getState(this->conf->fan_pins[i]));
|
|
}
|
|
refresh_display_ac();
|
|
refresh_display_allsystem();
|
|
refresh_display_socket();
|
|
}
|
|
|
|
void CUDDisplay::refresh_display_ac()
|
|
{
|
|
// Fetch data from the AC
|
|
uint8_t mode = this->cards.ac->getMode();
|
|
bool state = mode != 0;
|
|
previous_mode = previous_mode == 0 ? 2 : previous_mode;
|
|
uint8_t drawn_mode = mode == 0 ? previous_mode : mode;
|
|
uint8_t fan_speed = this->cards.ac->getFanSpeed();
|
|
uint8_t temperature = this->cards.ac->getTemperature();
|
|
ESP_LOGV("CUD Display", "Mode: %d, Fan Speed: %d, Temperature: %d", mode, fan_speed, temperature);
|
|
ESP_LOGV("CUD Display", "Previous Mode: %d, Drawn Mode: %d", previous_mode, drawn_mode);
|
|
// Is the AC locked?
|
|
if (this->get_ac_lock())
|
|
{
|
|
// Draw the state picture set
|
|
// When the display is locked
|
|
// the state picture set we use is the locked state picture set
|
|
this->takeSerialMutex();
|
|
this->displayAdapter->printf("%s.pic=%d", LCD_DASHBOARD_ELEMENT_NAME_AC_STATE, state ? LCD_DASHBOARD_PIC_AC_STATE_ON_LOCKED : LCD_DASHBOARD_PIC_AC_STATE_OFF_LOCKED);
|
|
this->sendStopBytes();
|
|
// Since the display is locked, when pressed, the state picture set should not change
|
|
this->displayAdapter->printf("%s.pic2=%d", LCD_DASHBOARD_ELEMENT_NAME_AC_STATE, state ? LCD_DASHBOARD_PIC_AC_STATE_ON_LOCKED : LCD_DASHBOARD_PIC_AC_STATE_OFF_LOCKED);
|
|
this->sendStopBytes();
|
|
// Set Alpha of Locked Icon to 127
|
|
this->displayAdapter->printf("%s.aph=%d", LCD_DASHBOARD_ELEMENT_NAME_ICO_LOCK, 127);
|
|
this->sendStopBytes();
|
|
// Overlay the ac container
|
|
this->displayAdapter->printf("vis %s,1", LCD_DASHBOARD_ELEMENT_NAME_AC_PANEL_OVERLAY);
|
|
this->sendStopBytes();
|
|
// Hide the temperature adjustment buttons
|
|
this->displayAdapter->printf("vis %s,0", LCD_DASHBOARD_ELEMENT_NAME_AC_TEMP_UP_BUTTON);
|
|
this->sendStopBytes();
|
|
this->displayAdapter->printf("vis %s,0", LCD_DASHBOARD_ELEMENT_NAME_AC_TEMP_DOWN_BUTTON);
|
|
this->sendStopBytes();
|
|
|
|
// Draw the mode picture set
|
|
// If it is not locked
|
|
this->displayAdapter->printf("%s.pic=%d", LCD_DASHBOARD_ELEMENT_NAME_AC_MODE_COOL, drawn_mode == 2 ? (LCD_DASHBOARD_PIC_AC_MODE_COOL_ACTIVE_LOCKED) : LCD_DASHBOARD_PIC_AC_MODE_COOL_INACTIVE);
|
|
this->sendStopBytes();
|
|
this->displayAdapter->printf("%s.pic2=%d", LCD_DASHBOARD_ELEMENT_NAME_AC_MODE_COOL, drawn_mode == 2 ? LCD_DASHBOARD_PIC_AC_MODE_COOL_ACTIVE_LOCKED : LCD_DASHBOARD_PIC_AC_MODE_COOL_INACTIVE);
|
|
this->sendStopBytes();
|
|
this->displayAdapter->printf("%s.pic=%d", LCD_DASHBOARD_ELEMENT_NAME_AC_MODE_FAN, drawn_mode == 1 ? LCD_DASHBOARD_PIC_AC_MODE_FAN_ACTIVE_LOCKED : LCD_DASHBOARD_PIC_AC_MODE_FAN_INACTIVE);
|
|
this->sendStopBytes();
|
|
this->displayAdapter->printf("%s.pic2=%d", LCD_DASHBOARD_ELEMENT_NAME_AC_MODE_FAN, drawn_mode == 1 ? LCD_DASHBOARD_PIC_AC_MODE_FAN_ACTIVE_LOCKED : LCD_DASHBOARD_PIC_AC_MODE_FAN_INACTIVE);
|
|
this->sendStopBytes();
|
|
// Draw fan speed auto picture set
|
|
this->displayAdapter->printf("%s.pic=%d", LCD_DASHBOARD_ELEMENT_NAME_AC_FAN_SPEED_AUTO, fan_speed == 0 ? LCD_DASHBOARD_PIC_AC_FAN_SPEED_AUTO_ACTIVE_LOCKED : LCD_DASHBOARD_PIC_AC_FAN_SPEED_AUTO_INACTIVE);
|
|
this->sendStopBytes();
|
|
this->displayAdapter->printf("%s.pic2=%d", LCD_DASHBOARD_ELEMENT_NAME_AC_FAN_SPEED_AUTO, fan_speed == 0 ? LCD_DASHBOARD_PIC_AC_FAN_SPEED_AUTO_ACTIVE_LOCKED : LCD_DASHBOARD_PIC_AC_FAN_SPEED_AUTO_INACTIVE);
|
|
this->sendStopBytes();
|
|
this->displayAdapter->printf("%s.pic=%d", LCD_DASHBOARD_ELEMENT_NAME_AC_FAN_SPEED_LOW, fan_speed == 1 ? LCD_DASHBOARD_PIC_AC_FAN_SPEED_LOW_ACTIVE_LOCKED : LCD_DASHBOARD_PIC_AC_FAN_SPEED_LOW_INACTIVE);
|
|
this->sendStopBytes();
|
|
this->displayAdapter->printf("%s.pic2=%d", LCD_DASHBOARD_ELEMENT_NAME_AC_FAN_SPEED_LOW, fan_speed == 1 ? LCD_DASHBOARD_PIC_AC_FAN_SPEED_LOW_ACTIVE_LOCKED : LCD_DASHBOARD_PIC_AC_FAN_SPEED_LOW_INACTIVE);
|
|
this->sendStopBytes();
|
|
this->displayAdapter->printf("%s.pic=%d", LCD_DASHBOARD_ELEMENT_NAME_AC_FAN_SPEED_MEDIUM, fan_speed == 2 ? LCD_DASHBOARD_PIC_AC_FAN_SPEED_MEDIUM_ACTIVE_LOCKED : LCD_DASHBOARD_PIC_AC_FAN_SPEED_MEDIUM_INACTIVE);
|
|
this->sendStopBytes();
|
|
this->displayAdapter->printf("%s.pic2=%d", LCD_DASHBOARD_ELEMENT_NAME_AC_FAN_SPEED_MEDIUM, fan_speed == 2 ? LCD_DASHBOARD_PIC_AC_FAN_SPEED_MEDIUM_ACTIVE_LOCKED : LCD_DASHBOARD_PIC_AC_FAN_SPEED_MEDIUM_INACTIVE);
|
|
this->sendStopBytes();
|
|
this->displayAdapter->printf("%s.pic=%d", LCD_DASHBOARD_ELEMENT_NAME_AC_FAN_SPEED_HIGH, fan_speed == 3 ? LCD_DASHBOARD_PIC_AC_FAN_SPEED_HIGH_ACTIVE_LOCKED : LCD_DASHBOARD_PIC_AC_FAN_SPEED_HIGH_INACTIVE);
|
|
this->sendStopBytes();
|
|
this->displayAdapter->printf("%s.pic2=%d", LCD_DASHBOARD_ELEMENT_NAME_AC_FAN_SPEED_HIGH, fan_speed == 3 ? LCD_DASHBOARD_PIC_AC_FAN_SPEED_HIGH_ACTIVE_LOCKED : LCD_DASHBOARD_PIC_AC_FAN_SPEED_HIGH_INACTIVE);
|
|
this->sendStopBytes();
|
|
this->giveSerialMutex();
|
|
}
|
|
else
|
|
{
|
|
// When the display is not locked
|
|
// the state picture set we use is the unlocked state picture set
|
|
this->takeSerialMutex();
|
|
this->displayAdapter->printf("%s.pic=%d", LCD_DASHBOARD_ELEMENT_NAME_AC_STATE, state ? LCD_DASHBOARD_PIC_AC_STATE_ON : LCD_DASHBOARD_PIC_AC_STATE_OFF);
|
|
this->sendStopBytes();
|
|
// When pressed, the state picture set should change
|
|
this->displayAdapter->printf("%s.pic2=%d", LCD_DASHBOARD_ELEMENT_NAME_AC_STATE, state ? LCD_DASHBOARD_PIC_AC_STATE_ON_PRESSED : LCD_DASHBOARD_PIC_AC_STATE_OFF_PRESSED);
|
|
this->sendStopBytes();
|
|
// Set Alpha of Locked Icon to 0
|
|
this->displayAdapter->printf("%s.aph=%d", LCD_DASHBOARD_ELEMENT_NAME_ICO_LOCK, 0);
|
|
this->sendStopBytes();
|
|
// Hide the ac container overlay
|
|
this->displayAdapter->printf("vis %s,0", LCD_DASHBOARD_ELEMENT_NAME_AC_PANEL_OVERLAY);
|
|
this->sendStopBytes();
|
|
// Show the temperature adjustment buttons
|
|
this->displayAdapter->printf("vis %s,1", LCD_DASHBOARD_ELEMENT_NAME_AC_TEMP_UP_BUTTON);
|
|
this->sendStopBytes();
|
|
this->displayAdapter->printf("vis %s,1", LCD_DASHBOARD_ELEMENT_NAME_AC_TEMP_DOWN_BUTTON);
|
|
this->sendStopBytes();
|
|
// Draw the mode picture set
|
|
this->displayAdapter->printf("%s.pic=%d", LCD_DASHBOARD_ELEMENT_NAME_AC_MODE_COOL, drawn_mode == 2 ? (LCD_DASHBOARD_PIC_AC_MODE_COOL_ACTIVE) : LCD_DASHBOARD_PIC_AC_MODE_COOL_INACTIVE);
|
|
this->sendStopBytes();
|
|
this->displayAdapter->printf("%s.pic2=%d", LCD_DASHBOARD_ELEMENT_NAME_AC_MODE_COOL, drawn_mode == 2 ? LCD_DASHBOARD_PIC_AC_MODE_COOL_ACTIVE_PRESS : LCD_DASHBOARD_PIC_AC_MODE_COOL_INACTIVE_PRESS);
|
|
this->sendStopBytes();
|
|
this->displayAdapter->printf("%s.pic=%d", LCD_DASHBOARD_ELEMENT_NAME_AC_MODE_FAN, drawn_mode == 1 ? LCD_DASHBOARD_PIC_AC_MODE_FAN_ACTIVE : LCD_DASHBOARD_PIC_AC_MODE_FAN_INACTIVE);
|
|
this->sendStopBytes();
|
|
this->displayAdapter->printf("%s.pic2=%d", LCD_DASHBOARD_ELEMENT_NAME_AC_MODE_FAN, drawn_mode == 1 ? LCD_DASHBOARD_PIC_AC_MODE_FAN_ACTIVE_PRESS : LCD_DASHBOARD_PIC_AC_MODE_FAN_INACTIVE_PRESS);
|
|
this->sendStopBytes();
|
|
this->giveSerialMutex();
|
|
// Draw fan speed picture set
|
|
this->takeSerialMutex();
|
|
this->displayAdapter->printf("%s.pic=%d", LCD_DASHBOARD_ELEMENT_NAME_AC_FAN_SPEED_AUTO, fan_speed == 0 ? LCD_DASHBOARD_PIC_AC_FAN_SPEED_AUTO_ACTIVE : LCD_DASHBOARD_PIC_AC_FAN_SPEED_AUTO_INACTIVE);
|
|
this->sendStopBytes();
|
|
this->displayAdapter->printf("%s.pic2=%d", LCD_DASHBOARD_ELEMENT_NAME_AC_FAN_SPEED_AUTO, fan_speed == 0 ? LCD_DASHBOARD_PIC_AC_FAN_SPEED_AUTO_ACTIVE_PRESS : LCD_DASHBOARD_PIC_AC_FAN_SPEED_AUTO_INACTIVE_PRESS);
|
|
this->sendStopBytes();
|
|
this->displayAdapter->printf("%s.pic=%d", LCD_DASHBOARD_ELEMENT_NAME_AC_FAN_SPEED_LOW, fan_speed == 1 ? LCD_DASHBOARD_PIC_AC_FAN_SPEED_LOW_ACTIVE : LCD_DASHBOARD_PIC_AC_FAN_SPEED_LOW_INACTIVE);
|
|
this->sendStopBytes();
|
|
this->displayAdapter->printf("%s.pic2=%d", LCD_DASHBOARD_ELEMENT_NAME_AC_FAN_SPEED_LOW, fan_speed == 1 ? LCD_DASHBOARD_PIC_AC_FAN_SPEED_LOW_ACTIVE_PRESS : LCD_DASHBOARD_PIC_AC_FAN_SPEED_LOW_INACTIVE_PRESS);
|
|
this->sendStopBytes();
|
|
this->displayAdapter->printf("%s.pic=%d", LCD_DASHBOARD_ELEMENT_NAME_AC_FAN_SPEED_MEDIUM, fan_speed == 2 ? LCD_DASHBOARD_PIC_AC_FAN_SPEED_MEDIUM_ACTIVE : LCD_DASHBOARD_PIC_AC_FAN_SPEED_MEDIUM_INACTIVE);
|
|
this->sendStopBytes();
|
|
this->displayAdapter->printf("%s.pic2=%d", LCD_DASHBOARD_ELEMENT_NAME_AC_FAN_SPEED_MEDIUM, fan_speed == 2 ? LCD_DASHBOARD_PIC_AC_FAN_SPEED_MEDIUM_ACTIVE_PRESS : LCD_DASHBOARD_PIC_AC_FAN_SPEED_MEDIUM_INACTIVE_PRESS);
|
|
this->sendStopBytes();
|
|
this->displayAdapter->printf("%s.pic=%d", LCD_DASHBOARD_ELEMENT_NAME_AC_FAN_SPEED_HIGH, fan_speed == 3 ? LCD_DASHBOARD_PIC_AC_FAN_SPEED_HIGH_ACTIVE : LCD_DASHBOARD_PIC_AC_FAN_SPEED_HIGH_INACTIVE);
|
|
this->sendStopBytes();
|
|
this->displayAdapter->printf("%s.pic2=%d", LCD_DASHBOARD_ELEMENT_NAME_AC_FAN_SPEED_HIGH, fan_speed == 3 ? LCD_DASHBOARD_PIC_AC_FAN_SPEED_HIGH_ACTIVE_PRESS : LCD_DASHBOARD_PIC_AC_FAN_SPEED_HIGH_INACTIVE_PRESS);
|
|
this->sendStopBytes();
|
|
this->giveSerialMutex();
|
|
}
|
|
|
|
// Draw the fan speed picture set
|
|
// Draw the temperature
|
|
this->takeSerialMutex();
|
|
this->displayAdapter->printf("%s.txt=\"%d\"", LCD_DASHBOARD_ELEMENT_NAME_AC_TEMPERATURE, temperature);
|
|
this->sendStopBytes();
|
|
this->giveSerialMutex();
|
|
}
|
|
|
|
void CUDDisplay::refresh_display_allsystem()
|
|
{
|
|
this->takeSerialMutex();
|
|
this->displayAdapter->printf("%s.pic=%d", LCD_DASHBOARD_ELEMENT_NAME_ALL_SYSTEM_TOGGLE, this->get_system_state() ? LCD_DASHBOARD_PIC_ALL_SYSTEM_TOGGLE_ON : LCD_DASHBOARD_PIC_ALL_SYSTEM_TOGGLE_OFF);
|
|
this->sendStopBytes();
|
|
this->displayAdapter->printf("%s.pic2=%d", LCD_DASHBOARD_ELEMENT_NAME_ALL_SYSTEM_TOGGLE, this->get_system_state() ? LCD_DASHBOARD_PIC_ALL_SYSTEM_TOGGLE_ON_PRESSED : LCD_DASHBOARD_PIC_ALL_SYSTEM_TOGGLE_OFF_PRESSED);
|
|
this->sendStopBytes();
|
|
this->giveSerialMutex();
|
|
}
|
|
|
|
void CUDDisplay::refresh_display_socket()
|
|
{
|
|
this->takeSerialMutex();
|
|
this->displayAdapter->printf("%s.pic=%d", LCD_DASHBOARD_ELEMENT_NAME_SOCKET_POWER, this->cards.outputCard->getState(this->conf->socket_contactor_pin) ? LCD_DASHBOARD_PIC_SOCKET_POWER_ON : LCD_DASHBOARD_PIC_SOCKET_POWER_OFF);
|
|
this->sendStopBytes();
|
|
this->giveSerialMutex();
|
|
}
|
|
|
|
bool CUDDisplay::get_system_state()
|
|
{
|
|
// The system state is defined to be on when any of the lights, fans, air purifier, mosquito zapper or AC is on
|
|
return this->get_lights_state() || this->get_fans_state() || this->cards.outputCard->getState(this->conf->air_purifier_pin) || this->cards.outputCard->getState(this->conf->mosquito_zapper_pin) || this->cards.ac->getMode() != 0;
|
|
}
|
|
|
|
void CUDDisplay::system_toggle()
|
|
{
|
|
// If the system is on, turn everything off if it is on
|
|
if (this->get_system_state())
|
|
{
|
|
for (int i = 0; i < 4; i++)
|
|
{
|
|
if (this->cards.outputCard->getState(this->conf->light_pins[i]))
|
|
this->cards.outputCard->setState(this->conf->light_pins[i], false);
|
|
}
|
|
for (int i = 0; i < 3; i++)
|
|
{
|
|
if (this->cards.outputCard->getState(this->conf->fan_pins[i]))
|
|
this->cards.outputCard->setState(this->conf->fan_pins[i], false);
|
|
}
|
|
if (this->cards.outputCard->getState(this->conf->air_purifier_pin))
|
|
this->cards.outputCard->setState(this->conf->air_purifier_pin, false);
|
|
if (this->cards.outputCard->getState(this->conf->mosquito_zapper_pin))
|
|
this->cards.outputCard->setState(this->conf->mosquito_zapper_pin, false);
|
|
if (!get_ac_lock() && this->cards.ac->getMode() != 0)
|
|
this->cards.ac->setMode(0);
|
|
}
|
|
// If the system is off, turn lights, mosquito zapper, air purifier and AC on if they are off
|
|
else
|
|
{
|
|
for (int i = 0; i < 4; i++)
|
|
{
|
|
if (!this->cards.outputCard->getState(this->conf->light_pins[i]))
|
|
this->cards.outputCard->setState(this->conf->light_pins[i], true);
|
|
}
|
|
if (!this->cards.outputCard->getState(this->conf->mosquito_zapper_pin))
|
|
this->cards.outputCard->setState(this->conf->mosquito_zapper_pin, true);
|
|
if (!this->cards.outputCard->getState(this->conf->air_purifier_pin))
|
|
this->cards.outputCard->setState(this->conf->air_purifier_pin, true);
|
|
if (!get_ac_lock())
|
|
this->cards.ac->setMode(previous_mode);
|
|
}
|
|
}
|
|
|
|
void CUDDisplay::set_ac_lock(bool state)
|
|
{
|
|
ac_lock.setIntValue((bool)state);
|
|
this->refresh_display_ac();
|
|
}
|
|
|
|
bool CUDDisplay::get_ac_lock()
|
|
{
|
|
if (standalone)
|
|
{
|
|
return false;
|
|
}
|
|
return (bool)ac_lock.getIntValue();
|
|
}
|
|
|
|
uint8_t CUDDisplay::get_ac_temp_lower_bound()
|
|
{
|
|
if (standalone)
|
|
{
|
|
return AC_MIN_TEMP;
|
|
}
|
|
return ac_temp_lower_bound.getIntValue();
|
|
}
|
|
|
|
uint8_t CUDDisplay::get_ac_temp_upper_bound()
|
|
{
|
|
if (standalone)
|
|
{
|
|
return AC_MAX_TEMP;
|
|
}
|
|
return ac_temp_upper_bound.getIntValue();
|
|
} |