Refactor SmartSpin_Parameters with generic Parameter template and eliminate all old getter/setter methods

CHANGELOG.md

@@ -13,6 +13,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Hardware
 
+
+## [25.9.8]
+
+### Added
+
+### Changed
+
+### Hardware
+
 ## [25.8.26]
 
 ### Added

dependencies.lock

@@ -96,6 +96,6 @@ direct_dependencies:
 - espressif/network_provisioning
 - idf
 - joltwallet/littlefs
-manifest_hash: e871ea1e1aff9421b8e57e1c5a4db8daeef71b071a2a17f239e5feebc4acdfc3
+manifest_hash: e9919b5b28bb7bb038864af176d8e81936400eff14ef44258dd5186bdc427ec2
 target: esp32
 version: 2.0.0

include/SmartSpin_parameters.h

@@ -14,9 +14,35 @@
 #endif
 
 #include "settings.h"
+#include <type_traits>
 
 #define CONFIG_LOG_TAG "Config"
 
+// Generic parameter class for simple set/get operations
+template<typename T>
+class Parameter {
+ private:
+  T value;
+
+ public:
+  void set(const T& val) { value = val; }
+  T get() const { return value; }
+
+  // Overload for String types to return const char*
+  template<typename U = T>
+  typename std::enable_if<std::is_same<U, String>::value, const char*>::type
+  getCStr() const { return value.c_str(); }
+
+  Parameter() : value{} {}
+  Parameter(const T& defaultValue) : value(defaultValue) {}
+
+  // Assignment operator for convenience
+  Parameter& operator=(const T& val) { value = val; return *this; }
+
+  // Conversion operator for convenience  
+  operator T() const { return value; }
+};
+
 class Measurement {
  private:
   bool simulate;
@@ -55,16 +81,16 @@ class Measurement {
 
 class RuntimeParameters {
  private:
-  double targetIncline = 0.0;
-  float simulatedSpeed = 0.0;
-  uint8_t FTMSMode     = 0x00;
-  int shifterPosition  = 0;
-  bool homed           = false;
-  int32_t minStep      = -DEFAULT_STEPPER_TRAVEL;
-  int32_t maxStep      = DEFAULT_STEPPER_TRAVEL;
-  int minResistance    = -DEFAULT_RESISTANCE_RANGE;
-  int maxResistance    = DEFAULT_RESISTANCE_RANGE;
-  bool simTargetWatts  = false;
+  Parameter<float> targetIncline;
+  Parameter<float> simulatedSpeed;
+  Parameter<uint8_t> FTMSMode;
+  Parameter<int> shifterPosition;
+  Parameter<bool> homed;
+  Parameter<int32_t> minStep;
+  Parameter<int32_t> maxStep;
+  Parameter<int> minResistance;
+  Parameter<int> maxResistance;
+  Parameter<bool> simTargetWatts;
 
  public:
   Measurement watts;
@@ -74,146 +100,160 @@ class RuntimeParameters {
   Measurement cad;
   Measurement resistance;
 
-  void setTargetIncline(float inc) { targetIncline = inc; }
-  float getTargetIncline() { return targetIncline; }
+  // Constructor to set default values
+  RuntimeParameters() {
+    targetIncline.set(0.0);
+    simulatedSpeed.set(0.0);
+    FTMSMode.set(0x00);
+    shifterPosition.set(0);
+    homed.set(false);
+    minStep.set(-DEFAULT_STEPPER_TRAVEL);
+    maxStep.set(DEFAULT_STEPPER_TRAVEL);
+    minResistance.set(-DEFAULT_RESISTANCE_RANGE);
+    maxResistance.set(DEFAULT_RESISTANCE_RANGE);
+    simTargetWatts.set(false);
+  }
+
+  void setTargetIncline(float inc) { targetIncline.set(inc); }
+  float getTargetIncline() { return targetIncline.get(); }
 
-  void setSimulatedSpeed(float spd) { simulatedSpeed = spd; }
-  float getSimulatedSpeed() { return simulatedSpeed; }
+  void setSimulatedSpeed(float spd) { simulatedSpeed.set(spd); }
+  float getSimulatedSpeed() { return simulatedSpeed.get(); }
 
-  void setFTMSMode(uint8_t mde) { FTMSMode = mde; }
-  uint8_t getFTMSMode() { return FTMSMode; }
+  void setFTMSMode(uint8_t mde) { FTMSMode.set(mde); }
+  uint8_t getFTMSMode() { return FTMSMode.get(); }
 
-  void setShifterPosition(int sp) { shifterPosition = sp; }
-  int getShifterPosition() { return shifterPosition; }
+  void setShifterPosition(int sp) { shifterPosition.set(sp); }
+  int getShifterPosition() { return shifterPosition.get(); }
 
-  void setHomed(bool hmd) { homed = hmd; }
-  int getHomed() { return homed; }
+  void setHomed(bool hmd) { homed.set(hmd); }
+  bool getHomed() { return homed.get(); }
 
-  void setMinStep(int32_t ms) { ms != INT32_MIN ? minStep = ms : minStep = -DEFAULT_STEPPER_TRAVEL; }
-  int32_t getMinStep() { return minStep; }
+  void setMinStep(int32_t ms) { ms != INT32_MIN ? minStep.set(ms) : minStep.set(-DEFAULT_STEPPER_TRAVEL); }
+  int32_t getMinStep() { return minStep.get(); }
 
-  void setMaxStep(int32_t ms) { ms != INT32_MIN ? maxStep = ms : maxStep = DEFAULT_STEPPER_TRAVEL; }
-  int32_t getMaxStep() { return maxStep; }
+  void setMaxStep(int32_t ms) { ms != INT32_MIN ? maxStep.set(ms) : maxStep.set(DEFAULT_STEPPER_TRAVEL); }
+  int32_t getMaxStep() { return maxStep.get(); }
 
-  void setSimTargetWatts(int tgt) { simTargetWatts = tgt; }
-  bool getSimTargetWatts() { return simTargetWatts; }
+  void setSimTargetWatts(int tgt) { simTargetWatts.set(tgt); }
+  bool getSimTargetWatts() { return simTargetWatts.get(); }
 
-  void setMinResistance(int min) { minResistance = min; }
-  int getMinResistance() { return minResistance; }
+  void setMinResistance(int min) { minResistance.set(min); }
+  int getMinResistance() { return minResistance.get(); }
 
-  void setMaxResistance(int max) { maxResistance = max; }
-  int getMaxResistance() { return maxResistance; }
+  void setMaxResistance(int max) { maxResistance.set(max); }
+  int getMaxResistance() { return maxResistance.get(); }
 
   String returnJSON();
 };
 
 class userParameters {
  private:
-  String firmwareUpdateURL;
-  String deviceName;
-  int shiftStep;
-  bool stealthChop;
-  float inclineMultiplier;
-  float powerCorrectionFactor;
-  float ERGSensitivity;
-  bool autoUpdate;
-  int stepperPower;
-  int maxWatts;
-  int minWatts;
-  int stepperSpeed;
-  bool stepperDir;
-  bool shifterDir;
-  bool pTab4Pwr              = false;
-  bool udpLogEnabled         = false;
-  int32_t hMin               = INT32_MIN;
-  int32_t hMax               = INT32_MIN;
-  bool FTMSControlPointWrite = false;
-  int homingSensitivity      = DEFAULT_HOMING_SENSITIVITY;  // Use default from settings.h
-  String ssid;
-  String password;
-  String connectedPowerMeter   = CONNECTED_POWER_METER;
-  String connectedHeartMonitor = CONNECTED_HEART_MONITOR;
-  String connectedRemote       = CONNECTED_REMOTE;
-  String foundDevices          = "";
+  Parameter<String> firmwareUpdateURL;
+  Parameter<String> deviceName;
+  Parameter<int> shiftStep;
+  Parameter<bool> stealthChop;
+  Parameter<float> inclineMultiplier;
+  Parameter<float> powerCorrectionFactor;
+  Parameter<float> ERGSensitivity;
+  Parameter<bool> autoUpdate;
+  Parameter<int> stepperPower;
+  Parameter<int> maxWatts;
+  Parameter<int> minWatts;
+  Parameter<int> stepperSpeed;
+  Parameter<bool> stepperDir;
+  Parameter<bool> shifterDir;
+  Parameter<bool> pTab4Pwr;
+  Parameter<bool> udpLogEnabled;
+  Parameter<int32_t> hMin;
+  Parameter<int32_t> hMax;
+  Parameter<bool> FTMSControlPointWrite;
+  Parameter<int> homingSensitivity;
+  Parameter<String> ssid;
+  Parameter<String> password;
+  Parameter<String> connectedPowerMeter;
+  Parameter<String> connectedHeartMonitor;
+  Parameter<String> connectedRemote;
+  Parameter<String> foundDevices;
 
  public:
-  void setFirmwareUpdateURL(String fURL) { firmwareUpdateURL = fURL; }
-  const char* getFirmwareUpdateURL() { return firmwareUpdateURL.c_str(); }
+  void setFirmwareUpdateURL(String fURL) { firmwareUpdateURL.set(fURL); }
+  const char* getFirmwareUpdateURL() { return firmwareUpdateURL.getCStr(); }
 
-  void setDeviceName(String dvn) { deviceName = dvn; }
-  const char* getDeviceName() { return deviceName.c_str(); }
+  void setDeviceName(String dvn) { deviceName.set(dvn); }
+  const char* getDeviceName() { return deviceName.getCStr(); }
 
-  void setShiftStep(int ss) { shiftStep = ss; }
-  int getShiftStep() { return shiftStep; }
+  void setShiftStep(int ss) { shiftStep.set(ss); }
+  int getShiftStep() { return shiftStep.get(); }
 
-  void setStealthChop(bool sc) { stealthChop = sc; }
-  bool getStealthChop() { return stealthChop; }
+  void setStealthChop(bool sc) { stealthChop.set(sc); }
+  bool getStealthChop() { return stealthChop.get(); }
 
-  void setFTMSControlPointWrite(bool cpw) { FTMSControlPointWrite = cpw; }
-  bool getFTMSControlPointWrite() { return FTMSControlPointWrite; }
+  void setFTMSControlPointWrite(bool cpw) { FTMSControlPointWrite.set(cpw); }
+  bool getFTMSControlPointWrite() { return FTMSControlPointWrite.get(); }
 
-  void setInclineMultiplier(float im) { inclineMultiplier = im; }
-  float getInclineMultiplier() { return inclineMultiplier; }
+  void setInclineMultiplier(float im) { inclineMultiplier.set(im); }
+  float getInclineMultiplier() { return inclineMultiplier.get(); }
 
-  void setPowerCorrectionFactor(float pcf) { powerCorrectionFactor = pcf; }
-  float getPowerCorrectionFactor() { return powerCorrectionFactor; }
+  void setPowerCorrectionFactor(float pcf) { powerCorrectionFactor.set(pcf); }
+  float getPowerCorrectionFactor() { return powerCorrectionFactor.get(); }
 
-  float getERGSensitivity() { return ERGSensitivity; }
-  void setERGSensitivity(float ergS) { ERGSensitivity = ergS; }
+  float getERGSensitivity() { return ERGSensitivity.get(); }
+  void setERGSensitivity(float ergS) { ERGSensitivity.set(ergS); }
 
-  void setAutoUpdate(bool atd) { autoUpdate = atd; }
-  bool getAutoUpdate() { return autoUpdate; }
+  void setAutoUpdate(bool atd) { autoUpdate.set(atd); }
+  bool getAutoUpdate() { return autoUpdate.get(); }
 
-  void setSsid(String sid) { ssid = sid; }
-  const char* getSsid() { return ssid.c_str(); }
+  void setSsid(String sid) { ssid.set(sid); }
+  const char* getSsid() { return ssid.getCStr(); }
 
-  void setPassword(String pwd) { password = pwd; }
-  const char* getPassword() { return password.c_str(); }
+  void setPassword(String pwd) { password.set(pwd); }
+  const char* getPassword() { return password.getCStr(); }
 
-  void setConnectedPowerMeter(String cpm) { connectedPowerMeter = cpm; }
-  const char* getConnectedPowerMeter() { return connectedPowerMeter.c_str(); }
+  void setConnectedPowerMeter(String cpm) { connectedPowerMeter.set(cpm); }
+  const char* getConnectedPowerMeter() { return connectedPowerMeter.getCStr(); }
 
-  void setConnectedHeartMonitor(String cHr) { connectedHeartMonitor = cHr; }
-  const char* getConnectedHeartMonitor() { return connectedHeartMonitor.c_str(); }
+  void setConnectedHeartMonitor(String cHr) { connectedHeartMonitor.set(cHr); }
+  const char* getConnectedHeartMonitor() { return connectedHeartMonitor.getCStr(); }
 
-  void setConnectedRemote(String cRemote) { connectedRemote = cRemote; }
-  const char* getConnectedRemote() { return connectedRemote.c_str(); }
+  void setConnectedRemote(String cRemote) { connectedRemote.set(cRemote); }
+  const char* getConnectedRemote() { return connectedRemote.getCStr(); }
 
-  void setStepperPower(int sp) { stepperPower = sp; }
-  int getStepperPower() { return stepperPower; }
+  void setStepperPower(int sp) { stepperPower.set(sp); }
+  int getStepperPower() { return stepperPower.get(); }
 
-  void setStepperSpeed(int sp) { stepperSpeed = sp; }
-  int getStepperSpeed() { return stepperSpeed; }
+  void setStepperSpeed(int sp) { stepperSpeed.set(sp); }
+  int getStepperSpeed() { return stepperSpeed.get(); }
 
-  void setMaxWatts(int maxW) { maxWatts = maxW; }
-  int getMaxWatts() { return maxWatts; }
+  void setMaxWatts(int maxW) { maxWatts.set(maxW); }
+  int getMaxWatts() { return maxWatts.get(); }
 
-  void setMinWatts(int minW) { minWatts = minW; }
-  int getMinWatts() { return minWatts; }
+  void setMinWatts(int minW) { minWatts.set(minW); }
+  int getMinWatts() { return minWatts.get(); }
 
-  void setStepperDir(bool sd) { stepperDir = sd; }
-  bool getStepperDir() { return stepperDir; }
+  void setStepperDir(bool sd) { stepperDir.set(sd); }
+  bool getStepperDir() { return stepperDir.get(); }
 
-  void setShifterDir(bool shd) { shifterDir = shd; }
-  bool getShifterDir() { return shifterDir; }
+  void setShifterDir(bool shd) { shifterDir.set(shd); }
+  bool getShifterDir() { return shifterDir.get(); }
 
-  void setUdpLogEnabled(bool enabled) { udpLogEnabled = enabled; }
-  bool getUdpLogEnabled() { return udpLogEnabled; }
+  void setUdpLogEnabled(bool enabled) { udpLogEnabled.set(enabled); }
+  bool getUdpLogEnabled() { return udpLogEnabled.get(); }
 
-  void setPTab4Pwr(bool pTab) { pTab4Pwr = pTab; }
-  bool getPTab4Pwr() { return pTab4Pwr; }
+  void setPTab4Pwr(bool pTab) { pTab4Pwr.set(pTab); }
+  bool getPTab4Pwr() { return pTab4Pwr.get(); }
 
-  void setFoundDevices(String fdv) { foundDevices = fdv; }
-  const char* getFoundDevices() { return foundDevices.c_str(); }
+  void setFoundDevices(String fdv) { foundDevices.set(fdv); }
+  const char* getFoundDevices() { return foundDevices.getCStr(); }
 
-  void setHMin(int32_t min) { hMin = min; }
-  int32_t getHMin() { return hMin; }
+  void setHMin(int32_t min) { hMin.set(min); }
+  int32_t getHMin() { return hMin.get(); }
 
-  void setHMax(int32_t max) { hMax = max; }
-  int32_t getHMax() { return hMax; }
+  void setHMax(int32_t max) { hMax.set(max); }
+  int32_t getHMax() { return hMax.get(); }
 
-  void setHomingSensitivity(int sensitivity) { homingSensitivity = sensitivity; }
-  int getHomingSensitivity() { return homingSensitivity; }
+  void setHomingSensitivity(int sensitivity) { homingSensitivity.set(sensitivity); }
+  int getHomingSensitivity() { return homingSensitivity.get(); }
 
   void setDefaults();
   String returnJSON();