siwat
/
ESPMegaPRO-v3-SDK
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

debug_fram

This commit is contained in:
Siwat Sirichai 2023-12-31 02:18:57 +07:00
parent b4b7232937
commit 091dc183fe
7 changed files with 126 additions and 48 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

56
ESPMegaPRO-firmware/lib/ESPMegaPRO/ClimateCard.cpp
View File

@ -86,24 +86,37 @@ void ClimateCard::setFRAMAutoSave(bool autoSave)
void ClimateCard::saveStateToFRAM() void ClimateCard::saveStateToFRAM()
{ {
fram->writeObject(fram_address, this->state); // fram->write8(fram_address, state.ac_temperature);
// fram->write8(fram_address + 1, state.ac_mode);
// fram->write8(fram_address + 2, state.ac_fan_speed);
fram->writeObject(fram_address, state);
Serial.println("Saved state to FRAM");
Serial.write(0xFF);
Serial.write(0xFF);
Serial.write(0xFF);
} }
void ClimateCard::loadStateFromFRAM() void ClimateCard::loadStateFromFRAM()
{ {
fram->readObject(fram_address, this->state); // state.ac_temperature = fram->read8(fram_address);
// If temperature is out of range, set to its respective maximum or minimum // state.ac_mode = fram->read8(fram_address + 1);
if (state.ac_temperature > ac.max_temperature) // state.ac_fan_speed = fram->read8(fram_address + 2);
state.ac_temperature = ac.max_temperature; fram->readObject(fram_address, state);
else if (state.ac_temperature < ac.min_temperature) // if (state.ac_temperature > ac.max_temperature)
state.ac_temperature = ac.min_temperature; // state.ac_temperature = ac.max_temperature;
// If mode is out of range, set to 0 // else if (state.ac_temperature < ac.min_temperature)
if (state.ac_mode > ac.modes) // state.ac_temperature = ac.min_temperature;
state.ac_mode = 0; // // If mode is out of range, set to 0
// If fan speed is out of range, set to 0 // if (state.ac_mode > ac.modes)
if (state.ac_fan_speed > ac.fan_speeds) // state.ac_mode = 0;
state.ac_fan_speed = 0; // // If fan speed is out of range, set to 0
// if (state.ac_fan_speed > ac.fan_speeds)
// state.ac_fan_speed = 0;
updateAirConditioner(); updateAirConditioner();
for (uint8_t i = 0; i < callbacks.size(); i++)
{
callbacks[i](this->state.ac_mode, this->state.ac_fan_speed, this->state.ac_temperature);
}
} }
void ClimateCard::setTemperature(uint8_t temperature) void ClimateCard::setTemperature(uint8_t temperature)
@ -137,6 +150,10 @@ void ClimateCard::setFanSpeed(uint8_t fan_speed)
void ClimateCard::registerChangeCallback(std::function<void(uint8_t, uint8_t, uint8_t)> callback) void ClimateCard::registerChangeCallback(std::function<void(uint8_t, uint8_t, uint8_t)> callback)
{ {
Serial.print("Registering callback");
Serial.write(0xFF);
Serial.write(0xFF);
Serial.write(0xFF);
callbacks.push_back(callback); callbacks.push_back(callback);
} }
@ -199,10 +216,15 @@ void ClimateCard::updateAirConditioner()
// rmt_write_items(RMT_TX_CHANNEL, items, itemCount, true); // rmt_write_items(RMT_TX_CHANNEL, items, itemCount, true);
// rmt_wait_tx_done(RMT_TX_CHANNEL, portMAX_DELAY); // rmt_wait_tx_done(RMT_TX_CHANNEL, portMAX_DELAY);
// // Publish state // // Publish state
// for (uint8_t i = 0; i < callbacks.size(); i++) Serial.print("Callbacks: ");
// { Serial.println(callbacks.size());
// callbacks[i](this->state.ac_mode, this->state.ac_fan_speed, this->state.ac_temperature); Serial.write(0xFF);
// } Serial.write(0xFF);
Serial.write(0xFF);
for (uint8_t i = 0; i < callbacks.size(); i++)
{
callbacks[i](this->state.ac_mode, this->state.ac_fan_speed, this->state.ac_temperature);
}
} }
uint8_t ClimateCard::getSensorType() uint8_t ClimateCard::getSensorType()

48
ESPMegaPRO-firmware/lib/ESPMegaPRO/ESPMegaIoT.cpp
View File

@ -1,7 +1,5 @@
#include <ESPMegaIoT.hpp> #include <ESPMegaIoT.hpp>
#include <ETH.h> #include <ETH.h>
#define NETWORK_CONFIG_ADDRESS 34
#define MQTT_CONFIG_ADDRESS 34 + sizeof(NetworkConfig)
ESPMegaIoT::ESPMegaIoT() : mqtt(tcpClient) ESPMegaIoT::ESPMegaIoT() : mqtt(tcpClient)
{ {
@ -316,13 +314,34 @@ void ESPMegaIoT::setNetworkConfig(NetworkConfig network_config)
void ESPMegaIoT::loadNetworkConfig() void ESPMegaIoT::loadNetworkConfig()
{ {
// Load the network config from FRAM // Load the network config from FRAM
fram->read(0, (uint8_t *)&network_config, sizeof(NetworkConfig)); network_config.ip = fram->read32(FRAM_ADDRESS);
network_config.gateway = fram->read32(FRAM_ADDRESS + 4);
network_config.subnet = fram->read32(FRAM_ADDRESS + 8);
network_config.dns1 = fram->read32(FRAM_ADDRESS + 12);
network_config.dns2 = fram->read32(FRAM_ADDRESS + 16);
fram->read(FRAM_ADDRESS + 20, (uint8_t*)network_config.hostname, 32);
network_config.useStaticIp = fram->read8(FRAM_ADDRESS + 52);
network_config.useWifi = fram->read8(FRAM_ADDRESS + 53);
network_config.wifiUseAuth = fram->read8(FRAM_ADDRESS + 54);
fram->read(FRAM_ADDRESS + 55, (uint8_t*)network_config.ssid, 32);
fram->read(FRAM_ADDRESS + 87, (uint8_t*)network_config.password, 32);
} }
void ESPMegaIoT::saveNetworkConfig() void ESPMegaIoT::saveNetworkConfig()
{ {
// Save the network config to FRAM // Save the network config to FRAM
fram->write(NETWORK_CONFIG_ADDRESS, (uint8_t *)&network_config, sizeof(NetworkConfig)); fram->write32(FRAM_ADDRESS, network_config.ip);
fram->write32(FRAM_ADDRESS + 4, network_config.gateway);
fram->write32(FRAM_ADDRESS + 8, network_config.subnet);
fram->write32(FRAM_ADDRESS + 12, network_config.dns1);
fram->write32(FRAM_ADDRESS + 16, network_config.dns2);
fram->write(FRAM_ADDRESS + 20, (uint8_t*)network_config.hostname, 32);
fram->write8(FRAM_ADDRESS + 52, network_config.useStaticIp);
fram->write8(FRAM_ADDRESS + 53, network_config.useWifi);
fram->write8(FRAM_ADDRESS + 54, network_config.wifiUseAuth);
fram->write(FRAM_ADDRESS + 55, (uint8_t*)network_config.ssid, 32);
fram->write(FRAM_ADDRESS + 87, (uint8_t*)network_config.password, 32);
} }
void ESPMegaIoT::ethernetBegin() void ESPMegaIoT::ethernetBegin()
@ -333,13 +352,23 @@ void ESPMegaIoT::ethernetBegin()
void ESPMegaIoT::loadMqttConfig() void ESPMegaIoT::loadMqttConfig()
{ {
// Load the mqtt config from FRAM // Load the mqtt config from FRAM
fram->read(sizeof(NetworkConfig), (uint8_t *)&this->mqtt_config, sizeof(MqttConfig)); // We skip bytes 119-127 because they are reserved for the network config
// Populate the mqtt connection parameters mqtt_config.mqtt_port = fram->read16(FRAM_ADDRESS + 128);
fram->read(FRAM_ADDRESS + 130, (uint8_t*)mqtt_config.mqtt_server, 32);
fram->read(FRAM_ADDRESS + 162, (uint8_t*)mqtt_config.mqtt_user, 32);
fram->read(FRAM_ADDRESS + 194, (uint8_t*)mqtt_config.mqtt_password, 32);
mqtt_config.mqtt_useauth = fram->read8(FRAM_ADDRESS + 226);
fram->read(FRAM_ADDRESS + 227, (uint8_t*)mqtt_config.base_topic, 32);
} }
void ESPMegaIoT::saveMqttConfig() void ESPMegaIoT::saveMqttConfig()
{ {
fram->write(MQTT_CONFIG_ADDRESS, (uint8_t *)&mqtt_config, sizeof(MqttConfig)); fram->write16(FRAM_ADDRESS + 128, mqtt_config.mqtt_port);
fram->write(FRAM_ADDRESS + 130, (uint8_t*)mqtt_config.mqtt_server, 32);
fram->write(FRAM_ADDRESS + 162, (uint8_t*)mqtt_config.mqtt_user, 32);
fram->write(FRAM_ADDRESS + 194, (uint8_t*)mqtt_config.mqtt_password, 32);
fram->write8(FRAM_ADDRESS + 226, mqtt_config.mqtt_useauth);
fram->write(FRAM_ADDRESS + 227, (uint8_t*)mqtt_config.base_topic, 32);
} }
void ESPMegaIoT::connectToMqtt() void ESPMegaIoT::connectToMqtt()
@ -407,4 +436,9 @@ bool ESPMegaIoT::networkConnected()
return WiFi.status() == WL_CONNECTED; return WiFi.status() == WL_CONNECTED;
else else
return ethernetIface->linkUp(); return ethernetIface->linkUp();
}
void ESPMegaIoT::bindFRAM(FRAM *fram)
{
this->fram = fram;
} }

7
ESPMegaPRO-firmware/lib/ESPMegaPRO/ESPMegaIoT.hpp
View File

@ -14,6 +14,12 @@
#include <WiFi.h> #include <WiFi.h>
#include <FRAM.h> #include <FRAM.h>
// FRAM Address for ESPMegaPROIoT
// Starts from 34
// Ends at 300 (inclusive)
// Total of 267 bytes
#define FRAM_ADDRESS 34
struct NetworkConfig struct NetworkConfig
{ {
IPAddress ip; IPAddress ip;
@ -81,6 +87,7 @@ public:
void setBaseTopic(char *base_topic); void setBaseTopic(char *base_topic);
void bindEthernetInterface(ETHClass *ethernetIface); void bindEthernetInterface(ETHClass *ethernetIface);
bool networkConnected(); bool networkConnected();
void bindFRAM(FRAM *fram);
IoTComponent* getComponent(uint8_t card_id); IoTComponent* getComponent(uint8_t card_id);
IPAddress getETHIp(); IPAddress getETHIp();

6
ESPMegaPRO-firmware/lib/ESPMegaPRO/ESPMegaPRO_OOP.cpp
View File

@ -1,4 +1,9 @@
#include <ESPMegaPRO_OOP.hpp> #include <ESPMegaPRO_OOP.hpp>
// Reserve FRAM address 0 - 1000 for ESPMegaPRO Internal Use
// (34 Bytes) Address 0-33 for Built-in Digital Output Card
// () Address 34-300 for ESPMegaPRO IoT Module
ESPMegaPRO::ESPMegaPRO() { ESPMegaPRO::ESPMegaPRO() {
} }
@ -95,6 +100,7 @@ void ESPMegaPRO::setTime(int hours, int minutes, int seconds, int day, int month
void ESPMegaPRO::enableIotModule() { void ESPMegaPRO::enableIotModule() {
if (iotEnabled) return; if (iotEnabled) return;
this->iot = new ESPMegaIoT(); this->iot = new ESPMegaIoT();
this->iot->bindFRAM(&fram);
this->iot->intr_begin(cards); this->iot->intr_begin(cards);
iotEnabled = true; iotEnabled = true;
} }

47
ESPMegaPRO-firmware/lib/ESPMegaPRO/InternalDisplay.cpp
View File

@ -2,39 +2,26 @@
void InternalDisplay::begin(ESPMegaIoT *iot, std::function<rtctime_t()> getRtcTime) { void InternalDisplay::begin(ESPMegaIoT *iot, std::function<rtctime_t()> getRtcTime) {
ESP_LOGD("InternalDisplay", "Assigning IoT Module and RTC Time Getter");
this->iot = iot; this->iot = iot;
this->getRtcTime = getRtcTime; this->getRtcTime = getRtcTime;
ESP_LOGD("InternalDisplay", "Acquiring Network and MQTT Configs");
this->mqttConfig = this->iot->getMqttConfig(); this->mqttConfig = this->iot->getMqttConfig();
this->networkConfig = this->iot->getNetworkConfig(); this->networkConfig = this->iot->getNetworkConfig();
// Register callbacks // Register callbacks
ESP_LOGD("InternalDisplay", "Registering Callbacks");
auto bindedPageChangeCallback = std::bind(&InternalDisplay::handlePageChange, this, std::placeholders::_1); auto bindedPageChangeCallback = std::bind(&InternalDisplay::handlePageChange, this, std::placeholders::_1);
this->registerPageChangeCallback(bindedPageChangeCallback); this->registerPageChangeCallback(bindedPageChangeCallback);
auto bindedTouchCallback = std::bind(&InternalDisplay::handleTouch, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3); auto bindedTouchCallback = std::bind(&InternalDisplay::handleTouch, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3);
this->registerTouchCallback(bindedTouchCallback); this->registerTouchCallback(bindedTouchCallback);
ESP_LOGD("InternalDisplay", "Binding Page Change Callback");
auto bindedInputStateChangeCallback = std::bind(&InternalDisplay::handleInputStateChange, this, std::placeholders::_1, std::placeholders::_2); auto bindedInputStateChangeCallback = std::bind(&InternalDisplay::handleInputStateChange, this, std::placeholders::_1, std::placeholders::_2);
ESP_LOGD("InternalDisplay", "Binding Input State Change Callback");
auto bindedPwmStateChangeCallback = std::bind(&InternalDisplay::handlePwmStateChange, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3); auto bindedPwmStateChangeCallback = std::bind(&InternalDisplay::handlePwmStateChange, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3);
ESP_LOGD("InternalDisplay", "Registering inputCard Callbacks");
this->inputCard->registerCallback(bindedInputStateChangeCallback); this->inputCard->registerCallback(bindedInputStateChangeCallback);
ESP_LOGD("InternalDisplay", "Registering outputCard Callbacks");
this->outputCard->registerChangeCallback(bindedPwmStateChangeCallback); this->outputCard->registerChangeCallback(bindedPwmStateChangeCallback);
// Initialize the display // Initialize the display
ESP_LOGD("InternalDisplay", "Initializing DisplayAdapter");
this->displayAdapter->begin(115200); this->displayAdapter->begin(115200);
ESP_LOGD("InternalDisplay", "Setting DisplayAdapter Timeout");
this->displayAdapter->setTimeout(100); this->displayAdapter->setTimeout(100);
ESP_LOGD("InternalDisplay", "Flushing DisplayAdapter");
this->displayAdapter->flush(); this->displayAdapter->flush();
ESP_LOGD("InternalDisplay", "Resetting Display");
this->reset(); this->reset();
delay(500); delay(500);
ESP_LOGD("InternalDisplay", "Jumping to Page 1");
this->jumpToPage(1); this->jumpToPage(1);
ESP_LOGD("InternalDisplay", "Display Initialization Complete");
} }
@ -99,12 +86,7 @@ void InternalDisplay::updateStatusIcons(bool networkStatus, bool mqttStatus) {
void InternalDisplay::updateClock() { void InternalDisplay::updateClock() {
rtctime_t time = this->getRtcTime(); rtctime_t time = this->getRtcTime();
this->displayAdapter->print("time.txt="); this->displayAdapter->printf("time.txt=\"%02d:%02d %s\"", time.hours%12, time.minutes, time.hours/12 ? "PM" : "AM");
this->displayAdapter->print(time.hours%12);
this->displayAdapter->print(":");
this->displayAdapter->print(time.minutes);
this->displayAdapter->print(" ");
this->displayAdapter->print(time.hours/12 ? "PM" : "AM");
this->sendStopBytes(); this->sendStopBytes();
} }
@ -134,6 +116,12 @@ void InternalDisplay::refreshPage(uint8_t page) {
case INTERNAL_DISPLAY_PWM_ADJUSTMENT_PAGE: case INTERNAL_DISPLAY_PWM_ADJUSTMENT_PAGE:
this->refreshPWMAdjustment(); this->refreshPWMAdjustment();
break; break;
case INTERNAL_DISPLAY_NETWORK_CONFIG_PAGE:
this->refreshNetworkConfig();
break;
case INTERNAL_DISPLAY_MQTT_CONFIG_PAGE:
this->refreshMQTTConfig();
break;
default: default:
break; break;
} }
@ -269,6 +257,8 @@ void InternalDisplay::bindOutputCard(DigitalOutputCard *outputCard) {
// fan_speed: [auto, low, medium, high] // fan_speed: [auto, low, medium, high]
void InternalDisplay::bindClimateCard(ClimateCard *climateCard) { void InternalDisplay::bindClimateCard(ClimateCard *climateCard) {
this->climateCard = climateCard; this->climateCard = climateCard;
auto bindedACStateChangeCallback = std::bind(&InternalDisplay::handleACStateChange, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3);
this->climateCard->registerChangeCallback(bindedACStateChangeCallback);
} }
void InternalDisplay::refreshPWMAdjustment() { void InternalDisplay::refreshPWMAdjustment() {
@ -379,8 +369,6 @@ void InternalDisplay::handleACTouch(uint8_t type, uint8_t component) {
default: default:
break; break;
} }
// Refresh the AC page
this->refreshAC();
} }
void InternalDisplay::handlePWMAdjustmentTouch(uint8_t type, uint8_t component) { void InternalDisplay::handlePWMAdjustmentTouch(uint8_t type, uint8_t component) {
@ -468,9 +456,8 @@ void InternalDisplay::refreshMQTTConfig() {
this->displayAdapter->print("\""); this->displayAdapter->print("\"");
this->sendStopBytes(); this->sendStopBytes();
// Refresh the mqtt port // Refresh the mqtt port
this->displayAdapter->print("port_set.txt=\""); this->displayAdapter->print("port_set.val=");
this->displayAdapter->print(this->mqttConfig->mqtt_port); this->displayAdapter->print(this->mqttConfig->mqtt_port);
this->displayAdapter->print("\"");
this->sendStopBytes(); this->sendStopBytes();
// Refresh the mqtt username // Refresh the mqtt username
this->displayAdapter->print("user_set.txt=\""); this->displayAdapter->print("user_set.txt=\"");
@ -487,6 +474,10 @@ void InternalDisplay::refreshMQTTConfig() {
this->displayAdapter->print(this->mqttConfig->base_topic); this->displayAdapter->print(this->mqttConfig->base_topic);
this->displayAdapter->print("\""); this->displayAdapter->print("\"");
this->sendStopBytes(); this->sendStopBytes();
// Refresh the mqtt use auth
this->displayAdapter->print("use_auth.val=");
this->displayAdapter->print(this->mqttConfig->mqtt_useauth ? 1 : 0);
this->sendStopBytes();
} }
void InternalDisplay::sendIpToDisplay(IPAddress ip) { void InternalDisplay::sendIpToDisplay(IPAddress ip) {
@ -498,4 +489,14 @@ void InternalDisplay::sendIpToDisplay(IPAddress ip) {
this->displayAdapter->print(ip[2]); this->displayAdapter->print(ip[2]);
this->displayAdapter->print("."); this->displayAdapter->print(".");
this->displayAdapter->print(ip[3]); this->displayAdapter->print(ip[3]);
}
void InternalDisplay::handleACStateChange(uint8_t mode, uint8_t fan_speed, uint8_t temperature) {
// If the climate card is binded to the display and the current page is the AC page
// then update the respective AC component
Serial.println("AC state changed");
if (this->climateCard==nullptr || this->currentPage != INTERNAL_DISPLAY_AC_PAGE) return;
this->sendStopBytes();
// Update the AC state
this->refreshAC();
} }

1
ESPMegaPRO-firmware/lib/ESPMegaPRO/InternalDisplay.hpp
View File

@ -84,6 +84,7 @@ class InternalDisplay : public ESPMegaDisplay {
void setOutputBar(uint8_t pin, uint16_t value); void setOutputBar(uint8_t pin, uint16_t value);
void setOutputStateColor(uint8_t pin, bool state); void setOutputStateColor(uint8_t pin, bool state);
void setInputMarker(uint8_t pin, bool state); void setInputMarker(uint8_t pin, bool state);
void handleACStateChange(uint8_t mode, uint8_t fan_speed, uint8_t temperature);
void saveNetworkConfig(); void saveNetworkConfig();
void saveMQTTConfig(); void saveMQTTConfig();
void updateStatusIcons(bool networkStatus, bool mqttStatus); void updateStatusIcons(bool networkStatus, bool mqttStatus);

9
ESPMegaPRO-firmware/src/main.cpp
View File

@ -68,6 +68,7 @@ void setup() {
Serial.println("Setting network config"); Serial.println("Setting network config");
espmega.iot->setNetworkConfig(config); espmega.iot->setNetworkConfig(config);
espmega.iot->saveNetworkConfig(); espmega.iot->saveNetworkConfig();
// espmega.iot->loadNetworkConfig();
Serial.println("Connecting to network"); Serial.println("Connecting to network");
espmega.iot->connectNetwork(); espmega.iot->connectNetwork();
Serial.println("Begin MQTT Modules"); Serial.println("Begin MQTT Modules");
@ -81,6 +82,7 @@ void setup() {
Serial.println("Loading MQTT Config Struct to IoT Module"); Serial.println("Loading MQTT Config Struct to IoT Module");
espmega.iot->setMqttConfig(mqtt_config); espmega.iot->setMqttConfig(mqtt_config);
espmega.iot->saveMqttConfig(); espmega.iot->saveMqttConfig();
// espmega.iot->loadMqttConfig();
Serial.println("Connecting to MQTT"); Serial.println("Connecting to MQTT");
espmega.iot->connectToMqtt(); espmega.iot->connectToMqtt();
Serial.println("Registering Output Card"); Serial.println("Registering Output Card");
@ -91,13 +93,18 @@ void setup() {
espmega.inputs.registerCallback(input_change_callback); espmega.inputs.registerCallback(input_change_callback);
Serial.println("Installing Climate Card"); Serial.println("Installing Climate Card");
espmega.installCard(2, &climateCard); espmega.installCard(2, &climateCard);
climateCard.bindFRAM(&espmega.fram, 2000); climateCard.bindFRAM(&espmega.fram, 301);
climateCard.loadStateFromFRAM(); climateCard.loadStateFromFRAM();
climateCard.setFRAMAutoSave(true); climateCard.setFRAMAutoSave(true);
Serial.println("Enabling Internal Display"); Serial.println("Enabling Internal Display");
espmega.enableInternalDisplay(&Serial); espmega.enableInternalDisplay(&Serial);
espmega.display->bindClimateCard(&climateCard); espmega.display->bindClimateCard(&climateCard);
Serial.println("Initialization Routine Complete"); Serial.println("Initialization Routine Complete");
Serial.write(0xFF);
Serial.write(0xFF);
Serial.write(0xFF);
Serial.println(sizeof(MqttConfig));
Serial.println(sizeof(NetworkConfig));
} }
void loop() { void loop() {