polymech/firmware-base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
master
firmware-base/src/PHApp.cpp

1487 lines
39 KiB
C++
Raw Permalink Blame History

#include <Arduino.h>
#include <macros.h>
#include <Component.h>
#include <enums.h>
#include <ArduinoLog.h>
#include "./PHApp.h"
#include "./config.h"
#include "./config-modbus.h"
#include "esp32_compat.h"
#include "Settings.h"
#include <components/Logger.h>
#include <components/OmronE5Types.h>
#include <components/OmronE5.h>
#ifdef ENABLE_MODBUS_TCP
#include <modbus/ModbusTCP.h>
#include <modbus/ModbusTypes.h>
#endif
#include <LittleFS.h>
#include <components/RestServer.h>
#if defined(ENABLE_AMPERAGE_BUDGET_MANAGER)
void PHApp_onWarmupComplete(Component *owner)
{
PHApp *app = static_cast<PHApp *>(owner);
if (app)
{
bool wasInitializing = false;
#ifdef ENABLE_PROFILE_TEMPERATURE
for (int i = 0; i < PROFILE_TEMPERATURE_COUNT; i++)
{
if (app->tempProfiles[i] != nullptr && app->tempProfiles[i]->getCurrentStatus() == PlotStatus::INITIALIZING)
{
wasInitializing = true;
break;
}
}
#endif
if (wasInitializing)
{
// TODO: Implement any logic that should occur when the warmup is complete.
LS_INFO("PHApp received warmup complete notification from AmperageBudgetManager.");
#ifdef ENABLE_FEEDBACK_BUZZER
if (app->feedbackBuzzer_0)
{
app->feedbackBuzzer_0->setMode(FeedbackBuzzer::E_BuzzerMode::MODE_FAST_BLINK, 3000);
}
#endif
}
}
}
#endif
#define MB_R_APP_STATE_REG 9
#define MB_R_SYSTEM_CMD_PRINT_RESET 1
#define MB_R_SYSTEM_CMD_PRINT_REGS 2
#define MB_R_SYSTEM_CMD_PRINT_MEMORY 5
#define MB_R_SYSTEM_CMD_PRINT_VFD 6
#ifdef ENABLE_PROFILER
uint32_t PHApp::initialFreeHeap = 0;
uint64_t PHApp::initialCpuTicks = 0;
#endif
#ifndef LOG_LEVEL
#define LOG_LEVEL LOG_LEVEL_VERBOSE
#endif
///////////////////////////////////////////////////////////////////////////////////////////////////
//
// Network Servers
//
#if defined(ENABLE_WEBSERVER)
WiFiServer server(80);
#endif
#ifdef ENABLE_MODBUS_TCP
ModbusServerTCPasync mb;
#endif
///////////////////////////////////////////////////////////////////////////////////////////////////
//
// Omron E5
//
#undef ENABLE_TRUTH_COLLECTOR
///////////////////////////////////////////////////////////////////////////////////////////////////
//
// Factory : Instances
//
#define ADD_RELAY(relayNum, relayPin, relayKey, relayAddr) \
relay_##relayNum = new Relay(this, relayPin, relayKey, relayAddr); \
components.push_back(relay_##relayNum);
#ifdef ENABLE_SOLENOID_0
#define ADD_SOLENOID(solenoidNum, solenoidPin, solenoidKey, solenoidAddr) \
solenoid_##solenoidNum = new Solenoid(this, solenoidPin, solenoidKey, solenoidAddr); \
components.push_back(solenoid_##solenoidNum);
#endif
#define ADD_POT(potNum, potPin, potKey, potAddr, ...) \
pot_##potNum = new POT(this, potPin, potKey, potAddr, ##__VA_ARGS__); \
components.push_back(pot_##potNum);
#define ADD_POS3ANALOG(posNum, switchPin1, switchPin2, switchKey, switchAddr) \
pos3Analog_##posNum = new Pos3Analog(this, switchPin1, switchPin2, switchKey, switchAddr); \
components.push_back(pos3Analog_##posNum);
#ifdef ENABLE_PID
#define ADD_PID(pidNum, nameStr, doPin, csPin, clkPin, outPin, key) \
pidController_##pidNum = new PIDController(key, nameStr, doPin, csPin, clkPin, outPin); \
components.push_back(pidController_##pidNum);
#endif
Logger *g_logger = nullptr;
void PHApp::printRegisters()
{
L_VERBOSE(F("--- Entering PHApp::printRegisters ---"));
#if ENABLED(HAS_MODBUS_REGISTER_DESCRIPTIONS)
Log.setShowLevel(false);
Serial.print("| Name | ID | Address | RW | Function Code | Number Addresses |Register Description| \n");
Serial.print("|------|----------|----|----|----|----|-------|\n");
short size = components.size();
L_VERBOSE(F("PHApp::printRegisters - Processing %d components..."), size);
for (int i = 0; i < size; i++)
{
Component *component = components[i];
if (!component)
{
L_ERROR(F("PHApp::printRegisters - Found NULL component at index %d"), i);
continue;
}
L_VERBOSE(F("PHApp::printRegisters - Component %d: ID=%d, Name=%s"), i, component->id, component->name.c_str());
// if (!(component->nFlags & 1 << OBJECT_NET_CAPS::E_NCAPS_MODBUS)) // <-- Modbus flag check might be different now
// {
// continue;
// }
// Log.verbose("| %s | %d | %d | %s | %d | %d | %s |\n", // <-- Calls to removed ModbusGateway methods
// component->name.c_str(),
// component->id,
// component->getAddress(),
// component->getRegisterMode(),
// component->getFunctionCode(),
// component->getNumberAddresses(),
// component->getRegisterDescription().c_str());
Log.verbose("| %s | %d | - | - | - | - | - |\n", // <-- Simplified output
component->name.c_str(),
component->id);
}
Log.setShowLevel(true);
#endif
L_VERBOSE(F("--- Exiting PHApp::printRegisters ---"));
}
short PHApp::reset(short val0, short val1)
{
_state = APP_STATE::RESET;
_error = E_OK;
#if defined(ESP32) || defined(ESP8266) // Use ESP.restart() for ESP32 and ESP8266
ESP.restart();
#else
return E_NOT_IMPLEMENTED;
#endif
return E_OK;
}
short PHApp::list(short val0, short val1)
{
uchar s = components.size();
for (uchar i = 0; i < s; i++)
{
Component *component = components[i];
if (component)
{
L_VERBOSE("PHApp::list - %d | %s (ID: %d)", i, component->name.c_str(), component->id);
}
else
{
Log.warningln("PHApp::list - NULL component at index %d", i);
}
}
return E_OK;
}
short PHApp::setup()
{
_state = APP_STATE::RESET;
_error = E_OK;
#ifdef ENABLE_PROFILER
if (initialFreeHeap == 0 && initialCpuTicks == 0)
{
initialFreeHeap = ESP.getFreeHeap();
initialCpuTicks = esp_cpu_get_ccount();
}
#endif
#ifndef DISABLE_SERIAL_LOGGING
// Serial Setup
Serial.begin(SERIAL_BAUD_RATE);
while (!Serial && !Serial.available())
{
}
#endif
#ifdef ENABLE_LOGGER
logger_0 = new Logger(this, COMPONENT_KEY_LOGGER, MB_ADDR_LOGGER_0);
g_logger = logger_0;
components.push_back(logger_0);
#endif
#ifndef DISABLE_SERIAL_LOGGING
// Log Setup
#if defined(ENABLE_LOGGER)
#if defined(ENABLE_LOGGING_TARGET_PRINT)
if (logger_0)
{
Serial.begin(SERIAL_BAUD_RATE);
logger_0->addPrintTarget(&Serial);
}
#endif
Log.begin(LOG_LEVEL, logger_0);
#else
Log.begin(LOG_LEVEL, &Serial);
#endif
Log.setShowLevel(true);
#else
// Log Setup (without Serial)
Log.begin(LOG_LEVEL_WARNING, nullptr);
Log.setShowLevel(false);
#endif
L_INFO("PHApp::setup() started. Logger configured.");
// Application stuff
#ifdef ENABLE_RUNTIME_STATE
runtimeState = new RuntimeState(this, COMPONENT_KEY_RUNTIME_STATE);
components.push_back(runtimeState);
#endif
// Components
#ifdef ENABLE_SERIAL_BRIDGE
bridge = new Bridge(this);
components.push_back(bridge);
#endif
#ifndef DISABLE_SERIAL_LOGGING
com_serial = new SerialMessage(Serial, bridge);
components.push_back(com_serial);
#endif
// Network
short networkSetupResult = setupNetwork();
if (networkSetupResult != E_OK)
{
L_ERROR("Network setup failed with error code: %d", networkSetupResult);
}
#ifdef ENABLE_SETTINGS
appSettings = new Settings(this);
components.push_back(appSettings);
#endif
#ifdef ENABLE_LOGGER
#if defined(ENABLE_LOGGING_TARGET_WEBSOCKET) && defined(ENABLE_WEBSERVER) && defined(ENABLE_WEBSOCKET)
if (logger_0 && webServer)
{
logger_0->addWebSocketTarget(webServer);
L_INFO("WebSocket logging target added.");
}
#endif
#if defined(ENABLE_LOGGING_TARGET_FILE) && defined(ENABLE_LITTLEFS)
if (logger_0)
{
logger_0->addFileTarget();
L_INFO("File logging target added.");
}
#endif
#endif
// Components
#ifdef ENABLE_RELAYS
#ifdef AUX_RELAY_0
ADD_RELAY(0, AUX_RELAY_0, COMPONENT_KEY_RELAY_0, MB_ADDR_AUX_5);
#endif
#ifdef AUX_RELAY_1
ADD_RELAY(1, AUX_RELAY_1, COMPONENT_KEY_RELAY_1, MB_ADDR_AUX_6);
#endif
#endif
#ifdef ENABLE_POT0
ADD_POT(0, MB_ANALOG_0, COMPONENT_KEY_ANALOG_0, MB_ADDR_AUX_2, POTDampingAlgorithm::DAMPING_EMA, true);
#endif
#ifdef ENABLE_POT1
ADD_POT(1, MB_ANALOG_1, COMPONENT_KEY_ANALOG_1, MB_ADDR_AUX_3, POTDampingAlgorithm::DAMPING_EMA, true);
#endif
#if (defined(AUX_ANALOG_3POS_SWITCH_0) && (defined(AUX_ANALOG_3POS_SWITCH_1)))
ADD_POS3ANALOG(0, AUX_ANALOG_3POS_SWITCH_0, AUX_ANALOG_3POS_SWITCH_1, COMPONENT_KEY_MB_ANALOG_3POS_SWITCH_0, MB_ADDR_AUX_3);
#endif
#if (defined(MB_ANALOG_3POS_SWITCH_2) && (defined(MB_ANALOG_3POS_SWITCH_3)))
// ADD_POS3ANALOG(1, MB_ANALOG_3POS_SWITCH_2, MB_ANALOG_3POS_SWITCH_3, COMPONENT_KEY_MB_ANALOG_3POS_SWITCH_1, MB_R_SWITCH_1); // <-- Temporarily disable
#endif
#ifdef MB_GPIO_MB_MAP_7
// --- Define configuration for the MB_GPIO group ---
std::vector<GPIO_PinConfig> gpioConfigs;
gpioConfigs.reserve(2); // Reserve space for 2 elements
gpioConfigs.push_back(
GPIO_PinConfig(
E_GPIO_7, // pinNumber: The physical pin to manage
E_GPIO_TYPE_ANALOG_INPUT, // pinType: Treat as analog input
300, // startAddress: Modbus register address
E_FN_CODE::FN_READ_HOLD_REGISTER, // type: Map to a Holding Register
MB_ACCESS_READ_ONLY, // access: Allow Modbus read only
1000, // opIntervalMs: Update interval in milliseconds
"GPIO_6", // name: Custom name for this pin
"GPIO_Group" // group: Group name for this pin
));
gpioConfigs.push_back(
GPIO_PinConfig(
E_GPIO_15, // pinNumber: The physical pin to manage
E_GPIO_TYPE_ANALOG_INPUT, // pinType: Treat as analog input
301, // startAddress: Modbus register address
E_FN_CODE::FN_READ_HOLD_REGISTER, // type: Map to a Holding Register
MB_ACCESS_READ_ONLY, // access: Allow Modbus read only
1000, // opIntervalMs: Update interval in milliseconds
"GPIO_15", // name: Custom name for this pin
"GPIO_Group" // group: Group name for this pin
));
const short gpioGroupId = COMPONENT_KEY_GPIO_MAP; // Using defined key
gpio_0 = new MB_GPIO(this, gpioGroupId, gpioConfigs);
components.push_back(gpio_0);
#endif
#ifdef PIN_ANALOG_LEVEL_SWITCH_0
analogLevelSwitch_0 = new AnalogLevelSwitch(
this, // owner
PIN_ANALOG_LEVEL_SWITCH_0, // analogPin
ALS_0_NUM_LEVELS, // numLevels
ALS_0_ADC_STEP, // levelStep
ALS_0_ADC_OFFSET, // adcValueOffset
ID_ANALOG_LEVEL_SWITCH_0, // id
ALS_0_MB_ADDR // modbusAddress
);
if (analogLevelSwitch_0)
{
components.push_back(analogLevelSwitch_0);
L_INFO(F("AnalogLevelSwitch_0 initialized. Pin:%d, ID:%d, Levels:%d, Step:%d, Offset:%d, Smooth:%d(Fixed), Debounce:%d(Fixed), MB:%d"),
PIN_ANALOG_LEVEL_SWITCH_0, ID_ANALOG_LEVEL_SWITCH_0, ALS_0_NUM_LEVELS,
ALS_0_ADC_STEP, ALS_0_ADC_OFFSET,
ALS_SMOOTHING_SIZE,
ALS_DEBOUNCE_COUNT,
ALS_0_MB_ADDR);
}
else
{
L_ERROR(F("AnalogLevelSwitch_0 initialization failed."));
}
#endif
#ifdef ENABLE_STATUS
statusLight_0 = new StatusLight(this,
STATUS_WARNING_PIN,
COMPONENT_KEY_FEEDBACK_0,
MB_MONITORING_STATUS_FEEDBACK_0); // Keep original address for now, add to config-modbus.h later if needed
components.push_back(statusLight_0);
statusLight_1 = new StatusLight(this,
STATUS_ERROR_PIN,
COMPONENT_KEY_FEEDBACK_1,
MB_MONITORING_STATUS_FEEDBACK_1); // Keep original address for now
components.push_back(statusLight_1);
#else
statusLight_0 = NULL;
statusLight_1 = NULL;
#endif
L_INFO("PHApp::setup - Base App::setup() called.");
#ifdef PIN_LED_FEEDBACK_0
ledFeedback_0 = new LEDFeedback(
this, // owner
PIN_LED_FEEDBACK_0, // pin
LED_PIXEL_COUNT_0, // pixelCount
ID_LED_FEEDBACK_0, // id
LED_FEEDBACK_0_MB_ADDR // modbusAddress
);
if (ledFeedback_0)
{
components.push_back(ledFeedback_0);
L_INFO(F("LEDFeedback_0 initialized. Pin:%d, Count:%d, ID:%d, MB:%d"),
PIN_LED_FEEDBACK_0, LED_PIXEL_COUNT_0,
ID_LED_FEEDBACK_0, LED_FEEDBACK_0_MB_ADDR);
}
else
{
L_ERROR(F("LEDFeedback_0 initialization failed."));
}
#endif
#ifdef ENABLE_JOYSTICK
joystick_0 = new Joystick(
this, // owner
PIN_JOYSTICK_UP, // UP pin
PIN_JOYSTICK_DOWN, // DOWN pin
PIN_JOYSTICK_LEFT, // LEFT pin
PIN_JOYSTICK_RIGHT, // RIGHT pin
MB_ADDR_AUX_7 // modbusAddress
);
if (joystick_0)
{
components.push_back(joystick_0);
}
else
{
L_ERROR(F("Joystick_0 initialization failed."));
}
#endif
#ifdef PIN_AUX_1
pushButton_1 = new PushButton(this, PIN_AUX_1, COMPONENT_KEY_PUSH_BUTTON_0, MB_IREG_ANALOG_0);
components.push_back(pushButton_1);
#endif
#ifdef ENABLE_FEEDBACK_3C
feedback3C_0 = new Feedback3C(this,
GPIO_PIN_CH4,
GPIO_PIN_CH5,
GPIO_PIN_CH6,
COMPONENT_KEY_FEEDBACK_0,
MB_ADDR_FEEDBACK_0);
components.push_back(feedback3C_0);
#endif
#ifdef ENABLE_FEEDBACK_BUZZER
feedbackBuzzer_0 = new FeedbackBuzzer(this,
GPIO_PIN_CH3,
COMPONENT_KEY_FEEDBACK_1,
MB_ADDR_AUX_9);
components.push_back(feedbackBuzzer_0);
#endif
// Systems : Hydraulic Cylinder - Loadcell sensor - RS485
#ifdef ENABLE_SOLENOID_0
uint32_t solenoid0Addr = appSettings->get("SOLENOID_0_MB_ADDR", (uint32_t)MB_ADDR_SOLENOID_0);
ADD_SOLENOID(0, PIN_SOLENOID_0, COMPONENT_KEY_SOLENOID_0, solenoid0Addr);
#endif
#ifdef ENABLE_SOLENOID_1
uint32_t solenoid1Addr = appSettings->get("SOLENOID_1_MB_ADDR", (uint32_t)MB_ADDR_SOLENOID_1);
ADD_SOLENOID(1, PIN_SOLENOID_1, COMPONENT_KEY_SOLENOID_1, MB_ADDR_SOLENOID_1);
#endif
#ifdef ENABLE_LOADCELL_0
uint32_t slaveId0 = appSettings->get("LOADCELL_SLAVE_ID_0", (uint32_t)LOADCELL_SLAVE_ID_0);
loadCell_0 = new Loadcell(this, slaveId0, LOADCELL_READ_INTERVAL, COMPONENT_KEY_LOADCELL_0);
components.push_back(static_cast<RTU_Base *>(loadCell_0));
#endif
#ifdef ENABLE_LOADCELL_1
uint32_t slaveId1 = appSettings->get("LOADCELL_SLAVE_ID_1", (uint32_t)LOADCELL_SLAVE_ID_1);
loadCell_1 = new Loadcell(this, slaveId1, LOADCELL_READ_INTERVAL, COMPONENT_KEY_LOADCELL_1);
components.push_back(static_cast<RTU_Base *>(loadCell_1));
#endif
#ifdef ENABLE_PRESS_CYLINDER
pressCylinder_0 = new PressCylinder(this, COMPONENT_KEY_PRESS_CYLINDER_0, MB_ADDR_PRESS_CYLINDER_0, joystick_0, pushButton_1);
#ifdef ENABLE_LOADCELL_0
if (loadCell_0)
pressCylinder_0->addLoadcell(loadCell_0);
#endif
#ifdef ENABLE_LOADCELL_1
if (loadCell_1)
pressCylinder_0->addLoadcell(loadCell_1);
#endif
#ifdef ENABLE_SOLENOID_0
if (solenoid_0)
pressCylinder_0->addSolenoid(solenoid_0);
#endif
#ifdef ENABLE_SOLENOID_1
if (solenoid_1)
pressCylinder_0->addSolenoid(solenoid_1);
#endif
components.push_back(pressCylinder_0);
#endif
#ifdef ENABLE_OPERATOR_SWITCH
operatorSwitch_0 = new OperatorSwitch(this,
PIN_OPERATOR_SWITCH_STOP,
PIN_OPERATOR_SWITCH_CYCLE,
COMPONENT_KEY_OPERATOR_SWITCH,
MB_ADDR_AUX_8);
components.push_back(operatorSwitch_0);
#endif
#ifdef ENABLE_MODBUS_MIRROR
modbusMirror_0 = new ModbusMirror(this, COMPONENT_KEY_MODBUS_MIRROR);
components.push_back(modbusMirror_0);
#endif
#ifdef ENABLE_IFTTT
iftttWebhook = new IFTTTWebhook(this, COMPONENT_KEY_IFTTT);
components.push_back(iftttWebhook);
#endif
#ifdef ENABLE_NETWORK_VALUE_TEST
L_INFO("PHApp::setup - Initializing NetworkValueTest...");
networkValueTest = new NetworkValueTest(this, COMPONENT_KEY_TEST_NV, MB_ADDR_AUX_TEST_NV);
networkValueTest->owner = this;
components.push_back(networkValueTest);
#endif
#ifdef ENABLE_NETWORK_VALUE_TEST_PB
L_INFO("PHApp::setup - Initializing NetworkValueTestPB...");
networkValueTestPB = new NetworkValueTestPB(this, COMPONENT_KEY_TEST_NV_PB, MB_ADDR_AUX_TEST_NV + 10);
networkValueTestPB->owner = this;
components.push_back(networkValueTestPB);
#endif
// Motors
#ifdef ENABLE_SAKO_VFD
vfd_0 = new SAKO_VFD(this, MB_SAKO_VFD_SLAVE_ID, MB_SAKO_VFD_READ_INTERVAL);
components.push_back(vfd_0);
#endif
#ifdef ENABLE_DELTA_VFD
vfd_2 = new DELTA_VFD(this, MB_DELTA_VFD_SLAVE_ID, MB_DELTA_VFD_READ_INTERVAL);
components.push_back(vfd_2);
#endif
// Temperature
#ifdef ENABLE_PROFILE_TEMPERATURE
for (ushort i = 0; i < PROFILE_TEMPERATURE_COUNT; ++i)
{
// Assign unique ID: COMPONENT_KEY_PROFILE_START (910) + slot index
ushort profileComponentId = COMPONENT_KEY_PROFILE_START + i;
ushort baseAddr = MB_HREG_TEMP_PROFILE_BASE + (i * TEMP_PROFILE_REGISTER_COUNT);
tempProfiles[i] = new TemperatureProfile(this, i, profileComponentId, baseAddr);
tempProfiles[i]->setEventsDelegate(this);
components.push_back(tempProfiles[i]);
}
#endif
#ifdef ENABLE_PROFILE_PRESSURE
for (ushort i = 0; i < PROFILE_PRESSURE_COUNT; ++i)
{
ushort profileComponentId = COMPONENT_KEY_PRESSURE_PROFILE_START + i;
ushort baseAddr = MB_HREG_PRESSURE_PROFILE_BASE + (i * PRESSURE_PROFILE_REGISTER_COUNT);
pressureProfiles[i] = new PressureProfile(this, i, profileComponentId, baseAddr);
pressureProfiles[i]->setEventsDelegate(this);
components.push_back(pressureProfiles[i]);
}
#endif
#ifdef ENABLE_PROFILE_SIGNAL_PLOT
for (int i = 0; i < PROFILE_SIGNAL_PLOT_COUNT; i++)
{
ushort profileComponentId = COMPONENT_KEY_SIGNAL_PLOT_START + i;
ushort modbusAddress = MB_HREG_SIGNAL_PLOT_BASE + (i * SIGNAL_PLOT_REGISTER_COUNT);
signalPlots[i] = new SignalPlot(this, i, profileComponentId, modbusAddress);
signalPlots[i]->setEventsDelegate(this);
components.push_back(signalPlots[i]);
#ifdef ENABLE_MODBUS_TCP
if (modbusManager != nullptr)
{
signalPlots[i]->setModbusTCP(modbusManager);
}
else
{
L_ERROR("PHApp::setup - SignalPlot %d: modbusManager is nullptr", i);
}
#endif
}
#endif
#ifdef ENABLE_PID
const int8_t PID2_THERMO_DO = 19; // Example MISO pin
const int8_t PID2_THERMO_CS = 5; // Example Chip Select pin
const int8_t PID2_THERMO_CLK = 18; // Example SCK pin
const int8_t PID2_OUTPUT_PIN = 23; // Example PWM/Output pin
ADD_PID(0, "PID Temp Controller 2", PID2_THERMO_DO, PID2_THERMO_CS, PID2_THERMO_CLK, PID2_OUTPUT_PIN, COMPONENT_KEY_PID_2);
#endif
// RS485
#ifdef ENABLE_RS485
rs485 = new RS485(this);
components.push_back(rs485);
#endif
#ifdef ENABLE_AMPERAGE_BUDGET_MANAGER
pidManagerAmperage = new AmperageBudgetManager(this, MB_ADDR_AMPERAGE_BUDGET_BASE);
#if defined(ENABLE_OMRON_E5) && defined(ENABLE_PROFILE_TEMPERATURE)
pidManagerAmperage->setCanUseCallback(&PHApp_canUsePID);
pidManagerAmperage->setOnWarmupCompleteCallback(&PHApp_onWarmupComplete);
#endif
components.push_back(pidManagerAmperage);
#endif
// Systems : Extruder
#ifdef ENABLE_EXTRUDER
extruder_0 = new Extruder(this, vfd_0, nullptr, nullptr, nullptr);
components.push_back(extruder_0);
#endif
// Systems : Injector
#ifdef ENABLE_PLUNGER
plunger_0 = new Plunger(this, vfd_2, joystick_0, pot_0, pot_1);
components.push_back(plunger_0);
plunger_0->setEventsDelegate(this);
#endif
#ifdef ENABLE_INFLUXDB
influxDb_0 = new InfluxDB(this, COMPONENT_KEY_INFLUXDB);
components.push_back(influxDb_0);
#endif
registerComponents(bridge);
#ifdef ENABLE_BRIDGE
serial_register(bridge);
#endif
App::setup();
#ifdef ENABLE_SETTINGS
loadAppSettings();
#endif
init(0, 0);
onRun();
return E_OK;
}
short PHApp::onRun()
{
App::onRun();
#ifdef ENABLE_MODBUS_TCP
for (Component *comp : components)
{
if (comp && comp->hasNetCapability(OBJECT_NET_CAPS::E_NCAPS_MODBUS))
{
comp->mb_tcp_register(modbusManager);
}
}
#endif
load(0, 0);
#ifdef ENABLE_RELAYS
#ifdef AUX_RELAY_0
relay_0->setValue(1);
#endif
#endif
///////////////////////////////////////////////////////////////////////////////////////////////
//
// Post initialization
//
#ifdef ENABLE_WEBSERVER
registerRoutes(webServer);
#endif
#if ENABLED(ENABLE_AMPERAGE_BUDGET_MANAGER, ENABLE_OMRON_E5)
RTU_Base *const *devices = rs485->deviceManager.getDevices();
int numDevicesInManager = rs485->deviceManager.getMaxDevices();
for (int i = 0; i < numDevicesInManager; ++i)
{
if (devices[i] != nullptr)
{
Component *comp = devices[i];
if (comp == nullptr || comp->type != COMPONENT_TYPE::COMPONENT_TYPE_PID)
{
continue;
}
if (!pidManagerAmperage->addManagedDevice(static_cast<OmronE5 *>(comp)))
{
L_ERROR("Failed to add OmronE5 device to AmperageBudgetManager");
}
}
}
#endif
#if ENABLED(ENABLE_TEMPERATURE_PROFILES, ENABLE_OMRON_E5, ENABLE_MODBUS_TCP)
tempProfiles[0]->disable();
if (tempProfiles[0] && rs485)
{
RTU_Base *const *devices = rs485->deviceManager.getDevices();
int numDevicesInManager = rs485->deviceManager.getMaxDevices();
int targetRegisterIndex = 0; // Dedicated index for _targetRegisters
for (int i = 0; i < numDevicesInManager; i++)
{
Component *comp = devices[i];
if (comp == nullptr || comp->type != COMPONENT_TYPE::COMPONENT_TYPE_PID)
{
continue;
}
}
}
#endif
#ifdef ENABLE_NETWORK_VALUE_TEST
// networkValueTest->init();
#endif
#ifdef ENABLE_RUNTIME_STATE
if (runtimeState)
{
for (auto *component : components)
{
if (component && component->hasPersistence(E_PF_ENABLED))
{
runtimeState->addManagedComponent(component);
}
}
}
#endif
restoreState();
// setAllOmronComWrite(true, false);
return E_OK;
}
short PHApp::serial_register(Bridge *bridge)
{
/*
bridge->registerMemberFunction(COMPONENT_KEY_BASE::COMPONENT_KEY_APP, this, C_STR("list"), (ComponentFnPtr)&PHApp::list);
bridge->registerMemberFunction(COMPONENT_KEY_BASE::COMPONENT_KEY_APP, this, C_STR("reset"), (ComponentFnPtr)&PHApp::reset);
bridge->registerMemberFunction(COMPONENT_KEY_BASE::COMPONENT_KEY_APP, this, C_STR("printRegisters"), (ComponentFnPtr)&PHApp::printRegisters);
bridge->registerMemberFunction(COMPONENT_KEY_BASE::COMPONENT_KEY_APP, this, C_STR("load"), (ComponentFnPtr)&PHApp::load);
*/
return E_OK;
}
short PHApp::onWarning(short code)
{
return E_OK;
}
short PHApp::onError(short id, short code)
{
if (code == getLastError())
{
return code;
}
Log.error(F("* App:onError - component=%d code=%d" CR), id, code);
setLastError(code);
#ifdef ENABLE_STATUS
if (statusLight_0)
{
switch (id)
{
case COMPONENT_KEY_PLUNGER:
{
#if defined(ENABLE_PLUNGER)
case (short)PlungerState::IDLE:
{
statusLight_1->set(0, 0);
break;
}
case (short)PlungerState::JAMMED:
{
statusLight_1->set(1, 1);
break;
}
default:
{
statusLight_1->set(1, 0);
break;
}
}
#endif
}
}
}
#endif
return code;
}
short PHApp::onStop(short val)
{
return E_OK;
}
short PHApp::clearError()
{
setLastError(E_OK);
return E_OK;
}
short PHApp::loop()
{
App::loop();
if (millis() - _last_cycle_loop_ms >= LOOP_CYCLE_INTERVAL)
{
_last_cycle_loop_ms = millis();
loopCycle();
#ifdef ENABLE_PROFILE_TEMPERATURE
loopProfiles();
#endif
}
#ifdef ENABLE_RUNTIME_STATE
if (runtimeState && (millis() - _last_runtime_save_ms >= RUNTIME_STATE_SAVE_INTERVAL))
{
_last_runtime_save_ms = millis();
updateRuntimeState();
}
#endif
#ifdef ENABLE_INFLUXDB
testInfluxDB();
#endif
#ifdef ENABLE_WEBSERVER
loopWeb();
#endif
#ifdef ENABLE_MODBUS_TCP
loopModbus();
#endif
return E_OK;
}
short PHApp::loopWeb()
{
#if defined(ENABLE_WIFI) && defined(ENABLE_WEBSERVER)
if (webServer != nullptr)
{
webServer->loop();
}
#endif
return E_OK;
}
short PHApp::getAppState(short val)
{
return _state;
}
PHApp::PHApp() : App()
{
name = "PHApp";
webServer = nullptr;
pidController_0 = nullptr;
bridge = nullptr;
com_serial = nullptr;
pot_0 = nullptr;
pot_1 = nullptr;
pot_2 = nullptr;
statusLight_0 = nullptr;
statusLight_1 = nullptr;
relay_0 = nullptr;
relay_1 = nullptr;
relay_2 = nullptr;
relay_3 = nullptr;
relay_4 = nullptr;
relay_5 = nullptr;
relay_6 = nullptr;
relay_7 = nullptr;
pos3Analog_0 = nullptr;
pos3Analog_1 = nullptr;
modbusManager = nullptr;
logPrinter = nullptr;
rs485 = nullptr;
joystick_0 = nullptr;
networkValueTest = nullptr;
networkValueTestPB = nullptr;
feedback3C_0 = nullptr;
feedbackBuzzer_0 = nullptr;
operatorSwitch_0 = nullptr;
solenoid_0 = nullptr;
pressCylinder_0 = nullptr;
appSettings = nullptr;
#ifdef ENABLE_PROFILE_TEMPERATURE
// Initialize the array elements to nullptr
for (int i = 0; i < PROFILE_TEMPERATURE_COUNT; ++i)
{
tempProfiles[i] = nullptr;
}
#endif
#ifdef ENABLE_PROFILE_PRESSURE
for (int i = 0; i < PROFILE_PRESSURE_COUNT; ++i)
{
pressureProfiles[i] = nullptr;
}
#endif
#ifdef ENABLE_PROFILE_SIGNAL_PLOT
for (int i = 0; i < PROFILE_SIGNAL_PLOT_COUNT; ++i)
{
signalPlots[i] = nullptr;
}
#endif
#ifdef ENABLE_INFLUXDB
influxDb_0 = nullptr;
#endif
// WiFi settings are now initialized by WiFiNetworkSettings constructor
}
void PHApp::cleanupComponents()
{
L_INFO("PHApp::cleanupComponents - Cleaning up %d components...", components.size());
for (Component *comp : components)
{
delete comp;
}
components.clear(); // Clear the vector AFTER deleting objects
// Nullify pointers that were manually managed or outside the vector
bridge = nullptr;
com_serial = nullptr;
pot_0 = nullptr;
pot_1 = nullptr;
pot_2 = nullptr;
statusLight_0 = nullptr;
statusLight_1 = nullptr;
relay_0 = nullptr;
relay_1 = nullptr;
relay_2 = nullptr;
relay_3 = nullptr;
relay_4 = nullptr;
relay_5 = nullptr;
relay_6 = nullptr;
relay_7 = nullptr;
pos3Analog_0 = nullptr;
pos3Analog_1 = nullptr;
pidController_0 = nullptr;
modbusManager = nullptr;
joystick_0 = nullptr;
networkValueTest = nullptr;
networkValueTestPB = nullptr;
feedback3C_0 = nullptr;
feedbackBuzzer_0 = nullptr;
operatorSwitch_0 = nullptr;
solenoid_0 = nullptr;
pressCylinder_0 = nullptr;
appSettings = nullptr;
#ifdef ENABLE_PROFILE_TEMPERATURE
// Clean up temperature profiles (they were also added to components vector, so already deleted there)
// Ensure the pointers in the array are nulled
for (int i = 0; i < PROFILE_TEMPERATURE_COUNT; ++i)
{
tempProfiles[i] = nullptr;
}
#endif
#ifdef ENABLE_PROFILE_PRESSURE
for (int i = 0; i < PROFILE_PRESSURE_COUNT; ++i)
{
pressureProfiles[i] = nullptr;
}
#endif
#ifdef ENABLE_WEBSERVER
if (webServer)
{
delete webServer;
webServer = nullptr;
}
#endif
#ifdef ENABLE_RS485
rs485 = nullptr; // RS485 interface was in the vector, already deleted
#endif
#ifdef ENABLE_MODBUS_MIRROR
delete modbusMirror_0;
#endif
#ifdef ENABLE_INFLUXDB
delete influxDb_0;
#endif
#ifdef ENABLE_IFTTT
delete iftttWebhook;
#endif
L_INFO("PHApp::cleanupComponents - Cleanup complete.");
}
PHApp::~PHApp()
{
cleanupComponents();
}
short PHApp::setAppState(short newState)
{
if (_state != newState)
{
_state = (APP_STATE)newState;
}
return E_OK;
}
#ifdef ENABLE_SETTINGS
short PHApp::loadAppSettings()
{
if (!appSettings->load("/settings.json"))
{
L_WARN("Failed to load settings, using defaults.");
}
// Initialize App Settings
setAppWarmup(appSettings->get("ALWAYS_WARMUP", true), false);
setAppPidLag(appSettings->get("PID_LAG_COMPENSATION", true), false);
#if defined(ENABLE_OMRON_E5) && defined(ENABLE_RS485)
if (!rs485)
{
L_ERROR("RS485 not initialized, cannot apply settings to Omron devices.");
return E_NOT_INITIALIZED;
}
RTU_Base *const *devices = rs485->deviceManager.getDevices();
int numDevicesInManager = rs485->deviceManager.getMaxDevices();
for (int i = 0; i < numDevicesInManager; ++i)
{
RTU_Base *device = devices[i];
if (device == nullptr || device->type != COMPONENT_TYPE::COMPONENT_TYPE_PID)
{
continue;
}
bool foundInSettings = false;
bool shouldBeEnabled = false;
for (uint8_t p = 0; p < appSettings->partitionCount; ++p)
{
PartitionConfig &partition = appSettings->partitions[p];
for (uint8_t c = 0; c < partition.controllerCount; ++c)
{
ControllerConfig &controller = partition.controllers[c];
if (device->slaveId == controller.slaveId)
{
foundInSettings = true;
shouldBeEnabled = controller.enabled;
break;
}
}
if (foundInSettings)
{
break;
}
}
if (foundInSettings)
{
if (shouldBeEnabled)
{
device->enable();
}
else
{
device->disable();
}
}
else
{
device->disable();
}
}
#endif
return E_OK;
}
#endif
#ifdef ENABLE_PID
short PHApp::getPid2Register(short offset, short unused)
{
if (!pidController_0)
{
L_ERROR("Serial Command Error: PID Controller 2 not initialized.");
return E_INVALID_PARAMETER; // Use defined error code
}
if (offset < 0 || offset >= PID_2_REGISTER_COUNT)
{
L_ERROR("Serial Command Error: Invalid PID2 offset %d.", offset);
return E_INVALID_PARAMETER;
}
short address = MB_HREG_PID_2_BASE_ADDRESS + offset;
short value = pidController_0->mb_tcp_read(address);
Log.noticeln("PID2 Register Offset %d (Addr %d) Value: %d", offset, address, value);
// Optionally send value back over serial if needed by the protocol
return E_OK;
}
short PHApp::setPid2Register(short offset, short value)
{
if (!pidController_0)
{
L_ERROR("Serial Command Error: PID Controller 2 not initialized.");
return E_INVALID_PARAMETER; // Use defined error code
}
if (offset < 0 || offset >= PID_2_REGISTER_COUNT)
{
L_ERROR("Serial Command Error: Invalid PID2 offset %d.", offset);
return E_INVALID_PARAMETER;
}
short address = MB_HREG_PID_2_BASE_ADDRESS + offset;
short result = pidController_0->mb_tcp_write(address, value);
if (result == E_OK)
{
Log.noticeln("PID2 Register Offset %d (Addr %d) set to: %d", offset, address, value);
}
else
{
L_ERROR("PID2 Register Offset %d (Addr %d) failed to set to %d. Error: %d", offset, address, value, result);
}
return result;
}
#endif
short PHApp::onMessage(int id, E_CALLS verb, E_MessageFlags flags, void *user, Component *src)
{
#if defined(ENABLE_INFLUXDB) && defined(ENABLE_OMRON_E5)
// Intercept messages from Omron PID controllers to log their data.
if (verb == E_CALLS::EC_USER && src && src->type == COMPONENT_TYPE::COMPONENT_TYPE_PID)
{
// Log.infoln("PHApp::onMessage - OmronE5");
// We know it's an OmronE5, so we can safely cast it.
OmronE5 *omron = static_cast<OmronE5 *>(src);
uint16_t sp, pv;
// Ensure both SP and PV are valid before logging
if (omron->getSP(sp) && omron->getPV(pv))
{
Point p("pid_controller"); // Create a local Point
p.addTag("slaveId", String(omron->slaveId));
p.addField("sp", sp);
p.addField("pv", pv);
p.addField("isHeating", omron->isHeating());
influxDb_0->write(p);
}
else
{
Log.errorln("PHApp::onMessage - OmronE5 - SP or PV not valid");
}
}
#endif
#if ENABLED(ENABLE_RS485, ENABLE_WEBSERVER, ENABLE_WEBSOCKET)
if (verb == E_CALLS::EC_USER && user != nullptr && webServer != nullptr)
{
MB_UpdateData *update = static_cast<MB_UpdateData *>(user);
return webServer->onMessage(id, E_CALLS::EC_USER, E_MessageFlags::E_MF_NONE, user, src);
}
if (verb == E_CALLS::EC_PROTOBUF_UPDATE && user != nullptr)
{
PB_UpdateData *update = static_cast<PB_UpdateData *>(user);
return webServer->onMessage(id, E_CALLS::EC_PROTOBUF_UPDATE, E_MessageFlags::E_MF_NONE, user, src);
}
#endif
if (verb == E_CALLS::EC_DISPATCH && user != nullptr)
{
JsonDocument *doc = static_cast<JsonDocument *>(user);
this->broadcast(BROADCAST_ERROR_MESSAGE, *doc);
return E_OK;
}
return App::onMessage(id, verb, flags, user, src);
}
/**
* @brief Retrieves a component by its ID.
*
* @param id The ID of the component to retrieve.
* @return A pointer to the component with the specified ID, or nullptr if not found.
* @note Top-Level PHApp cant be part of components vector, so we need to handle it separately.
*/
Component *PHApp::byId(ushort id)
{
Component *comp = App::byId(id);
if (comp)
{
return comp;
}
else if (id == COMPONENT_KEY_APP)
{
return this;
}
return nullptr;
}
short PHApp::init(short arg1, short arg2)
{
#if ENABLED(ENABLE_AMPERAGE_BUDGET_MANAGER, ENABLE_OMRON_E5)
RTU_Base *const *devices = rs485->deviceManager.getDevices();
int numDevicesInManager = rs485->deviceManager.getMaxDevices();
for (int i = 0; i < numDevicesInManager; ++i)
{
if (devices[i] != nullptr)
{
Component *comp = devices[i];
if (comp == nullptr || comp->type != COMPONENT_TYPE::COMPONENT_TYPE_PID)
{
continue;
}
OmronE5 *omronE5 = static_cast<OmronE5 *>(comp);
omronE5->stop();
omronE5->setSP(0);
}
}
#endif
return E_OK;
}
#ifdef ENABLE_PROFILE_SIGNAL_PLOT
void PHApp::startSignalPlot(short slotId)
{
if (slotId >= 0 && slotId < PROFILE_SIGNAL_PLOT_COUNT && signalPlots[slotId] != nullptr)
{
L_INFO("PHApp: Starting SignalPlot in slot %d (triggered by TemperatureProfile).", slotId);
signalPlots[slotId]->start();
}
else
{
Log.warningln("PHApp: Could not start SignalPlot. Invalid slotId %d or plot not initialized.", slotId);
}
}
void PHApp::stopSignalPlot(short slotId)
{
if (slotId >= 0 && slotId < PROFILE_SIGNAL_PLOT_COUNT && signalPlots[slotId] != nullptr)
{
L_INFO("PHApp: Stopping SignalPlot in slot %d (triggered by TemperatureProfile).", slotId);
signalPlots[slotId]->stop();
}
else
{
Log.warningln("PHApp: Could not stop SignalPlot. Invalid slotId %d or plot not initialized.", slotId);
}
}
void PHApp::enableSignalPlot(short slotId, bool enable)
{
if (slotId >= 0 && slotId < PROFILE_SIGNAL_PLOT_COUNT && signalPlots[slotId] != nullptr)
{
if (enable)
{
L_INFO("PHApp: Enabling SignalPlot in slot %d (triggered by TemperatureProfile).", slotId);
signalPlots[slotId]->enable(enable);
}
else
{
L_INFO("PHApp: Disabling SignalPlot in slot %d (triggered by TemperatureProfile).", slotId);
signalPlots[slotId]->disable();
}
}
else
{
Log.warningln("PHApp: Could not enable/disable SignalPlot. Invalid slotId %d or plot not initialized.", slotId);
}
}
void PHApp::pauseSignalPlot(short slotId)
{
if (slotId >= 0 && slotId < PROFILE_SIGNAL_PLOT_COUNT && signalPlots[slotId] != nullptr)
{
L_INFO("PHApp: Pausing SignalPlot in slot %d (triggered by TemperatureProfile).", slotId);
signalPlots[slotId]->pause();
}
else
{
Log.warningln("PHApp: Could not pause SignalPlot. Invalid slotId %d or plot not initialized.", slotId);
}
}
void PHApp::resumeSignalPlot(short slotId)
{
if (slotId >= 0 && slotId < PROFILE_SIGNAL_PLOT_COUNT && signalPlots[slotId] != nullptr)
{
L_INFO("PHApp: Resuming SignalPlot in slot %d (triggered by TemperatureProfile).", slotId);
signalPlots[slotId]->resume();
}
else
{
Log.warningln("PHApp: Could not resume SignalPlot. Invalid slotId %d or plot not initialized.", slotId);
}
}
#endif // ENABLE_PROFILE_SIGNAL_PLOT
#ifdef ENABLE_INFLUXDB
void PHApp::testInfluxDB()
{
if (influxDb_0 && (millis() - _last_influx_test_ms >= 5000))
{
_last_influx_test_ms = millis();
Point p("test_data"); // Create a local Point
p.addTag("device", "ESP32-S3");
p.addTag("source", "1");
p.addField("random_value", random(100));
p.addField("random_value2", random(100));
p.addField("on-off-1", random(2));
p.addField("on-off-2", random(2));
if (influxDb_0->write(p) == E_OK)
{
Log.infoln("PHApp: Sent test data to InfluxDB.");
}
}
}
#endif
bool PHApp::isSlave() const
{
return _is_slave;
}
short PHApp::setSlave(bool value, bool sync)
{
_is_slave = value;
bool enabled = !value; // When slave=true, disable components; when slave=false, enable them
#if defined(ENABLE_RS485) && defined(ENABLE_OMRON_E5)
if (rs485)
{
RTU_Base *const *devices = rs485->deviceManager.getDevices();
int numDevices = rs485->deviceManager.getMaxDevices();
for (int i = 0; i < numDevices; ++i)
{
if (devices[i] != nullptr && devices[i]->type == COMPONENT_TYPE::COMPONENT_TYPE_PID)
{
OmronE5 *omron = static_cast<OmronE5 *>(devices[i]);
if (omron)
{
omron->enable(enabled);
}
}
}
}
#endif
#ifdef ENABLE_AMPERAGE_BUDGET_MANAGER
if (pidManagerAmperage)
{
pidManagerAmperage->enable(enabled);
}
#endif
#ifdef ENABLE_LOADCELL_0
if (loadCell_0)
{
loadCell_0->enable(enabled);
}
#endif
#ifdef ENABLE_LOADCELL_1
if (loadCell_1)
{
loadCell_1->enable(enabled);
}
#endif
#ifdef ENABLE_PROFILE_TEMPERATURE
for (int i = 0; i < PROFILE_TEMPERATURE_COUNT; ++i)
{
if (tempProfiles[i] != nullptr)
{
tempProfiles[i]->enable(enabled);
}
}
#endif
if (sync)
{
updateRuntimeState();
}
return E_OK;
}
bool PHApp::getAllOmronStop() const
{
return _all_omron_stop;
}
short PHApp::setAllOmronStop(bool value, bool sync)
{
_all_omron_stop = value;
#if defined(ENABLE_RS485) && defined(ENABLE_OMRON_E5)
if (!rs485)
{
L_INFO("PHApp: No RS485 found");
return E_OK;
}
RTU_Base *const *devices = rs485->deviceManager.getDevices();
int numDevices = rs485->deviceManager.getMaxDevices();
for (int i = 0; i < numDevices; ++i)
{
if (devices[i] != nullptr && devices[i]->type == COMPONENT_TYPE::COMPONENT_TYPE_PID)
{
OmronE5 *omron = static_cast<OmronE5 *>(devices[i]);
if (omron && omron->enabled())
{
if (value)
{
omron->stop();
}
else
{
omron->run();
}
}
}
}
updateRuntimeState();
#endif
return E_OK;
}
bool PHApp::getAllOmronComWrite() const
{
return _all_omron_com_write;
}
short PHApp::setAllOmronComWrite(bool value, bool sync)
{
_all_omron_com_write = value;
#if defined(ENABLE_RS485) && defined(ENABLE_OMRON_E5)
if (!rs485)
{
L_INFO("PHApp: No RS485 found");
return E_OK;
}
RTU_Base *const *devices = rs485->deviceManager.getDevices();
int numDevices = rs485->deviceManager.getMaxDevices();
for (int i = 0; i < numDevices; ++i)
{
if (devices[i] != nullptr && devices[i]->type == COMPONENT_TYPE::COMPONENT_TYPE_PID)
{
OmronE5 *omron = static_cast<OmronE5 *>(devices[i]);
if (omron && omron->enabled())
{
omron->setCommsWriting(value);
}
}
}
#endif
if (sync)
{
updateRuntimeState();
}
return E_OK;
}
short PHApp::setAppWarmup(bool value, bool sync)
{
_app_warmup = value;
if (appSettings)
{
appSettings->set("heating", "ALWAYS_WARMUP", value);
appSettings->save();
}
if (sync)
{
updateRuntimeState();
}
return E_OK;
}
short PHApp::setAppPidLag(bool value, bool sync)
{
_app_pid_lag = value;
if (appSettings)
{
appSettings->set("heating", "PID_LAG_COMPENSATION", value);
appSettings->save();
}
if (sync)
{
updateRuntimeState();
}
return E_OK;
}
void app_main()
{
// Arduino will still call setup()/loop()
}
Reference in New Issue View Git Blame Copy Permalink