218 lines
9.4 KiB
C++
218 lines
9.4 KiB
C++
// feature_di_component_demo.cpp -------------------------------------------
|
||
// Build the "lean" variant : g++ -std=c++20 -O2 -DDEMO_MAIN feature_di_component_demo.cpp -o demo
|
||
// Build the "Modbus" variant: g++ -std=c++20 -O2 -DDEMO_MAIN -DENABLE_MODBUS feature_di_component_demo.cpp -o demo_net
|
||
// @link ://chatgpt.com/share/6803c6b7-0468-8001-857f-352a31c8c9bd
|
||
// ───────────────────────────────────────────────────────────────────────────
|
||
|
||
#include <Arduino.h> // Added for Serial
|
||
#include <cstdint>
|
||
#include <cstddef>
|
||
#include <array>
|
||
// #include <iostream> // Replaced by Arduino.h
|
||
#include <type_traits>
|
||
#include <string_view> // For info() return type example
|
||
#include <cstring> // For strcmp
|
||
|
||
/*──────────────────── 1. Tiny utility -----------------------------------*/
|
||
struct RegisterMap {
|
||
const uint16_t* data;
|
||
std::size_t size;
|
||
};
|
||
|
||
/*──────────────────── 2. "Feature" concept (any module that has setup/loop/info)*/
|
||
// Renamed and updated SFINAE check
|
||
template<typename, typename = std::void_t<>>
|
||
struct is_valid_feature : std::false_type {};
|
||
|
||
template<typename F>
|
||
struct is_valid_feature<F, std::void_t<
|
||
decltype(std::declval<F&>().setup()),
|
||
decltype(std::declval<F&>().loop()),
|
||
decltype(std::declval<const F&>().info()) // Added const info() check
|
||
>> : std::true_type {};
|
||
|
||
// Updated helper function
|
||
template<typename F> constexpr bool is_valid_feature_func() { return is_valid_feature<F>::value; }
|
||
|
||
|
||
/*──────────────────── 3. Individual feature packs -----------------------*/
|
||
// 3a. Core sensor logic ────────────────────────────────────────────────
|
||
struct CoreFeature {
|
||
static constexpr bool has_network = false;
|
||
|
||
void setup() { Serial.println(F("[Core] setup")); } // Use Serial
|
||
void loop () { /*Serial.println(F("[Core] loop"));*/ } // Commented out for less noise
|
||
// Added info method
|
||
void info() const { Serial.println(F("[Core] Info: Basic temperature sensing.")); } // Use Serial
|
||
|
||
float readCelsius() const { return 25.0f; }
|
||
};
|
||
|
||
// 3b. Optional Modbus/Network feature ──────────────────────────────────
|
||
struct ModbusFeature {
|
||
static constexpr bool has_network = true;
|
||
|
||
std::array<uint16_t,2> regs{ 250 /*25 °C×10*/, 0 };
|
||
|
||
void setup() { Serial.println(F("[Modbus] setup")); } // Use Serial
|
||
void loop () { /*Serial.println(F("[Modbus] loop"));*/ } // Commented out for less noise
|
||
// Added info method
|
||
void info() const { // Use Serial
|
||
Serial.print(F("[Modbus] Info: Modbus TCP/IP enabled. Address: "));
|
||
Serial.println(deviceAddress());
|
||
}
|
||
|
||
|
||
RegisterMap registerMapping() const { return { regs.data(), regs.size() }; }
|
||
uint16_t deviceAddress() const { return 42; }
|
||
|
||
void onRegisterWrite(uint16_t r, uint16_t v) {
|
||
if (r < regs.size()) regs[r] = v;
|
||
}
|
||
};
|
||
|
||
// 3c. Default Logger feature ─────────────────────────────────────────────
|
||
struct LoggerFeature {
|
||
static constexpr bool has_network = true; // Assuming logger might send logs over network
|
||
void setup() { Serial.println(F("[Logger] setup")); } // Use Serial
|
||
void loop () { /*Serial.println(F("[Logger] loop"));*/ } // Commented out for less noise
|
||
// Added info method
|
||
void info() const { Serial.println(F("[Logger] Info: Basic console logging active.")); } // Use Serial
|
||
};
|
||
|
||
|
||
/*──────────────────── 4. Generic "Device" aggregator ───────────────────*/
|
||
// Use static_assert with the updated SFINAE check
|
||
// Inherit LoggerFeature by default
|
||
template<typename... Fs>
|
||
class Device : public LoggerFeature, public Fs...
|
||
{
|
||
// Ensure the default and all *additional* base classes Fs satisfy the requirements
|
||
static_assert(is_valid_feature_func<LoggerFeature>(), "Default LoggerFeature must implement setup(), loop(), and info()");
|
||
// Use C++17 fold expression within the static_assert for additional features
|
||
static_assert(sizeof...(Fs) == 0 || (is_valid_feature_func<Fs>() && ...), "All additional features must implement setup(), loop(), and info()");
|
||
|
||
|
||
public:
|
||
void setup() {
|
||
LoggerFeature::setup(); // Explicitly call setup for the default feature
|
||
if constexpr (sizeof...(Fs) > 0) { // Check if there are other features
|
||
(Fs::setup(), ...); // Call setup for the rest using fold-expression
|
||
}
|
||
}
|
||
|
||
void loop () {
|
||
LoggerFeature::loop(); // Explicitly call loop for the default feature
|
||
if constexpr (sizeof...(Fs) > 0) {
|
||
(Fs::loop (), ...); // Call loop for the rest
|
||
}
|
||
}
|
||
|
||
// Added aggregated info method
|
||
void info() const {
|
||
// Call info() for LoggerFeature and all Fs... using a fold expression
|
||
(LoggerFeature::info(), (Fs::info(), ...));
|
||
}
|
||
|
||
// Include LoggerFeature's network status in the calculation
|
||
static constexpr bool has_network = LoggerFeature::has_network || (false || ... || Fs::has_network);
|
||
};
|
||
|
||
/*──────────────────── 5. Choose the feature bundle (application layer) ───*/
|
||
// LoggerFeature is now implicitly included by Device
|
||
#ifdef ENABLE_MODBUS
|
||
using TemperatureSensor = Device<CoreFeature, ModbusFeature>;
|
||
#else
|
||
using TemperatureSensor = Device<CoreFeature>;
|
||
#endif
|
||
|
||
/*──────────────────── Arduino Entry Points -------------------------------*/
|
||
// Instantiate the device globally
|
||
TemperatureSensor device;
|
||
|
||
// Buffer for serial commands
|
||
#define SERIAL_CMD_BUFFER_SIZE 64
|
||
char serialCmdBuffer[SERIAL_CMD_BUFFER_SIZE];
|
||
uint8_t serialCmdBufferIdx = 0;
|
||
|
||
// Helper function to print commands
|
||
void printHelp() {
|
||
Serial.println(F("--- Serial Commands ---"));
|
||
Serial.println(F("1 - Show device info"));
|
||
Serial.println(F("? - Print this help message"));
|
||
}
|
||
|
||
void setup() {
|
||
// Initialize Serial for logging, if needed (optional)
|
||
Serial.begin(115200);
|
||
// Wait for serial port to connect (needed for native USB)
|
||
// On some boards, this delay is needed to allow the Serial Monitor to connect
|
||
// On others (like ESP32), Serial begins immediately. Adjust if needed.
|
||
delay(1000);
|
||
while (!Serial && millis() < 3000); // Wait up to 3 seconds
|
||
|
||
Serial.println(F("\n--- Serial Interface Ready ---"));
|
||
printHelp();
|
||
|
||
// <<< Hypothetical serial connection point >>>
|
||
Serial.println(F("--- Device Info ---"));
|
||
device.info(); // Call the aggregated info method
|
||
Serial.println(F("--- Device Setup ---"));
|
||
device.setup(); // Call the aggregated setup
|
||
Serial.println(F("--- Setup Complete ---"));
|
||
}
|
||
|
||
void loop() {
|
||
device.loop(); // Call the aggregated loop
|
||
|
||
// --- Handle Serial Input ---
|
||
while (Serial.available() > 0) {
|
||
char receivedChar = Serial.read();
|
||
|
||
// Handle backspace
|
||
if (receivedChar == '\b' || receivedChar == 127) {
|
||
if (serialCmdBufferIdx > 0) {
|
||
serialCmdBufferIdx--;
|
||
Serial.print("\b \b"); // Move cursor back, print space, move back again
|
||
}
|
||
continue; // Continue to next character
|
||
}
|
||
|
||
// Echo character back (optional, good for interactive use)
|
||
Serial.print(receivedChar);
|
||
|
||
// Process command on newline or carriage return
|
||
if (receivedChar == '\n' || receivedChar == '\r') {
|
||
serialCmdBuffer[serialCmdBufferIdx] = '\0'; // Null-terminate the string
|
||
Serial.println(); // Move to next line after command received
|
||
|
||
if (serialCmdBufferIdx > 0) { // Process if buffer is not empty
|
||
// --- Process Commands ---
|
||
if (strcmp(serialCmdBuffer, "1") == 0) {
|
||
Serial.println(F("--- Device Info ---"));
|
||
device.info();
|
||
} else if (strcmp(serialCmdBuffer, "?") == 0) {
|
||
printHelp();
|
||
} else {
|
||
Serial.print(F("Unknown command: '"));
|
||
Serial.print(serialCmdBuffer);
|
||
Serial.println(F("'"));
|
||
printHelp(); // Show help on unknown command
|
||
}
|
||
}
|
||
// Reset buffer index for the next command
|
||
serialCmdBufferIdx = 0;
|
||
serialCmdBuffer[0] = '\0';
|
||
} else if (serialCmdBufferIdx < SERIAL_CMD_BUFFER_SIZE - 1) {
|
||
// Add character to buffer if it's not newline/CR and buffer has space
|
||
serialCmdBuffer[serialCmdBufferIdx++] = receivedChar;
|
||
}
|
||
// Ignore characters if buffer is full until newline/CR is received
|
||
}
|
||
|
||
|
||
// Add delay or other logic if needed for stability
|
||
// delay(10);
|
||
}
|
||
// ───────────────────────────────────────────────────────────────────────────
|