diff --git a/lib/ArduinoJson/ArduinoJson.h b/lib/ArduinoJson/ArduinoJson.h
new file mode 100644
index 0000000..ecf94fb
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson.h
@@ -0,0 +1,17 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#ifdef __cplusplus
+
+#include "ArduinoJson.hpp"
+
+using namespace ArduinoJson;
+
+#else
+
+#error ArduinoJson requires a C++ compiler, please change file extension to .cc or .cpp
+
+#endif
diff --git a/lib/ArduinoJson/ArduinoJson.hpp b/lib/ArduinoJson/ArduinoJson.hpp
new file mode 100644
index 0000000..fdaf786
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson.hpp
@@ -0,0 +1,65 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#if __cplusplus < 201103L && (!defined(_MSC_VER) || _MSC_VER < 1910)
+#  error ArduinoJson requires C++11 or newer. Configure your compiler for C++11 or downgrade ArduinoJson to 6.20.
+#endif
+
+#include "ArduinoJson/Configuration.hpp"
+
+// Include Arduino.h before stdlib.h to avoid conflict with atexit()
+// https://github.com/bblanchon/ArduinoJson/pull/1693#issuecomment-1001060240
+#if ARDUINOJSON_ENABLE_ARDUINO_STRING || ARDUINOJSON_ENABLE_ARDUINO_STREAM || \
+    ARDUINOJSON_ENABLE_ARDUINO_PRINT ||                                       \
+    (ARDUINOJSON_ENABLE_PROGMEM && defined(ARDUINO))
+#  include <Arduino.h>
+#endif
+
+#if !ARDUINOJSON_DEBUG
+#  ifdef __clang__
+#    pragma clang system_header
+#  elif defined __GNUC__
+#    pragma GCC system_header
+#  endif
+#endif
+
+// Remove true and false macros defined by some cores, such as Arduino Due's
+// See issues #2181 and arduino/ArduinoCore-sam#50
+#ifdef true
+#  undef true
+#endif
+#ifdef false
+#  undef false
+#endif
+
+#include "ArduinoJson/Array/JsonArray.hpp"
+#include "ArduinoJson/Object/JsonObject.hpp"
+#include "ArduinoJson/Variant/JsonVariantConst.hpp"
+
+#include "ArduinoJson/Document/JsonDocument.hpp"
+
+#include "ArduinoJson/Array/ArrayImpl.hpp"
+#include "ArduinoJson/Array/ElementProxy.hpp"
+#include "ArduinoJson/Array/Utilities.hpp"
+#include "ArduinoJson/Collection/CollectionImpl.hpp"
+#include "ArduinoJson/Memory/ResourceManagerImpl.hpp"
+#include "ArduinoJson/Object/MemberProxy.hpp"
+#include "ArduinoJson/Object/ObjectImpl.hpp"
+#include "ArduinoJson/Variant/ConverterImpl.hpp"
+#include "ArduinoJson/Variant/JsonVariantCopier.hpp"
+#include "ArduinoJson/Variant/VariantCompare.hpp"
+#include "ArduinoJson/Variant/VariantImpl.hpp"
+#include "ArduinoJson/Variant/VariantRefBaseImpl.hpp"
+
+#include "ArduinoJson/Json/JsonDeserializer.hpp"
+#include "ArduinoJson/Json/JsonSerializer.hpp"
+#include "ArduinoJson/Json/PrettyJsonSerializer.hpp"
+#include "ArduinoJson/MsgPack/MsgPackBinary.hpp"
+#include "ArduinoJson/MsgPack/MsgPackDeserializer.hpp"
+#include "ArduinoJson/MsgPack/MsgPackExtension.hpp"
+#include "ArduinoJson/MsgPack/MsgPackSerializer.hpp"
+
+#include "ArduinoJson/compatibility.hpp"
diff --git a/lib/ArduinoJson/ArduinoJson/Array/ArrayData.hpp b/lib/ArduinoJson/ArduinoJson/Array/ArrayData.hpp
new file mode 100644
index 0000000..c386950
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Array/ArrayData.hpp
@@ -0,0 +1,66 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Collection/CollectionData.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+class ArrayData : public CollectionData {
+ public:
+  VariantData* addElement(ResourceManager* resources);
+
+  static VariantData* addElement(ArrayData* array, ResourceManager* resources) {
+    if (!array)
+      return nullptr;
+    return array->addElement(resources);
+  }
+
+  template <typename T>
+  bool addValue(const T& value, ResourceManager* resources);
+
+  template <typename T>
+  static bool addValue(ArrayData* array, const T& value,
+                       ResourceManager* resources) {
+    if (!array)
+      return false;
+    return array->addValue(value, resources);
+  }
+
+  VariantData* getOrAddElement(size_t index, ResourceManager* resources);
+
+  VariantData* getElement(size_t index, const ResourceManager* resources) const;
+
+  static VariantData* getElement(const ArrayData* array, size_t index,
+                                 const ResourceManager* resources) {
+    if (!array)
+      return nullptr;
+    return array->getElement(index, resources);
+  }
+
+  void removeElement(size_t index, ResourceManager* resources);
+
+  static void removeElement(ArrayData* array, size_t index,
+                            ResourceManager* resources) {
+    if (!array)
+      return;
+    array->removeElement(index, resources);
+  }
+
+  void remove(iterator it, ResourceManager* resources) {
+    CollectionData::removeOne(it, resources);
+  }
+
+  static void remove(ArrayData* array, iterator it,
+                     ResourceManager* resources) {
+    if (array)
+      return array->remove(it, resources);
+  }
+
+ private:
+  iterator at(size_t index, const ResourceManager* resources) const;
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Array/ArrayImpl.hpp b/lib/ArduinoJson/ArduinoJson/Array/ArrayImpl.hpp
new file mode 100644
index 0000000..044064f
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Array/ArrayImpl.hpp
@@ -0,0 +1,79 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Array/ArrayData.hpp>
+#include <ArduinoJson/Variant/VariantCompare.hpp>
+#include <ArduinoJson/Variant/VariantData.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+inline ArrayData::iterator ArrayData::at(
+    size_t index, const ResourceManager* resources) const {
+  auto it = createIterator(resources);
+  while (!it.done() && index) {
+    it.next(resources);
+    --index;
+  }
+  return it;
+}
+
+inline VariantData* ArrayData::addElement(ResourceManager* resources) {
+  auto slot = resources->allocVariant();
+  if (!slot)
+    return nullptr;
+  CollectionData::appendOne(slot, resources);
+  return slot.ptr();
+}
+
+inline VariantData* ArrayData::getOrAddElement(size_t index,
+                                               ResourceManager* resources) {
+  auto it = createIterator(resources);
+  while (!it.done() && index > 0) {
+    it.next(resources);
+    index--;
+  }
+  if (it.done())
+    index++;
+  VariantData* element = it.data();
+  while (index > 0) {
+    element = addElement(resources);
+    if (!element)
+      return nullptr;
+    index--;
+  }
+  return element;
+}
+
+inline VariantData* ArrayData::getElement(
+    size_t index, const ResourceManager* resources) const {
+  return at(index, resources).data();
+}
+
+inline void ArrayData::removeElement(size_t index, ResourceManager* resources) {
+  remove(at(index, resources), resources);
+}
+
+template <typename T>
+inline bool ArrayData::addValue(const T& value, ResourceManager* resources) {
+  ARDUINOJSON_ASSERT(resources != nullptr);
+  auto slot = resources->allocVariant();
+  if (!slot)
+    return false;
+  JsonVariant variant(slot.ptr(), resources);
+  if (!variant.set(value)) {
+    resources->freeVariant(slot);
+    return false;
+  }
+  CollectionData::appendOne(slot, resources);
+  return true;
+}
+
+// Returns the size (in bytes) of an array with n elements.
+constexpr size_t sizeofArray(size_t n) {
+  return n * ResourceManager::slotSize;
+}
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Array/ElementProxy.hpp b/lib/ArduinoJson/ArduinoJson/Array/ElementProxy.hpp
new file mode 100644
index 0000000..d0d8b41
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Array/ElementProxy.hpp
@@ -0,0 +1,75 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Variant/VariantRefBase.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+// A proxy class to get or set an element of an array.
+// https://arduinojson.org/v7/api/jsonarray/subscript/
+template <typename TUpstream>
+class ElementProxy : public VariantRefBase<ElementProxy<TUpstream>>,
+                     public VariantOperators<ElementProxy<TUpstream>> {
+  friend class VariantAttorney;
+
+  friend class VariantRefBase<ElementProxy<TUpstream>>;
+
+  template <typename, typename>
+  friend class MemberProxy;
+
+  template <typename>
+  friend class ElementProxy;
+
+ public:
+  ElementProxy(TUpstream upstream, size_t index)
+      : upstream_(upstream), index_(index) {}
+
+  ElementProxy& operator=(const ElementProxy& src) {
+    this->set(src);
+    return *this;
+  }
+
+  template <typename T>
+  ElementProxy& operator=(const T& src) {
+    this->set(src);
+    return *this;
+  }
+
+  template <typename T>
+  ElementProxy& operator=(T* src) {
+    this->set(src);
+    return *this;
+  }
+
+ private:
+  // clang-format off
+  ElementProxy(const ElementProxy& src)  // Error here? See https://arduinojson.org/v7/proxy-non-copyable/
+      : upstream_(src.upstream_), index_(src.index_) {}
+  // clang-format on
+
+  ResourceManager* getResourceManager() const {
+    return VariantAttorney::getResourceManager(upstream_);
+  }
+
+  FORCE_INLINE VariantData* getData() const {
+    return VariantData::getElement(
+        VariantAttorney::getData(upstream_), index_,
+        VariantAttorney::getResourceManager(upstream_));
+  }
+
+  VariantData* getOrCreateData() const {
+    auto data = VariantAttorney::getOrCreateData(upstream_);
+    if (!data)
+      return nullptr;
+    return data->getOrAddElement(
+        index_, VariantAttorney::getResourceManager(upstream_));
+  }
+
+  TUpstream upstream_;
+  size_t index_;
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Array/JsonArray.hpp b/lib/ArduinoJson/ArduinoJson/Array/JsonArray.hpp
new file mode 100644
index 0000000..0441bee
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Array/JsonArray.hpp
@@ -0,0 +1,219 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Array/ElementProxy.hpp>
+#include <ArduinoJson/Array/JsonArrayConst.hpp>
+
+ARDUINOJSON_BEGIN_PUBLIC_NAMESPACE
+
+class JsonObject;
+
+// A reference to an array in a JsonDocument
+// https://arduinojson.org/v7/api/jsonarray/
+class JsonArray : public detail::VariantOperators<JsonArray> {
+  friend class detail::VariantAttorney;
+
+ public:
+  using iterator = JsonArrayIterator;
+
+  // Constructs an unbound reference.
+  JsonArray() : data_(0), resources_(0) {}
+
+  // INTERNAL USE ONLY
+  JsonArray(detail::ArrayData* data, detail::ResourceManager* resources)
+      : data_(data), resources_(resources) {}
+
+  // Returns a JsonVariant pointing to the array.
+  // https://arduinojson.org/v7/api/jsonvariant/
+  operator JsonVariant() {
+    void* data = data_;  // prevent warning cast-align
+    return JsonVariant(reinterpret_cast<detail::VariantData*>(data),
+                       resources_);
+  }
+
+  // Returns a read-only reference to the array.
+  // https://arduinojson.org/v7/api/jsonarrayconst/
+  operator JsonArrayConst() const {
+    return JsonArrayConst(data_, resources_);
+  }
+
+  // Appends a new (empty) element to the array.
+  // Returns a reference to the new element.
+  // https://arduinojson.org/v7/api/jsonarray/add/
+  template <typename T, detail::enable_if_t<
+                            !detail::is_same<T, JsonVariant>::value, int> = 0>
+  T add() const {
+    return add<JsonVariant>().to<T>();
+  }
+
+  // Appends a new (null) element to the array.
+  // Returns a reference to the new element.
+  // https://arduinojson.org/v7/api/jsonarray/add/
+  template <typename T, detail::enable_if_t<
+                            detail::is_same<T, JsonVariant>::value, int> = 0>
+  JsonVariant add() const {
+    return JsonVariant(detail::ArrayData::addElement(data_, resources_),
+                       resources_);
+  }
+
+  // Appends a value to the array.
+  // https://arduinojson.org/v7/api/jsonarray/add/
+  template <typename T>
+  bool add(const T& value) const {
+    return detail::ArrayData::addValue(data_, value, resources_);
+  }
+
+  // Appends a value to the array.
+  // https://arduinojson.org/v7/api/jsonarray/add/
+  template <typename T,
+            detail::enable_if_t<!detail::is_const<T>::value, int> = 0>
+  bool add(T* value) const {
+    return detail::ArrayData::addValue(data_, value, resources_);
+  }
+
+  // Returns an iterator to the first element of the array.
+  // https://arduinojson.org/v7/api/jsonarray/begin/
+  iterator begin() const {
+    if (!data_)
+      return iterator();
+    return iterator(data_->createIterator(resources_), resources_);
+  }
+
+  // Returns an iterator following the last element of the array.
+  // https://arduinojson.org/v7/api/jsonarray/end/
+  iterator end() const {
+    return iterator();
+  }
+
+  // Copies an array.
+  // https://arduinojson.org/v7/api/jsonarray/set/
+  bool set(JsonArrayConst src) const {
+    if (!data_)
+      return false;
+
+    clear();
+    for (auto element : src) {
+      if (!add(element))
+        return false;
+    }
+
+    return true;
+  }
+
+  // Removes the element at the specified iterator.
+  // https://arduinojson.org/v7/api/jsonarray/remove/
+  void remove(iterator it) const {
+    detail::ArrayData::remove(data_, it.iterator_, resources_);
+  }
+
+  // Removes the element at the specified index.
+  // https://arduinojson.org/v7/api/jsonarray/remove/
+  void remove(size_t index) const {
+    detail::ArrayData::removeElement(data_, index, resources_);
+  }
+
+  // Removes the element at the specified index.
+  // https://arduinojson.org/v7/api/jsonarray/remove/
+  template <typename TVariant,
+            detail::enable_if_t<detail::IsVariant<TVariant>::value, int> = 0>
+  void remove(const TVariant& variant) const {
+    if (variant.template is<size_t>())
+      remove(variant.template as<size_t>());
+  }
+
+  // Removes all the elements of the array.
+  // https://arduinojson.org/v7/api/jsonarray/clear/
+  void clear() const {
+    detail::ArrayData::clear(data_, resources_);
+  }
+
+  // Gets or sets the element at the specified index.
+  // https://arduinojson.org/v7/api/jsonarray/subscript/
+  template <typename T,
+            detail::enable_if_t<detail::is_integral<T>::value, int> = 0>
+  detail::ElementProxy<JsonArray> operator[](T index) const {
+    return {*this, size_t(index)};
+  }
+
+  // Gets or sets the element at the specified index.
+  // https://arduinojson.org/v7/api/jsonarray/subscript/
+  template <typename TVariant,
+            detail::enable_if_t<detail::IsVariant<TVariant>::value, int> = 0>
+  detail::ElementProxy<JsonArray> operator[](const TVariant& variant) const {
+    if (variant.template is<size_t>())
+      return {*this, variant.template as<size_t>()};
+    else
+      return {*this, size_t(-1)};
+  }
+
+  operator JsonVariantConst() const {
+    return JsonVariantConst(collectionToVariant(data_), resources_);
+  }
+
+  // Returns true if the reference is unbound.
+  // https://arduinojson.org/v7/api/jsonarray/isnull/
+  bool isNull() const {
+    return data_ == 0;
+  }
+
+  // Returns true if the reference is bound.
+  // https://arduinojson.org/v7/api/jsonarray/isnull/
+  operator bool() const {
+    return data_ != 0;
+  }
+
+  // Returns the depth (nesting level) of the array.
+  // https://arduinojson.org/v7/api/jsonarray/nesting/
+  size_t nesting() const {
+    return detail::VariantData::nesting(collectionToVariant(data_), resources_);
+  }
+
+  // Returns the number of elements in the array.
+  // https://arduinojson.org/v7/api/jsonarray/size/
+  size_t size() const {
+    return data_ ? data_->size(resources_) : 0;
+  }
+
+  // DEPRECATED: use add<JsonVariant>() instead
+  ARDUINOJSON_DEPRECATED("use add<JsonVariant>() instead")
+  JsonVariant add() const {
+    return add<JsonVariant>();
+  }
+
+  // DEPRECATED: use add<JsonArray>() instead
+  ARDUINOJSON_DEPRECATED("use add<JsonArray>() instead")
+  JsonArray createNestedArray() const {
+    return add<JsonArray>();
+  }
+
+  // DEPRECATED: use add<JsonObject>() instead
+  ARDUINOJSON_DEPRECATED("use add<JsonObject>() instead")
+  JsonObject createNestedObject() const;
+
+  // DEPRECATED: always returns zero
+  ARDUINOJSON_DEPRECATED("always returns zero")
+  size_t memoryUsage() const {
+    return 0;
+  }
+
+ private:
+  detail::ResourceManager* getResourceManager() const {
+    return resources_;
+  }
+
+  detail::VariantData* getData() const {
+    return collectionToVariant(data_);
+  }
+
+  detail::VariantData* getOrCreateData() const {
+    return collectionToVariant(data_);
+  }
+
+  detail::ArrayData* data_;
+  detail::ResourceManager* resources_;
+};
+
+ARDUINOJSON_END_PUBLIC_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Array/JsonArrayConst.hpp b/lib/ArduinoJson/ArduinoJson/Array/JsonArrayConst.hpp
new file mode 100644
index 0000000..88762d3
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Array/JsonArrayConst.hpp
@@ -0,0 +1,133 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Array/JsonArrayIterator.hpp>
+#include <ArduinoJson/Variant/VariantAttorney.hpp>
+#include <ArduinoJson/Variant/VariantData.hpp>
+
+ARDUINOJSON_BEGIN_PUBLIC_NAMESPACE
+
+class JsonObject;
+
+// A read-only reference to an array in a JsonDocument
+// https://arduinojson.org/v7/api/jsonarrayconst/
+class JsonArrayConst : public detail::VariantOperators<JsonArrayConst> {
+  friend class JsonArray;
+  friend class detail::VariantAttorney;
+
+ public:
+  using iterator = JsonArrayConstIterator;
+
+  // Returns an iterator to the first element of the array.
+  // https://arduinojson.org/v7/api/jsonarrayconst/begin/
+  iterator begin() const {
+    if (!data_)
+      return iterator();
+    return iterator(data_->createIterator(resources_), resources_);
+  }
+
+  // Returns an iterator to the element following the last element of the array.
+  // https://arduinojson.org/v7/api/jsonarrayconst/end/
+  iterator end() const {
+    return iterator();
+  }
+
+  // Creates an unbound reference.
+  JsonArrayConst() : data_(0), resources_(0) {}
+
+  // INTERNAL USE ONLY
+  JsonArrayConst(const detail::ArrayData* data,
+                 const detail::ResourceManager* resources)
+      : data_(data), resources_(resources) {}
+
+  // Returns the element at the specified index.
+  // https://arduinojson.org/v7/api/jsonarrayconst/subscript/
+  template <typename T,
+            detail::enable_if_t<detail::is_integral<T>::value, int> = 0>
+  JsonVariantConst operator[](T index) const {
+    return JsonVariantConst(
+        detail::ArrayData::getElement(data_, size_t(index), resources_),
+        resources_);
+  }
+
+  // Returns the element at the specified index.
+  // https://arduinojson.org/v7/api/jsonarrayconst/subscript/
+  template <typename TVariant,
+            detail::enable_if_t<detail::IsVariant<TVariant>::value, int> = 0>
+  JsonVariantConst operator[](const TVariant& variant) const {
+    if (variant.template is<size_t>())
+      return operator[](variant.template as<size_t>());
+    else
+      return JsonVariantConst();
+  }
+
+  operator JsonVariantConst() const {
+    return JsonVariantConst(getData(), resources_);
+  }
+
+  // Returns true if the reference is unbound.
+  // https://arduinojson.org/v7/api/jsonarrayconst/isnull/
+  bool isNull() const {
+    return data_ == 0;
+  }
+
+  // Returns true if the reference is bound.
+  // https://arduinojson.org/v7/api/jsonarrayconst/isnull/
+  operator bool() const {
+    return data_ != 0;
+  }
+
+  // Returns the depth (nesting level) of the array.
+  // https://arduinojson.org/v7/api/jsonarrayconst/nesting/
+  size_t nesting() const {
+    return detail::VariantData::nesting(getData(), resources_);
+  }
+
+  // Returns the number of elements in the array.
+  // https://arduinojson.org/v7/api/jsonarrayconst/size/
+  size_t size() const {
+    return data_ ? data_->size(resources_) : 0;
+  }
+
+  // DEPRECATED: always returns zero
+  ARDUINOJSON_DEPRECATED("always returns zero")
+  size_t memoryUsage() const {
+    return 0;
+  }
+
+ private:
+  const detail::VariantData* getData() const {
+    return collectionToVariant(data_);
+  }
+
+  const detail::ArrayData* data_;
+  const detail::ResourceManager* resources_;
+};
+
+// Compares the content of two arrays.
+// Returns true if the two arrays are equal.
+inline bool operator==(JsonArrayConst lhs, JsonArrayConst rhs) {
+  if (!lhs && !rhs)
+    return true;
+  if (!lhs || !rhs)
+    return false;
+
+  auto a = lhs.begin();
+  auto b = rhs.begin();
+
+  for (;;) {
+    if (a == b)  // same pointer or both null
+      return true;
+    if (a == lhs.end() || b == rhs.end())
+      return false;
+    if (*a != *b)
+      return false;
+    ++a;
+    ++b;
+  }
+}
+
+ARDUINOJSON_END_PUBLIC_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Array/JsonArrayIterator.hpp b/lib/ArduinoJson/ArduinoJson/Array/JsonArrayIterator.hpp
new file mode 100644
index 0000000..48daf8b
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Array/JsonArrayIterator.hpp
@@ -0,0 +1,96 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Variant/JsonVariant.hpp>
+
+ARDUINOJSON_BEGIN_PUBLIC_NAMESPACE
+
+template <typename T>
+class Ptr {
+ public:
+  Ptr(T value) : value_(value) {}
+
+  T* operator->() {
+    return &value_;
+  }
+
+  T& operator*() {
+    return value_;
+  }
+
+ private:
+  T value_;
+};
+
+class JsonArrayIterator {
+  friend class JsonArray;
+
+ public:
+  JsonArrayIterator() {}
+  explicit JsonArrayIterator(detail::ArrayData::iterator iterator,
+                             detail::ResourceManager* resources)
+      : iterator_(iterator), resources_(resources) {}
+
+  JsonVariant operator*() {
+    return JsonVariant(iterator_.data(), resources_);
+  }
+  Ptr<JsonVariant> operator->() {
+    return operator*();
+  }
+
+  bool operator==(const JsonArrayIterator& other) const {
+    return iterator_ == other.iterator_;
+  }
+
+  bool operator!=(const JsonArrayIterator& other) const {
+    return iterator_ != other.iterator_;
+  }
+
+  JsonArrayIterator& operator++() {
+    iterator_.next(resources_);
+    return *this;
+  }
+
+ private:
+  detail::ArrayData::iterator iterator_;
+  detail::ResourceManager* resources_;
+};
+
+class JsonArrayConstIterator {
+  friend class JsonArray;
+
+ public:
+  JsonArrayConstIterator() {}
+  explicit JsonArrayConstIterator(detail::ArrayData::iterator iterator,
+                                  const detail::ResourceManager* resources)
+      : iterator_(iterator), resources_(resources) {}
+
+  JsonVariantConst operator*() const {
+    return JsonVariantConst(iterator_.data(), resources_);
+  }
+  Ptr<JsonVariantConst> operator->() {
+    return operator*();
+  }
+
+  bool operator==(const JsonArrayConstIterator& other) const {
+    return iterator_ == other.iterator_;
+  }
+
+  bool operator!=(const JsonArrayConstIterator& other) const {
+    return iterator_ != other.iterator_;
+  }
+
+  JsonArrayConstIterator& operator++() {
+    iterator_.next(resources_);
+    return *this;
+  }
+
+ private:
+  detail::ArrayData::iterator iterator_;
+  const detail::ResourceManager* resources_;
+};
+
+ARDUINOJSON_END_PUBLIC_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Array/Utilities.hpp b/lib/ArduinoJson/ArduinoJson/Array/Utilities.hpp
new file mode 100644
index 0000000..9f404de
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Array/Utilities.hpp
@@ -0,0 +1,112 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Array/JsonArray.hpp>
+#include <ArduinoJson/Document/JsonDocument.hpp>
+
+ARDUINOJSON_BEGIN_PUBLIC_NAMESPACE
+
+// Copies a value to a JsonVariant.
+// This is a degenerated form of copyArray() to stop the recursion.
+template <typename T, detail::enable_if_t<!detail::is_array<T>::value, int> = 0>
+inline bool copyArray(const T& src, JsonVariant dst) {
+  return dst.set(src);
+}
+
+// Copies values from an array to a JsonArray or a JsonVariant.
+// https://arduinojson.org/v7/api/misc/copyarray/
+template <typename T, size_t N, typename TDestination,
+          detail::enable_if_t<
+              !detail::is_base_of<JsonDocument, TDestination>::value, int> = 0>
+inline bool copyArray(T (&src)[N], const TDestination& dst) {
+  return copyArray(src, N, dst);
+}
+
+// Copies values from an array to a JsonArray or a JsonVariant.
+// https://arduinojson.org/v7/api/misc/copyarray/
+template <typename T, typename TDestination,
+          detail::enable_if_t<
+              !detail::is_base_of<JsonDocument, TDestination>::value, int> = 0>
+inline bool copyArray(const T* src, size_t len, const TDestination& dst) {
+  bool ok = true;
+  for (size_t i = 0; i < len; i++) {
+    ok &= copyArray(src[i], dst.template add<JsonVariant>());
+  }
+  return ok;
+}
+
+// Copies a string to a JsonVariant.
+// This is a degenerated form of copyArray() to handle strings.
+template <typename TDestination>
+inline bool copyArray(const char* src, size_t, const TDestination& dst) {
+  return dst.set(src);
+}
+
+// Copies values from an array to a JsonDocument.
+// https://arduinojson.org/v7/api/misc/copyarray/
+template <typename T>
+inline bool copyArray(const T& src, JsonDocument& dst) {
+  return copyArray(src, dst.to<JsonArray>());
+}
+
+// Copies an array to a JsonDocument.
+// https://arduinojson.org/v7/api/misc/copyarray/
+template <typename T>
+inline bool copyArray(const T* src, size_t len, JsonDocument& dst) {
+  return copyArray(src, len, dst.to<JsonArray>());
+}
+
+// Copies a value from a JsonVariant.
+// This is a degenerated form of copyArray() to stop the recursion.
+template <typename T, detail::enable_if_t<!detail::is_array<T>::value, int> = 0>
+inline size_t copyArray(JsonVariantConst src, T& dst) {
+  dst = src.as<T>();
+  return 1;
+}
+
+// Copies values from a JsonArray or JsonVariant to an array.
+// https://arduinojson.org/v7/api/misc/copyarray/
+template <typename T, size_t N>
+inline size_t copyArray(JsonArrayConst src, T (&dst)[N]) {
+  return copyArray(src, dst, N);
+}
+
+// Copies values from a JsonArray or JsonVariant to an array.
+// https://arduinojson.org/v7/api/misc/copyarray/
+template <typename T>
+inline size_t copyArray(JsonArrayConst src, T* dst, size_t len) {
+  size_t i = 0;
+  for (JsonArrayConst::iterator it = src.begin(); it != src.end() && i < len;
+       ++it)
+    copyArray(*it, dst[i++]);
+  return i;
+}
+
+// Copies a string from a JsonVariant.
+// This is a degenerated form of copyArray() to handle strings.
+template <size_t N>
+inline size_t copyArray(JsonVariantConst src, char (&dst)[N]) {
+  JsonString s = src;
+  size_t len = N - 1;
+  if (len > s.size())
+    len = s.size();
+  memcpy(dst, s.c_str(), len);
+  dst[len] = 0;
+  return 1;
+}
+
+// Copies values from a JsonDocument to an array.
+// https://arduinojson.org/v7/api/misc/copyarray/
+template <
+    typename TSource, typename T,
+    detail::enable_if_t<detail::is_array<T>::value &&
+                            detail::is_base_of<JsonDocument, TSource>::value,
+                        int> = 0>
+inline size_t copyArray(const TSource& src, T& dst) {
+  return copyArray(src.template as<JsonArrayConst>(), dst);
+}
+
+ARDUINOJSON_END_PUBLIC_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Collection/CollectionData.hpp b/lib/ArduinoJson/ArduinoJson/Collection/CollectionData.hpp
new file mode 100644
index 0000000..8821599
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Collection/CollectionData.hpp
@@ -0,0 +1,122 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Memory/MemoryPool.hpp>
+#include <ArduinoJson/Namespace.hpp>
+#include <ArduinoJson/Polyfills/assert.hpp>
+
+#include <stddef.h>  // size_t
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+class VariantData;
+class ResourceManager;
+
+class CollectionIterator {
+  friend class CollectionData;
+
+ public:
+  CollectionIterator() : slot_(nullptr), currentId_(NULL_SLOT) {}
+
+  void next(const ResourceManager* resources);
+
+  bool done() const {
+    return slot_ == nullptr;
+  }
+
+  bool operator==(const CollectionIterator& other) const {
+    return slot_ == other.slot_;
+  }
+
+  bool operator!=(const CollectionIterator& other) const {
+    return slot_ != other.slot_;
+  }
+
+  VariantData* operator->() {
+    ARDUINOJSON_ASSERT(slot_ != nullptr);
+    return data();
+  }
+
+  VariantData& operator*() {
+    ARDUINOJSON_ASSERT(slot_ != nullptr);
+    return *data();
+  }
+
+  const VariantData& operator*() const {
+    ARDUINOJSON_ASSERT(slot_ != nullptr);
+    return *data();
+  }
+
+  VariantData* data() {
+    return reinterpret_cast<VariantData*>(slot_);
+  }
+
+  const VariantData* data() const {
+    return reinterpret_cast<const VariantData*>(slot_);
+  }
+
+ private:
+  CollectionIterator(VariantData* slot, SlotId slotId);
+
+  VariantData* slot_;
+  SlotId currentId_, nextId_;
+};
+
+class CollectionData {
+  SlotId head_ = NULL_SLOT;
+  SlotId tail_ = NULL_SLOT;
+
+ public:
+  // Placement new
+  static void* operator new(size_t, void* p) noexcept {
+    return p;
+  }
+
+  static void operator delete(void*, void*) noexcept {}
+
+  using iterator = CollectionIterator;
+
+  iterator createIterator(const ResourceManager* resources) const;
+
+  size_t size(const ResourceManager*) const;
+  size_t nesting(const ResourceManager*) const;
+
+  void clear(ResourceManager* resources);
+
+  static void clear(CollectionData* collection, ResourceManager* resources) {
+    if (!collection)
+      return;
+    collection->clear(resources);
+  }
+
+  SlotId head() const {
+    return head_;
+  }
+
+ protected:
+  void appendOne(Slot<VariantData> slot, const ResourceManager* resources);
+  void appendPair(Slot<VariantData> key, Slot<VariantData> value,
+                  const ResourceManager* resources);
+
+  void removeOne(iterator it, ResourceManager* resources);
+  void removePair(iterator it, ResourceManager* resources);
+
+ private:
+  Slot<VariantData> getPreviousSlot(VariantData*, const ResourceManager*) const;
+};
+
+inline const VariantData* collectionToVariant(
+    const CollectionData* collection) {
+  const void* data = collection;  // prevent warning cast-align
+  return reinterpret_cast<const VariantData*>(data);
+}
+
+inline VariantData* collectionToVariant(CollectionData* collection) {
+  void* data = collection;  // prevent warning cast-align
+  return reinterpret_cast<VariantData*>(data);
+}
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Collection/CollectionImpl.hpp b/lib/ArduinoJson/ArduinoJson/Collection/CollectionImpl.hpp
new file mode 100644
index 0000000..7b43053
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Collection/CollectionImpl.hpp
@@ -0,0 +1,137 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Collection/CollectionData.hpp>
+#include <ArduinoJson/Memory/Alignment.hpp>
+#include <ArduinoJson/Strings/StringAdapters.hpp>
+#include <ArduinoJson/Variant/VariantCompare.hpp>
+#include <ArduinoJson/Variant/VariantData.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+inline CollectionIterator::CollectionIterator(VariantData* slot, SlotId slotId)
+    : slot_(slot), currentId_(slotId) {
+  nextId_ = slot_ ? slot_->next() : NULL_SLOT;
+}
+
+inline void CollectionIterator::next(const ResourceManager* resources) {
+  ARDUINOJSON_ASSERT(currentId_ != NULL_SLOT);
+  slot_ = resources->getVariant(nextId_);
+  currentId_ = nextId_;
+  if (slot_)
+    nextId_ = slot_->next();
+}
+
+inline CollectionData::iterator CollectionData::createIterator(
+    const ResourceManager* resources) const {
+  return iterator(resources->getVariant(head_), head_);
+}
+
+inline void CollectionData::appendOne(Slot<VariantData> slot,
+                                      const ResourceManager* resources) {
+  if (tail_ != NULL_SLOT) {
+    auto tail = resources->getVariant(tail_);
+    tail->setNext(slot.id());
+    tail_ = slot.id();
+  } else {
+    head_ = slot.id();
+    tail_ = slot.id();
+  }
+}
+
+inline void CollectionData::appendPair(Slot<VariantData> key,
+                                       Slot<VariantData> value,
+                                       const ResourceManager* resources) {
+  key->setNext(value.id());
+
+  if (tail_ != NULL_SLOT) {
+    auto tail = resources->getVariant(tail_);
+    tail->setNext(key.id());
+    tail_ = value.id();
+  } else {
+    head_ = key.id();
+    tail_ = value.id();
+  }
+}
+
+inline void CollectionData::clear(ResourceManager* resources) {
+  auto next = head_;
+  while (next != NULL_SLOT) {
+    auto currId = next;
+    auto slot = resources->getVariant(next);
+    next = slot->next();
+    resources->freeVariant({slot, currId});
+  }
+
+  head_ = NULL_SLOT;
+  tail_ = NULL_SLOT;
+}
+
+inline Slot<VariantData> CollectionData::getPreviousSlot(
+    VariantData* target, const ResourceManager* resources) const {
+  auto prev = Slot<VariantData>();
+  auto currentId = head_;
+  while (currentId != NULL_SLOT) {
+    auto currentSlot = resources->getVariant(currentId);
+    if (currentSlot == target)
+      break;
+    prev = Slot<VariantData>(currentSlot, currentId);
+    currentId = currentSlot->next();
+  }
+  return prev;
+}
+
+inline void CollectionData::removeOne(iterator it, ResourceManager* resources) {
+  if (it.done())
+    return;
+  auto curr = it.slot_;
+  auto prev = getPreviousSlot(curr, resources);
+  auto next = curr->next();
+  if (prev)
+    prev->setNext(next);
+  else
+    head_ = next;
+  if (next == NULL_SLOT)
+    tail_ = prev.id();
+  resources->freeVariant({it.slot_, it.currentId_});
+}
+
+inline void CollectionData::removePair(ObjectData::iterator it,
+                                       ResourceManager* resources) {
+  if (it.done())
+    return;
+
+  auto keySlot = it.slot_;
+
+  auto valueId = it.nextId_;
+  auto valueSlot = resources->getVariant(valueId);
+
+  // remove value slot
+  keySlot->setNext(valueSlot->next());
+  resources->freeVariant({valueSlot, valueId});
+
+  // remove key slot
+  removeOne(it, resources);
+}
+
+inline size_t CollectionData::nesting(const ResourceManager* resources) const {
+  size_t maxChildNesting = 0;
+  for (auto it = createIterator(resources); !it.done(); it.next(resources)) {
+    size_t childNesting = it->nesting(resources);
+    if (childNesting > maxChildNesting)
+      maxChildNesting = childNesting;
+  }
+  return maxChildNesting + 1;
+}
+
+inline size_t CollectionData::size(const ResourceManager* resources) const {
+  size_t count = 0;
+  for (auto it = createIterator(resources); !it.done(); it.next(resources))
+    count++;
+  return count;
+}
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Configuration.hpp b/lib/ArduinoJson/ArduinoJson/Configuration.hpp
new file mode 100644
index 0000000..801202c
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Configuration.hpp
@@ -0,0 +1,285 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+// Support std::istream and std::ostream
+// https://arduinojson.org/v7/config/enable_std_stream/
+#ifndef ARDUINOJSON_ENABLE_STD_STREAM
+#  ifdef __has_include
+#    if __has_include(<istream>) && \
+    __has_include(<ostream>) && \
+    !defined(min) && \
+    !defined(max)
+#      define ARDUINOJSON_ENABLE_STD_STREAM 1
+#    else
+#      define ARDUINOJSON_ENABLE_STD_STREAM 0
+#    endif
+#  else
+#    ifdef ARDUINO
+#      define ARDUINOJSON_ENABLE_STD_STREAM 0
+#    else
+#      define ARDUINOJSON_ENABLE_STD_STREAM 1
+#    endif
+#  endif
+#endif
+
+// Support std::string
+// https://arduinojson.org/v7/config/enable_std_string/
+#ifndef ARDUINOJSON_ENABLE_STD_STRING
+#  ifdef __has_include
+#    if __has_include(<string>) && !defined(min) && !defined(max)
+#      define ARDUINOJSON_ENABLE_STD_STRING 1
+#    else
+#      define ARDUINOJSON_ENABLE_STD_STRING 0
+#    endif
+#  else
+#    ifdef ARDUINO
+#      define ARDUINOJSON_ENABLE_STD_STRING 0
+#    else
+#      define ARDUINOJSON_ENABLE_STD_STRING 1
+#    endif
+#  endif
+#endif
+
+// Support for std::string_view
+#ifndef ARDUINOJSON_ENABLE_STRING_VIEW
+#  ifdef __has_include
+#    if __has_include(<string_view>) && __cplusplus >= 201703L
+#      define ARDUINOJSON_ENABLE_STRING_VIEW 1
+#    else
+#      define ARDUINOJSON_ENABLE_STRING_VIEW 0
+#    endif
+#  else
+#    define ARDUINOJSON_ENABLE_STRING_VIEW 0
+#  endif
+#endif
+
+// Pointer size: a heuristic to set sensible defaults
+#ifndef ARDUINOJSON_SIZEOF_POINTER
+#  if defined(__SIZEOF_POINTER__)
+#    define ARDUINOJSON_SIZEOF_POINTER __SIZEOF_POINTER__
+#  elif defined(_WIN64) && _WIN64
+#    define ARDUINOJSON_SIZEOF_POINTER 8  // 64 bits
+#  else
+#    define ARDUINOJSON_SIZEOF_POINTER 4  // assume 32 bits otherwise
+#  endif
+#endif
+
+// Store floating-point values with float (0) or double (1)
+// https://arduinojson.org/v7/config/use_double/
+#ifndef ARDUINOJSON_USE_DOUBLE
+#  if ARDUINOJSON_SIZEOF_POINTER >= 4  // 32 & 64 bits systems
+#    define ARDUINOJSON_USE_DOUBLE 1
+#  else
+#    define ARDUINOJSON_USE_DOUBLE 0
+#  endif
+#endif
+
+// Store integral values with long (0) or long long (1)
+// https://arduinojson.org/v7/config/use_long_long/
+#ifndef ARDUINOJSON_USE_LONG_LONG
+#  if ARDUINOJSON_SIZEOF_POINTER >= 4  // 32 & 64 bits systems
+#    define ARDUINOJSON_USE_LONG_LONG 1
+#  else
+#    define ARDUINOJSON_USE_LONG_LONG 0
+#  endif
+#endif
+
+// Limit nesting as the stack is likely to be small
+// https://arduinojson.org/v7/config/default_nesting_limit/
+#ifndef ARDUINOJSON_DEFAULT_NESTING_LIMIT
+#  define ARDUINOJSON_DEFAULT_NESTING_LIMIT 10
+#endif
+
+// Number of bytes to store a slot id
+// https://arduinojson.org/v7/config/slot_id_size/
+#ifndef ARDUINOJSON_SLOT_ID_SIZE
+#  if ARDUINOJSON_SIZEOF_POINTER <= 2
+//   8-bit and 16-bit archs => up to 255 slots
+#    define ARDUINOJSON_SLOT_ID_SIZE 1
+#  elif ARDUINOJSON_SIZEOF_POINTER == 4
+//   32-bit arch => up to 65535 slots
+#    define ARDUINOJSON_SLOT_ID_SIZE 2
+#  else
+//   64-bit arch => up to 4294967295 slots
+#    define ARDUINOJSON_SLOT_ID_SIZE 4
+#  endif
+#endif
+
+// Capacity of each variant pool (in slots)
+#ifndef ARDUINOJSON_POOL_CAPACITY
+#  if ARDUINOJSON_SLOT_ID_SIZE == 1
+#    define ARDUINOJSON_POOL_CAPACITY 16  // 96 bytes
+#  elif ARDUINOJSON_SLOT_ID_SIZE == 2
+#    define ARDUINOJSON_POOL_CAPACITY 128  // 1024 bytes
+#  else
+#    define ARDUINOJSON_POOL_CAPACITY 256  // 4096 bytes
+#  endif
+#endif
+
+// Initial capacity of the pool list
+#ifndef ARDUINOJSON_INITIAL_POOL_COUNT
+#  define ARDUINOJSON_INITIAL_POOL_COUNT 4
+#endif
+
+// Automatically call shrinkToFit() from deserializeXxx()
+// Disabled by default on 8-bit platforms because it's not worth the increase in
+// code size
+#ifndef ARDUINOJSON_AUTO_SHRINK
+#  if ARDUINOJSON_SIZEOF_POINTER <= 2
+#    define ARDUINOJSON_AUTO_SHRINK 0
+#  else
+#    define ARDUINOJSON_AUTO_SHRINK 1
+#  endif
+#endif
+
+// Number of bytes to store the length of a string
+// https://arduinojson.org/v7/config/string_length_size/
+#ifndef ARDUINOJSON_STRING_LENGTH_SIZE
+#  if ARDUINOJSON_SIZEOF_POINTER <= 2
+#    define ARDUINOJSON_STRING_LENGTH_SIZE 1  // up to 255 characters
+#  else
+#    define ARDUINOJSON_STRING_LENGTH_SIZE 2  // up to 65535 characters
+#  endif
+#endif
+
+#ifdef ARDUINO
+
+// Enable support for Arduino's String class
+// https://arduinojson.org/v7/config/enable_arduino_string/
+#  ifndef ARDUINOJSON_ENABLE_ARDUINO_STRING
+#    define ARDUINOJSON_ENABLE_ARDUINO_STRING 1
+#  endif
+
+// Enable support for Arduino's Stream class
+// https://arduinojson.org/v7/config/enable_arduino_stream/
+#  ifndef ARDUINOJSON_ENABLE_ARDUINO_STREAM
+#    define ARDUINOJSON_ENABLE_ARDUINO_STREAM 1
+#  endif
+
+// Enable support for Arduino's Print class
+#  ifndef ARDUINOJSON_ENABLE_ARDUINO_PRINT
+#    define ARDUINOJSON_ENABLE_ARDUINO_PRINT 1
+#  endif
+
+// Enable support for PROGMEM
+// https://arduinojson.org/v7/config/enable_progmem/
+#  ifndef ARDUINOJSON_ENABLE_PROGMEM
+#    define ARDUINOJSON_ENABLE_PROGMEM 1
+#  endif
+
+#else  // ARDUINO
+
+// Disable support for Arduino's String class
+// https://arduinojson.org/v7/config/enable_arduino_string/
+#  ifndef ARDUINOJSON_ENABLE_ARDUINO_STRING
+#    define ARDUINOJSON_ENABLE_ARDUINO_STRING 0
+#  endif
+
+// Disable support for Arduino's Stream class
+// https://arduinojson.org/v7/config/enable_arduino_stream/
+#  ifndef ARDUINOJSON_ENABLE_ARDUINO_STREAM
+#    define ARDUINOJSON_ENABLE_ARDUINO_STREAM 0
+#  endif
+
+// Disable support for Arduino's Print class
+#  ifndef ARDUINOJSON_ENABLE_ARDUINO_PRINT
+#    define ARDUINOJSON_ENABLE_ARDUINO_PRINT 0
+#  endif
+
+// Enable PROGMEM support on AVR only
+// https://arduinojson.org/v7/config/enable_progmem/
+#  ifndef ARDUINOJSON_ENABLE_PROGMEM
+#    ifdef __AVR__
+#      define ARDUINOJSON_ENABLE_PROGMEM 1
+#    else
+#      define ARDUINOJSON_ENABLE_PROGMEM 0
+#    endif
+#  endif
+
+#endif  // ARDUINO
+
+// Convert unicode escape sequence (\u0123) to UTF-8
+// https://arduinojson.org/v7/config/decode_unicode/
+#ifndef ARDUINOJSON_DECODE_UNICODE
+#  define ARDUINOJSON_DECODE_UNICODE 1
+#endif
+
+// Ignore comments in input
+// https://arduinojson.org/v7/config/enable_comments/
+#ifndef ARDUINOJSON_ENABLE_COMMENTS
+#  define ARDUINOJSON_ENABLE_COMMENTS 0
+#endif
+
+// Support NaN in JSON
+// https://arduinojson.org/v7/config/enable_nan/
+#ifndef ARDUINOJSON_ENABLE_NAN
+#  define ARDUINOJSON_ENABLE_NAN 0
+#endif
+
+// Support Infinity in JSON
+// https://arduinojson.org/v7/config/enable_infinity/
+#ifndef ARDUINOJSON_ENABLE_INFINITY
+#  define ARDUINOJSON_ENABLE_INFINITY 0
+#endif
+
+// Control the exponentiation threshold for big numbers
+// CAUTION: cannot be more that 1e9 !!!!
+// https://arduinojson.org/v7/config/positive_exponentiation_threshold/
+#ifndef ARDUINOJSON_POSITIVE_EXPONENTIATION_THRESHOLD
+#  define ARDUINOJSON_POSITIVE_EXPONENTIATION_THRESHOLD 1e7
+#endif
+
+// Control the exponentiation threshold for small numbers
+// https://arduinojson.org/v7/config/negative_exponentiation_threshold/
+#ifndef ARDUINOJSON_NEGATIVE_EXPONENTIATION_THRESHOLD
+#  define ARDUINOJSON_NEGATIVE_EXPONENTIATION_THRESHOLD 1e-5
+#endif
+
+#ifndef ARDUINOJSON_LITTLE_ENDIAN
+#  if defined(_MSC_VER) ||                           \
+      (defined(__BYTE_ORDER__) &&                    \
+       __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) || \
+      defined(__LITTLE_ENDIAN__) || defined(__i386) || defined(__x86_64)
+#    define ARDUINOJSON_LITTLE_ENDIAN 1
+#  else
+#    define ARDUINOJSON_LITTLE_ENDIAN 0
+#  endif
+#endif
+
+#ifndef ARDUINOJSON_ENABLE_ALIGNMENT
+#  if defined(__AVR)
+#    define ARDUINOJSON_ENABLE_ALIGNMENT 0
+#  else
+#    define ARDUINOJSON_ENABLE_ALIGNMENT 1
+#  endif
+#endif
+
+#ifndef ARDUINOJSON_TAB
+#  define ARDUINOJSON_TAB "  "
+#endif
+
+#ifndef ARDUINOJSON_STRING_BUFFER_SIZE
+#  define ARDUINOJSON_STRING_BUFFER_SIZE 32
+#endif
+
+#ifndef ARDUINOJSON_DEBUG
+#  ifdef __PLATFORMIO_BUILD_DEBUG__
+#    define ARDUINOJSON_DEBUG 1
+#  else
+#    define ARDUINOJSON_DEBUG 0
+#  endif
+#endif
+
+#if ARDUINOJSON_USE_LONG_LONG || ARDUINOJSON_USE_DOUBLE
+#  define ARDUINOJSON_USE_EXTENSIONS 1
+#else
+#  define ARDUINOJSON_USE_EXTENSIONS 0
+#endif
+
+#if defined(nullptr)
+#  error nullptr is defined as a macro. Remove the faulty #define or #undef nullptr
+// See https://github.com/bblanchon/ArduinoJson/issues/1355
+#endif
diff --git a/lib/ArduinoJson/ArduinoJson/Deserialization/DeserializationError.hpp b/lib/ArduinoJson/ArduinoJson/Deserialization/DeserializationError.hpp
new file mode 100644
index 0000000..c498b07
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Deserialization/DeserializationError.hpp
@@ -0,0 +1,106 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+#include <ArduinoJson/Polyfills/pgmspace_generic.hpp>
+#include <ArduinoJson/Polyfills/preprocessor.hpp>
+
+#if ARDUINOJSON_ENABLE_STD_STREAM
+#  include <ostream>
+#endif
+
+ARDUINOJSON_BEGIN_PUBLIC_NAMESPACE
+
+class DeserializationError {
+ public:
+  enum Code {
+    Ok,
+    EmptyInput,
+    IncompleteInput,
+    InvalidInput,
+    NoMemory,
+    TooDeep
+  };
+
+  DeserializationError() {}
+  DeserializationError(Code c) : code_(c) {}
+
+  // Compare with DeserializationError
+  friend bool operator==(const DeserializationError& lhs,
+                         const DeserializationError& rhs) {
+    return lhs.code_ == rhs.code_;
+  }
+  friend bool operator!=(const DeserializationError& lhs,
+                         const DeserializationError& rhs) {
+    return lhs.code_ != rhs.code_;
+  }
+
+  // Compare with Code
+  friend bool operator==(const DeserializationError& lhs, Code rhs) {
+    return lhs.code_ == rhs;
+  }
+  friend bool operator==(Code lhs, const DeserializationError& rhs) {
+    return lhs == rhs.code_;
+  }
+  friend bool operator!=(const DeserializationError& lhs, Code rhs) {
+    return lhs.code_ != rhs;
+  }
+  friend bool operator!=(Code lhs, const DeserializationError& rhs) {
+    return lhs != rhs.code_;
+  }
+
+  // Returns true if there is an error
+  explicit operator bool() const {
+    return code_ != Ok;
+  }
+
+  // Returns internal enum, useful for switch statement
+  Code code() const {
+    return code_;
+  }
+
+  const char* c_str() const {
+    static const char* messages[] = {
+        "Ok",           "EmptyInput", "IncompleteInput",
+        "InvalidInput", "NoMemory",   "TooDeep"};
+    ARDUINOJSON_ASSERT(static_cast<size_t>(code_) <
+                       sizeof(messages) / sizeof(messages[0]));
+    return messages[code_];
+  }
+
+#if ARDUINOJSON_ENABLE_PROGMEM
+  const __FlashStringHelper* f_str() const {
+    ARDUINOJSON_DEFINE_PROGMEM_ARRAY(char, s0, "Ok");
+    ARDUINOJSON_DEFINE_PROGMEM_ARRAY(char, s1, "EmptyInput");
+    ARDUINOJSON_DEFINE_PROGMEM_ARRAY(char, s2, "IncompleteInput");
+    ARDUINOJSON_DEFINE_PROGMEM_ARRAY(char, s3, "InvalidInput");
+    ARDUINOJSON_DEFINE_PROGMEM_ARRAY(char, s4, "NoMemory");
+    ARDUINOJSON_DEFINE_PROGMEM_ARRAY(char, s5, "TooDeep");
+    ARDUINOJSON_DEFINE_PROGMEM_ARRAY(const char*, messages,
+                                     {s0, s1, s2, s3, s4, s5});
+    return reinterpret_cast<const __FlashStringHelper*>(
+        detail::pgm_read(messages + code_));
+  }
+#endif
+
+ private:
+  Code code_;
+};
+
+#if ARDUINOJSON_ENABLE_STD_STREAM
+inline std::ostream& operator<<(std::ostream& s,
+                                const DeserializationError& e) {
+  s << e.c_str();
+  return s;
+}
+
+inline std::ostream& operator<<(std::ostream& s, DeserializationError::Code c) {
+  s << DeserializationError(c).c_str();
+  return s;
+}
+#endif
+
+ARDUINOJSON_END_PUBLIC_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Deserialization/DeserializationOptions.hpp b/lib/ArduinoJson/ArduinoJson/Deserialization/DeserializationOptions.hpp
new file mode 100644
index 0000000..b711d71
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Deserialization/DeserializationOptions.hpp
@@ -0,0 +1,35 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Deserialization/Filter.hpp>
+#include <ArduinoJson/Deserialization/NestingLimit.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <typename TFilter>
+struct DeserializationOptions {
+  TFilter filter;
+  DeserializationOption::NestingLimit nestingLimit;
+};
+
+template <typename TFilter>
+inline DeserializationOptions<TFilter> makeDeserializationOptions(
+    TFilter filter, DeserializationOption::NestingLimit nestingLimit = {}) {
+  return {filter, nestingLimit};
+}
+
+template <typename TFilter>
+inline DeserializationOptions<TFilter> makeDeserializationOptions(
+    DeserializationOption::NestingLimit nestingLimit, TFilter filter) {
+  return {filter, nestingLimit};
+}
+
+inline DeserializationOptions<AllowAllFilter> makeDeserializationOptions(
+    DeserializationOption::NestingLimit nestingLimit = {}) {
+  return {{}, nestingLimit};
+}
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Deserialization/Filter.hpp b/lib/ArduinoJson/ArduinoJson/Deserialization/Filter.hpp
new file mode 100644
index 0000000..564893b
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Deserialization/Filter.hpp
@@ -0,0 +1,77 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Variant/JsonVariant.hpp>
+#include <ArduinoJson/Variant/VariantAttorney.hpp>
+
+ARDUINOJSON_BEGIN_PUBLIC_NAMESPACE
+
+namespace DeserializationOption {
+class Filter {
+ public:
+#if ARDUINOJSON_AUTO_SHRINK
+  explicit Filter(JsonDocument& doc) : variant_(doc) {
+    doc.shrinkToFit();
+  }
+#endif
+
+  explicit Filter(JsonVariantConst variant) : variant_(variant) {}
+
+  bool allow() const {
+    return variant_;
+  }
+
+  bool allowArray() const {
+    return variant_ == true || variant_.is<JsonArrayConst>();
+  }
+
+  bool allowObject() const {
+    return variant_ == true || variant_.is<JsonObjectConst>();
+  }
+
+  bool allowValue() const {
+    return variant_ == true;
+  }
+
+  template <typename TKey>
+  Filter operator[](const TKey& key) const {
+    if (variant_ == true)  // "true" means "allow recursively"
+      return *this;
+    JsonVariantConst member = variant_[key];
+    return Filter(member.isNull() ? variant_["*"] : member);
+  }
+
+ private:
+  JsonVariantConst variant_;
+};
+}  // namespace DeserializationOption
+
+namespace detail {
+struct AllowAllFilter {
+  bool allow() const {
+    return true;
+  }
+
+  bool allowArray() const {
+    return true;
+  }
+
+  bool allowObject() const {
+    return true;
+  }
+
+  bool allowValue() const {
+    return true;
+  }
+
+  template <typename TKey>
+  AllowAllFilter operator[](const TKey&) const {
+    return AllowAllFilter();
+  }
+};
+}  // namespace detail
+
+ARDUINOJSON_END_PUBLIC_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Deserialization/NestingLimit.hpp b/lib/ArduinoJson/ArduinoJson/Deserialization/NestingLimit.hpp
new file mode 100644
index 0000000..11aba7e
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Deserialization/NestingLimit.hpp
@@ -0,0 +1,32 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+#include <ArduinoJson/Polyfills/assert.hpp>
+
+ARDUINOJSON_BEGIN_PUBLIC_NAMESPACE
+
+namespace DeserializationOption {
+class NestingLimit {
+ public:
+  NestingLimit() : value_(ARDUINOJSON_DEFAULT_NESTING_LIMIT) {}
+  explicit NestingLimit(uint8_t n) : value_(n) {}
+
+  NestingLimit decrement() const {
+    ARDUINOJSON_ASSERT(value_ > 0);
+    return NestingLimit(static_cast<uint8_t>(value_ - 1));
+  }
+
+  bool reached() const {
+    return value_ == 0;
+  }
+
+ private:
+  uint8_t value_;
+};
+}  // namespace DeserializationOption
+
+ARDUINOJSON_END_PUBLIC_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Deserialization/Reader.hpp b/lib/ArduinoJson/ArduinoJson/Deserialization/Reader.hpp
new file mode 100644
index 0000000..4610312
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Deserialization/Reader.hpp
@@ -0,0 +1,74 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+#include <ArduinoJson/Polyfills/utility.hpp>
+
+#include <stdlib.h>  // for size_t
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+// The default reader is a simple wrapper for Readers that are not copyable
+template <typename TSource, typename Enable = void>
+struct Reader {
+ public:
+  Reader(TSource& source) : source_(&source) {}
+
+  int read() {
+    // clang-format off
+    return source_->read();  // Error here? See https://arduinojson.org/v7/invalid-input/
+    // clang-format on
+  }
+
+  size_t readBytes(char* buffer, size_t length) {
+    return source_->readBytes(buffer, length);
+  }
+
+ private:
+  TSource* source_;
+};
+
+template <typename TSource, typename Enable = void>
+struct BoundedReader {
+  // no default implementation because we need to pass the size to the
+  // constructor
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
+
+#include <ArduinoJson/Deserialization/Readers/IteratorReader.hpp>
+#include <ArduinoJson/Deserialization/Readers/RamReader.hpp>
+#include <ArduinoJson/Deserialization/Readers/VariantReader.hpp>
+
+#if ARDUINOJSON_ENABLE_ARDUINO_STREAM
+#  include <ArduinoJson/Deserialization/Readers/ArduinoStreamReader.hpp>
+#endif
+
+#if ARDUINOJSON_ENABLE_ARDUINO_STRING
+#  include <ArduinoJson/Deserialization/Readers/ArduinoStringReader.hpp>
+#endif
+
+#if ARDUINOJSON_ENABLE_PROGMEM
+#  include <ArduinoJson/Deserialization/Readers/FlashReader.hpp>
+#endif
+
+#if ARDUINOJSON_ENABLE_STD_STREAM
+#  include <ArduinoJson/Deserialization/Readers/StdStreamReader.hpp>
+#endif
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <typename TInput>
+Reader<remove_reference_t<TInput>> makeReader(TInput&& input) {
+  return Reader<remove_reference_t<TInput>>{detail::forward<TInput>(input)};
+}
+
+template <typename TChar>
+BoundedReader<TChar*> makeReader(TChar* input, size_t inputSize) {
+  return BoundedReader<TChar*>{input, inputSize};
+}
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Deserialization/Readers/ArduinoStreamReader.hpp b/lib/ArduinoJson/ArduinoJson/Deserialization/Readers/ArduinoStreamReader.hpp
new file mode 100644
index 0000000..7c4d6b8
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Deserialization/Readers/ArduinoStreamReader.hpp
@@ -0,0 +1,30 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <Arduino.h>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <typename TSource>
+struct Reader<TSource, enable_if_t<is_base_of<Stream, TSource>::value>> {
+ public:
+  explicit Reader(Stream& stream) : stream_(&stream) {}
+
+  int read() {
+    // don't use stream_->read() as it ignores the timeout
+    char c;
+    return stream_->readBytes(&c, 1) ? static_cast<unsigned char>(c) : -1;
+  }
+
+  size_t readBytes(char* buffer, size_t length) {
+    return stream_->readBytes(buffer, length);
+  }
+
+ private:
+  Stream* stream_;
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Deserialization/Readers/ArduinoStringReader.hpp b/lib/ArduinoJson/ArduinoJson/Deserialization/Readers/ArduinoStringReader.hpp
new file mode 100644
index 0000000..ba3d7b7
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Deserialization/Readers/ArduinoStringReader.hpp
@@ -0,0 +1,18 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <Arduino.h>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <typename TSource>
+struct Reader<TSource, enable_if_t<is_base_of<::String, TSource>::value>>
+    : BoundedReader<const char*> {
+  explicit Reader(const ::String& s)
+      : BoundedReader<const char*>(s.c_str(), s.length()) {}
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Deserialization/Readers/FlashReader.hpp b/lib/ArduinoJson/ArduinoJson/Deserialization/Readers/FlashReader.hpp
new file mode 100644
index 0000000..80c0da8
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Deserialization/Readers/FlashReader.hpp
@@ -0,0 +1,56 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Polyfills/pgmspace.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <>
+struct Reader<const __FlashStringHelper*, void> {
+  const char* ptr_;
+
+ public:
+  explicit Reader(const __FlashStringHelper* ptr)
+      : ptr_(reinterpret_cast<const char*>(ptr)) {}
+
+  int read() {
+    return pgm_read_byte(ptr_++);
+  }
+
+  size_t readBytes(char* buffer, size_t length) {
+    memcpy_P(buffer, ptr_, length);
+    ptr_ += length;
+    return length;
+  }
+};
+
+template <>
+struct BoundedReader<const __FlashStringHelper*, void> {
+  const char* ptr_;
+  const char* end_;
+
+ public:
+  explicit BoundedReader(const __FlashStringHelper* ptr, size_t size)
+      : ptr_(reinterpret_cast<const char*>(ptr)), end_(ptr_ + size) {}
+
+  int read() {
+    if (ptr_ < end_)
+      return pgm_read_byte(ptr_++);
+    else
+      return -1;
+  }
+
+  size_t readBytes(char* buffer, size_t length) {
+    size_t available = static_cast<size_t>(end_ - ptr_);
+    if (available < length)
+      length = available;
+    memcpy_P(buffer, ptr_, length);
+    ptr_ += length;
+    return length;
+  }
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Deserialization/Readers/IteratorReader.hpp b/lib/ArduinoJson/ArduinoJson/Deserialization/Readers/IteratorReader.hpp
new file mode 100644
index 0000000..428d3f5
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Deserialization/Readers/IteratorReader.hpp
@@ -0,0 +1,42 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Polyfills/type_traits.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <typename TIterator>
+class IteratorReader {
+  TIterator ptr_, end_;
+
+ public:
+  explicit IteratorReader(TIterator begin, TIterator end)
+      : ptr_(begin), end_(end) {}
+
+  int read() {
+    if (ptr_ < end_)
+      return static_cast<unsigned char>(*ptr_++);
+    else
+      return -1;
+  }
+
+  size_t readBytes(char* buffer, size_t length) {
+    size_t i = 0;
+    while (i < length && ptr_ < end_)
+      buffer[i++] = *ptr_++;
+    return i;
+  }
+};
+
+template <typename TSource>
+struct Reader<TSource, void_t<typename TSource::const_iterator>>
+    : IteratorReader<typename TSource::const_iterator> {
+  explicit Reader(const TSource& source)
+      : IteratorReader<typename TSource::const_iterator>(source.begin(),
+                                                         source.end()) {}
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Deserialization/Readers/RamReader.hpp b/lib/ArduinoJson/ArduinoJson/Deserialization/Readers/RamReader.hpp
new file mode 100644
index 0000000..30ddd8f
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Deserialization/Readers/RamReader.hpp
@@ -0,0 +1,49 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Polyfills/type_traits.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <typename T>
+struct IsCharOrVoid {
+  static const bool value =
+      is_same<T, void>::value || is_same<T, char>::value ||
+      is_same<T, unsigned char>::value || is_same<T, signed char>::value;
+};
+
+template <typename T>
+struct IsCharOrVoid<const T> : IsCharOrVoid<T> {};
+
+template <typename TSource>
+struct Reader<TSource*, enable_if_t<IsCharOrVoid<TSource>::value>> {
+  const char* ptr_;
+
+ public:
+  explicit Reader(const void* ptr)
+      : ptr_(ptr ? reinterpret_cast<const char*>(ptr) : "") {}
+
+  int read() {
+    return static_cast<unsigned char>(*ptr_++);
+  }
+
+  size_t readBytes(char* buffer, size_t length) {
+    for (size_t i = 0; i < length; i++)
+      buffer[i] = *ptr_++;
+    return length;
+  }
+};
+
+template <typename TSource>
+struct BoundedReader<TSource*, enable_if_t<IsCharOrVoid<TSource>::value>>
+    : public IteratorReader<const char*> {
+ public:
+  explicit BoundedReader(const void* ptr, size_t len)
+      : IteratorReader<const char*>(reinterpret_cast<const char*>(ptr),
+                                    reinterpret_cast<const char*>(ptr) + len) {}
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Deserialization/Readers/StdStreamReader.hpp b/lib/ArduinoJson/ArduinoJson/Deserialization/Readers/StdStreamReader.hpp
new file mode 100644
index 0000000..5de22c0
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Deserialization/Readers/StdStreamReader.hpp
@@ -0,0 +1,29 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <istream>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <typename TSource>
+struct Reader<TSource, enable_if_t<is_base_of<std::istream, TSource>::value>> {
+ public:
+  explicit Reader(std::istream& stream) : stream_(&stream) {}
+
+  int read() {
+    return stream_->get();
+  }
+
+  size_t readBytes(char* buffer, size_t length) {
+    stream_->read(buffer, static_cast<std::streamsize>(length));
+    return static_cast<size_t>(stream_->gcount());
+  }
+
+ private:
+  std::istream* stream_;
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Deserialization/Readers/VariantReader.hpp b/lib/ArduinoJson/ArduinoJson/Deserialization/Readers/VariantReader.hpp
new file mode 100644
index 0000000..6b91517
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Deserialization/Readers/VariantReader.hpp
@@ -0,0 +1,19 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Object/MemberProxy.hpp>
+#include <ArduinoJson/Variant/JsonVariantConst.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <typename TVariant>
+struct Reader<TVariant, enable_if_t<IsVariant<TVariant>::value>>
+    : Reader<char*, void> {
+  explicit Reader(const TVariant& x)
+      : Reader<char*, void>(x.template as<const char*>()) {}
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Deserialization/deserialize.hpp b/lib/ArduinoJson/ArduinoJson/Deserialization/deserialize.hpp
new file mode 100644
index 0000000..a23e093
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Deserialization/deserialize.hpp
@@ -0,0 +1,79 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Deserialization/DeserializationError.hpp>
+#include <ArduinoJson/Deserialization/DeserializationOptions.hpp>
+#include <ArduinoJson/Deserialization/Reader.hpp>
+#include <ArduinoJson/Polyfills/utility.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+// A meta-function that returns the first type of the parameter pack
+// or void if empty
+template <typename...>
+struct first_or_void {
+  using type = void;
+};
+template <typename T, typename... Rest>
+struct first_or_void<T, Rest...> {
+  using type = T;
+};
+
+// A meta-function that returns true if T is a valid destination type for
+// deserialize()
+template <class T>
+using is_deserialize_destination =
+    bool_constant<is_base_of<JsonDocument, remove_cv_t<T>>::value ||
+                  IsVariant<T>::value>;
+
+template <typename TDestination>
+inline void shrinkJsonDocument(TDestination&) {
+  // no-op by default
+}
+
+#if ARDUINOJSON_AUTO_SHRINK
+inline void shrinkJsonDocument(JsonDocument& doc) {
+  doc.shrinkToFit();
+}
+#endif
+
+template <template <typename> class TDeserializer, typename TDestination,
+          typename TReader, typename TOptions>
+DeserializationError doDeserialize(TDestination&& dst, TReader reader,
+                                   TOptions options) {
+  auto data = VariantAttorney::getOrCreateData(dst);
+  if (!data)
+    return DeserializationError::NoMemory;
+  auto resources = VariantAttorney::getResourceManager(dst);
+  dst.clear();
+  auto err = TDeserializer<TReader>(resources, reader)
+                 .parse(*data, options.filter, options.nestingLimit);
+  shrinkJsonDocument(dst);
+  return err;
+}
+
+template <
+    template <typename> class TDeserializer, typename TDestination,
+    typename TStream, typename... Args,
+    enable_if_t<  // issue #1897
+        !is_integral<typename first_or_void<Args...>::type>::value, int> = 0>
+DeserializationError deserialize(TDestination&& dst, TStream&& input,
+                                 Args... args) {
+  return doDeserialize<TDeserializer>(
+      dst, makeReader(detail::forward<TStream>(input)),
+      makeDeserializationOptions(args...));
+}
+
+template <template <typename> class TDeserializer, typename TDestination,
+          typename TChar, typename Size, typename... Args,
+          enable_if_t<is_integral<Size>::value, int> = 0>
+DeserializationError deserialize(TDestination&& dst, TChar* input,
+                                 Size inputSize, Args... args) {
+  return doDeserialize<TDeserializer>(dst, makeReader(input, size_t(inputSize)),
+                                      makeDeserializationOptions(args...));
+}
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Document/JsonDocument.hpp b/lib/ArduinoJson/ArduinoJson/Document/JsonDocument.hpp
new file mode 100644
index 0000000..027aa01
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Document/JsonDocument.hpp
@@ -0,0 +1,426 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Array/ElementProxy.hpp>
+#include <ArduinoJson/Memory/Allocator.hpp>
+#include <ArduinoJson/Memory/ResourceManager.hpp>
+#include <ArduinoJson/Object/JsonObject.hpp>
+#include <ArduinoJson/Object/MemberProxy.hpp>
+#include <ArduinoJson/Polyfills/utility.hpp>
+#include <ArduinoJson/Variant/JsonVariantConst.hpp>
+#include <ArduinoJson/Variant/VariantTo.hpp>
+
+ARDUINOJSON_BEGIN_PUBLIC_NAMESPACE
+
+// A JSON document.
+// https://arduinojson.org/v7/api/jsondocument/
+class JsonDocument : public detail::VariantOperators<const JsonDocument&> {
+  friend class detail::VariantAttorney;
+
+ public:
+  explicit JsonDocument(Allocator* alloc = detail::DefaultAllocator::instance())
+      : resources_(alloc) {}
+
+  // Copy-constructor
+  JsonDocument(const JsonDocument& src) : JsonDocument(src.allocator()) {
+    set(src);
+  }
+
+  // Move-constructor
+  JsonDocument(JsonDocument&& src)
+      : JsonDocument(detail::DefaultAllocator::instance()) {
+    swap(*this, src);
+  }
+
+  // Construct from variant, array, or object
+  template <typename T,
+            detail::enable_if_t<detail::IsVariant<T>::value ||
+                                    detail::is_same<T, JsonArray>::value ||
+                                    detail::is_same<T, JsonArrayConst>::value ||
+                                    detail::is_same<T, JsonObject>::value ||
+                                    detail::is_same<T, JsonObjectConst>::value,
+                                int> = 0>
+  JsonDocument(const T& src,
+               Allocator* alloc = detail::DefaultAllocator::instance())
+      : JsonDocument(alloc) {
+    set(src);
+  }
+
+  JsonDocument& operator=(JsonDocument src) {
+    swap(*this, src);
+    return *this;
+  }
+
+  template <typename T>
+  JsonDocument& operator=(const T& src) {
+    set(src);
+    return *this;
+  }
+
+  Allocator* allocator() const {
+    return resources_.allocator();
+  }
+
+  // Reduces the capacity of the memory pool to match the current usage.
+  // https://arduinojson.org/v7/api/jsondocument/shrinktofit/
+  void shrinkToFit() {
+    resources_.shrinkToFit();
+  }
+
+  // Casts the root to the specified type.
+  // https://arduinojson.org/v7/api/jsondocument/as/
+  template <typename T>
+  T as() {
+    return getVariant().template as<T>();
+  }
+
+  // Casts the root to the specified type.
+  // https://arduinojson.org/v7/api/jsondocument/as/
+  template <typename T>
+  T as() const {
+    return getVariant().template as<T>();
+  }
+
+  // Empties the document and resets the memory pool
+  // https://arduinojson.org/v7/api/jsondocument/clear/
+  void clear() {
+    resources_.clear();
+    data_.reset();
+  }
+
+  // Returns true if the root is of the specified type.
+  // https://arduinojson.org/v7/api/jsondocument/is/
+  template <typename T>
+  bool is() {
+    return getVariant().template is<T>();
+  }
+
+  // Returns true if the root is of the specified type.
+  // https://arduinojson.org/v7/api/jsondocument/is/
+  template <typename T>
+  bool is() const {
+    return getVariant().template is<T>();
+  }
+
+  // Returns true if the root is null.
+  // https://arduinojson.org/v7/api/jsondocument/isnull/
+  bool isNull() const {
+    return getVariant().isNull();
+  }
+
+  // Returns trues if the memory pool was too small.
+  // https://arduinojson.org/v7/api/jsondocument/overflowed/
+  bool overflowed() const {
+    return resources_.overflowed();
+  }
+
+  // Returns the depth (nesting level) of the array.
+  // https://arduinojson.org/v7/api/jsondocument/nesting/
+  size_t nesting() const {
+    return data_.nesting(&resources_);
+  }
+
+  // Returns the number of elements in the root array or object.
+  // https://arduinojson.org/v7/api/jsondocument/size/
+  size_t size() const {
+    return data_.size(&resources_);
+  }
+
+  // Copies the specified document.
+  // https://arduinojson.org/v7/api/jsondocument/set/
+  bool set(const JsonDocument& src) {
+    return to<JsonVariant>().set(src.as<JsonVariantConst>());
+  }
+
+  // Replaces the root with the specified value.
+  // https://arduinojson.org/v7/api/jsondocument/set/
+  template <
+      typename T,
+      detail::enable_if_t<!detail::is_base_of<JsonDocument, T>::value, int> = 0>
+  bool set(const T& src) {
+    return to<JsonVariant>().set(src);
+  }
+
+  // Replaces the root with the specified value.
+  // https://arduinojson.org/v7/api/jsondocument/set/
+  template <typename TChar,
+            detail::enable_if_t<!detail::is_const<TChar>::value, int> = 0>
+  bool set(TChar* src) {
+    return to<JsonVariant>().set(src);
+  }
+
+  // Clears the document and converts it to the specified type.
+  // https://arduinojson.org/v7/api/jsondocument/to/
+  template <typename T>
+  typename detail::VariantTo<T>::type to() {
+    clear();
+    return getVariant().template to<T>();
+  }
+
+  // DEPRECATED: use obj["key"].is<T>() instead
+  // https://arduinojson.org/v7/api/jsondocument/containskey/
+  template <typename TChar>
+  ARDUINOJSON_DEPRECATED("use doc[\"key\"].is<T>() instead")
+  bool containsKey(TChar* key) const {
+    return data_.getMember(detail::adaptString(key), &resources_) != 0;
+  }
+
+  // DEPRECATED: use obj[key].is<T>() instead
+  // https://arduinojson.org/v7/api/jsondocument/containskey/
+  template <typename TString,
+            detail::enable_if_t<detail::IsString<TString>::value, int> = 0>
+  ARDUINOJSON_DEPRECATED("use doc[key].is<T>() instead")
+  bool containsKey(const TString& key) const {
+    return data_.getMember(detail::adaptString(key), &resources_) != 0;
+  }
+
+  // DEPRECATED: use obj[key].is<T>() instead
+  // https://arduinojson.org/v7/api/jsondocument/containskey/
+  template <typename TVariant,
+            detail::enable_if_t<detail::IsVariant<TVariant>::value, int> = 0>
+  ARDUINOJSON_DEPRECATED("use doc[key].is<T>() instead")
+  bool containsKey(const TVariant& key) const {
+    return containsKey(key.template as<const char*>());
+  }
+
+  // Gets or sets a root object's member.
+  // https://arduinojson.org/v7/api/jsondocument/subscript/
+  template <typename TString,
+            detail::enable_if_t<detail::IsString<TString>::value, int> = 0>
+  detail::MemberProxy<JsonDocument&, detail::AdaptedString<TString>> operator[](
+      const TString& key) {
+    return {*this, detail::adaptString(key)};
+  }
+
+  // Gets or sets a root object's member.
+  // https://arduinojson.org/v7/api/jsondocument/subscript/
+  template <typename TChar,
+            detail::enable_if_t<detail::IsString<TChar*>::value &&
+                                    !detail::is_const<TChar>::value,
+                                int> = 0>
+  detail::MemberProxy<JsonDocument&, detail::AdaptedString<TChar*>> operator[](
+      TChar* key) {
+    return {*this, detail::adaptString(key)};
+  }
+
+  // Gets a root object's member.
+  // https://arduinojson.org/v7/api/jsondocument/subscript/
+  template <typename TString,
+            detail::enable_if_t<detail::IsString<TString>::value, int> = 0>
+  JsonVariantConst operator[](const TString& key) const {
+    return JsonVariantConst(
+        data_.getMember(detail::adaptString(key), &resources_), &resources_);
+  }
+
+  // Gets a root object's member.
+  // https://arduinojson.org/v7/api/jsondocument/subscript/
+  template <typename TChar,
+            detail::enable_if_t<detail::IsString<TChar*>::value &&
+                                    !detail::is_const<TChar>::value,
+                                int> = 0>
+  JsonVariantConst operator[](TChar* key) const {
+    return JsonVariantConst(
+        data_.getMember(detail::adaptString(key), &resources_), &resources_);
+  }
+
+  // Gets or sets a root array's element.
+  // https://arduinojson.org/v7/api/jsondocument/subscript/
+  template <typename T,
+            detail::enable_if_t<detail::is_integral<T>::value, int> = 0>
+  detail::ElementProxy<JsonDocument&> operator[](T index) {
+    return {*this, size_t(index)};
+  }
+
+  // Gets a root array's member.
+  // https://arduinojson.org/v7/api/jsondocument/subscript/
+  JsonVariantConst operator[](size_t index) const {
+    return JsonVariantConst(data_.getElement(index, &resources_), &resources_);
+  }
+
+  // Gets or sets a root object's member.
+  // https://arduinojson.org/v7/api/jsondocument/subscript/
+  template <typename TVariant,
+            detail::enable_if_t<detail::IsVariant<TVariant>::value, int> = 0>
+  JsonVariantConst operator[](const TVariant& key) const {
+    if (key.template is<JsonString>())
+      return operator[](key.template as<JsonString>());
+    if (key.template is<size_t>())
+      return operator[](key.template as<size_t>());
+    return {};
+  }
+
+  // Appends a new (empty) element to the root array.
+  // Returns a reference to the new element.
+  // https://arduinojson.org/v7/api/jsondocument/add/
+  template <typename T, detail::enable_if_t<
+                            !detail::is_same<T, JsonVariant>::value, int> = 0>
+  T add() {
+    return add<JsonVariant>().to<T>();
+  }
+
+  // Appends a new (null) element to the root array.
+  // Returns a reference to the new element.
+  // https://arduinojson.org/v7/api/jsondocument/add/
+  template <typename T, detail::enable_if_t<
+                            detail::is_same<T, JsonVariant>::value, int> = 0>
+  JsonVariant add() {
+    return JsonVariant(data_.addElement(&resources_), &resources_);
+  }
+
+  // Appends a value to the root array.
+  // https://arduinojson.org/v7/api/jsondocument/add/
+  template <typename TValue>
+  bool add(const TValue& value) {
+    return data_.addValue(value, &resources_);
+  }
+
+  // Appends a value to the root array.
+  // https://arduinojson.org/v7/api/jsondocument/add/
+  template <typename TChar,
+            detail::enable_if_t<!detail::is_const<TChar>::value, int> = 0>
+  bool add(TChar* value) {
+    return data_.addValue(value, &resources_);
+  }
+
+  // Removes an element of the root array.
+  // https://arduinojson.org/v7/api/jsondocument/remove/
+  template <typename T,
+            detail::enable_if_t<detail::is_integral<T>::value, int> = 0>
+  void remove(T index) {
+    detail::VariantData::removeElement(getData(), size_t(index),
+                                       getResourceManager());
+  }
+
+  // Removes a member of the root object.
+  // https://arduinojson.org/v7/api/jsondocument/remove/
+  template <typename TChar,
+            detail::enable_if_t<detail::IsString<TChar*>::value &&
+                                    !detail::is_const<TChar>::value,
+                                int> = 0>
+  void remove(TChar* key) {
+    detail::VariantData::removeMember(getData(), detail::adaptString(key),
+                                      getResourceManager());
+  }
+
+  // Removes a member of the root object.
+  // https://arduinojson.org/v7/api/jsondocument/remove/
+  template <typename TString,
+            detail::enable_if_t<detail::IsString<TString>::value, int> = 0>
+  void remove(const TString& key) {
+    detail::VariantData::removeMember(getData(), detail::adaptString(key),
+                                      getResourceManager());
+  }
+
+  // Removes a member of the root object or an element of the root array.
+  // https://arduinojson.org/v7/api/jsondocument/remove/
+  template <typename TVariant,
+            detail::enable_if_t<detail::IsVariant<TVariant>::value, int> = 0>
+  void remove(const TVariant& key) {
+    if (key.template is<const char*>())
+      remove(key.template as<const char*>());
+    if (key.template is<size_t>())
+      remove(key.template as<size_t>());
+  }
+
+  operator JsonVariant() {
+    return getVariant();
+  }
+
+  operator JsonVariantConst() const {
+    return getVariant();
+  }
+
+  friend void swap(JsonDocument& a, JsonDocument& b) {
+    swap(a.resources_, b.resources_);
+    swap_(a.data_, b.data_);
+  }
+
+  // DEPRECATED: use add<JsonVariant>() instead
+  ARDUINOJSON_DEPRECATED("use add<JsonVariant>() instead")
+  JsonVariant add() {
+    return add<JsonVariant>();
+  }
+
+  // DEPRECATED: use add<JsonArray>() instead
+  ARDUINOJSON_DEPRECATED("use add<JsonArray>() instead")
+  JsonArray createNestedArray() {
+    return add<JsonArray>();
+  }
+
+  // DEPRECATED: use doc[key].to<JsonArray>() instead
+  template <typename TChar>
+  ARDUINOJSON_DEPRECATED("use doc[key].to<JsonArray>() instead")
+  JsonArray createNestedArray(TChar* key) {
+    return operator[](key).template to<JsonArray>();
+  }
+
+  // DEPRECATED: use doc[key].to<JsonArray>() instead
+  template <typename TString>
+  ARDUINOJSON_DEPRECATED("use doc[key].to<JsonArray>() instead")
+  JsonArray createNestedArray(const TString& key) {
+    return operator[](key).template to<JsonArray>();
+  }
+
+  // DEPRECATED: use add<JsonObject>() instead
+  ARDUINOJSON_DEPRECATED("use add<JsonObject>() instead")
+  JsonObject createNestedObject() {
+    return add<JsonObject>();
+  }
+
+  // DEPRECATED: use doc[key].to<JsonObject>() instead
+  template <typename TChar>
+  ARDUINOJSON_DEPRECATED("use doc[key].to<JsonObject>() instead")
+  JsonObject createNestedObject(TChar* key) {
+    return operator[](key).template to<JsonObject>();
+  }
+
+  // DEPRECATED: use doc[key].to<JsonObject>() instead
+  template <typename TString>
+  ARDUINOJSON_DEPRECATED("use doc[key].to<JsonObject>() instead")
+  JsonObject createNestedObject(const TString& key) {
+    return operator[](key).template to<JsonObject>();
+  }
+
+  // DEPRECATED: always returns zero
+  ARDUINOJSON_DEPRECATED("always returns zero")
+  size_t memoryUsage() const {
+    return 0;
+  }
+
+ private:
+  JsonVariant getVariant() {
+    return JsonVariant(&data_, &resources_);
+  }
+
+  JsonVariantConst getVariant() const {
+    return JsonVariantConst(&data_, &resources_);
+  }
+
+  detail::ResourceManager* getResourceManager() {
+    return &resources_;
+  }
+
+  detail::VariantData* getData() {
+    return &data_;
+  }
+
+  const detail::VariantData* getData() const {
+    return &data_;
+  }
+
+  detail::VariantData* getOrCreateData() {
+    return &data_;
+  }
+
+  detail::ResourceManager resources_;
+  detail::VariantData data_;
+};
+
+inline void convertToJson(const JsonDocument& src, JsonVariant dst) {
+  dst.set(src.as<JsonVariantConst>());
+}
+
+ARDUINOJSON_END_PUBLIC_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Json/EscapeSequence.hpp b/lib/ArduinoJson/ArduinoJson/Json/EscapeSequence.hpp
new file mode 100644
index 0000000..a52c044
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Json/EscapeSequence.hpp
@@ -0,0 +1,40 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+class EscapeSequence {
+ public:
+  // Optimized for code size on a 8-bit AVR
+  static char escapeChar(char c) {
+    const char* p = escapeTable(true);
+    while (p[0] && p[1] != c) {
+      p += 2;
+    }
+    return p[0];
+  }
+
+  // Optimized for code size on a 8-bit AVR
+  static char unescapeChar(char c) {
+    const char* p = escapeTable(false);
+    for (;;) {
+      if (p[0] == '\0')
+        return 0;
+      if (p[0] == c)
+        return p[1];
+      p += 2;
+    }
+  }
+
+ private:
+  static const char* escapeTable(bool isSerializing) {
+    return &"//''\"\"\\\\b\bf\fn\nr\rt\t"[isSerializing ? 4 : 0];
+  }
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Json/JsonDeserializer.hpp b/lib/ArduinoJson/ArduinoJson/Json/JsonDeserializer.hpp
new file mode 100644
index 0000000..5add23b
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Json/JsonDeserializer.hpp
@@ -0,0 +1,720 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Deserialization/deserialize.hpp>
+#include <ArduinoJson/Json/EscapeSequence.hpp>
+#include <ArduinoJson/Json/Latch.hpp>
+#include <ArduinoJson/Json/Utf16.hpp>
+#include <ArduinoJson/Json/Utf8.hpp>
+#include <ArduinoJson/Memory/ResourceManager.hpp>
+#include <ArduinoJson/Numbers/parseNumber.hpp>
+#include <ArduinoJson/Polyfills/assert.hpp>
+#include <ArduinoJson/Polyfills/type_traits.hpp>
+#include <ArduinoJson/Polyfills/utility.hpp>
+#include <ArduinoJson/Variant/VariantData.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <typename TReader>
+class JsonDeserializer {
+ public:
+  JsonDeserializer(ResourceManager* resources, TReader reader)
+      : stringBuilder_(resources),
+        foundSomething_(false),
+        latch_(reader),
+        resources_(resources) {}
+
+  template <typename TFilter>
+  DeserializationError parse(VariantData& variant, TFilter filter,
+                             DeserializationOption::NestingLimit nestingLimit) {
+    DeserializationError::Code err;
+
+    err = parseVariant(variant, filter, nestingLimit);
+
+    if (!err && latch_.last() != 0 && variant.isFloat()) {
+      // We don't detect trailing characters earlier, so we need to check now
+      return DeserializationError::InvalidInput;
+    }
+
+    return err;
+  }
+
+ private:
+  char current() {
+    return latch_.current();
+  }
+
+  void move() {
+    latch_.clear();
+  }
+
+  bool eat(char charToSkip) {
+    if (current() != charToSkip)
+      return false;
+    move();
+    return true;
+  }
+
+  template <typename TFilter>
+  DeserializationError::Code parseVariant(
+      VariantData& variant, TFilter filter,
+      DeserializationOption::NestingLimit nestingLimit) {
+    DeserializationError::Code err;
+
+    err = skipSpacesAndComments();
+    if (err)
+      return err;
+
+    switch (current()) {
+      case '[':
+        if (filter.allowArray())
+          return parseArray(variant.toArray(), filter, nestingLimit);
+        else
+          return skipArray(nestingLimit);
+
+      case '{':
+        if (filter.allowObject())
+          return parseObject(variant.toObject(), filter, nestingLimit);
+        else
+          return skipObject(nestingLimit);
+
+      case '\"':
+      case '\'':
+        if (filter.allowValue())
+          return parseStringValue(variant);
+        else
+          return skipQuotedString();
+
+      case 't':
+        if (filter.allowValue())
+          variant.setBoolean(true);
+        return skipKeyword("true");
+
+      case 'f':
+        if (filter.allowValue())
+          variant.setBoolean(false);
+        return skipKeyword("false");
+
+      case 'n':
+        // the variant should already by null, except if the same object key was
+        // used twice, as in {"a":1,"a":null}
+        return skipKeyword("null");
+
+      default:
+        if (filter.allowValue())
+          return parseNumericValue(variant);
+        else
+          return skipNumericValue();
+    }
+  }
+
+  DeserializationError::Code skipVariant(
+      DeserializationOption::NestingLimit nestingLimit) {
+    DeserializationError::Code err;
+
+    err = skipSpacesAndComments();
+    if (err)
+      return err;
+
+    switch (current()) {
+      case '[':
+        return skipArray(nestingLimit);
+
+      case '{':
+        return skipObject(nestingLimit);
+
+      case '\"':
+      case '\'':
+        return skipQuotedString();
+
+      case 't':
+        return skipKeyword("true");
+
+      case 'f':
+        return skipKeyword("false");
+
+      case 'n':
+        return skipKeyword("null");
+
+      default:
+        return skipNumericValue();
+    }
+  }
+
+  template <typename TFilter>
+  DeserializationError::Code parseArray(
+      ArrayData& array, TFilter filter,
+      DeserializationOption::NestingLimit nestingLimit) {
+    DeserializationError::Code err;
+
+    if (nestingLimit.reached())
+      return DeserializationError::TooDeep;
+
+    // Skip opening braket
+    ARDUINOJSON_ASSERT(current() == '[');
+    move();
+
+    // Skip spaces
+    err = skipSpacesAndComments();
+    if (err)
+      return err;
+
+    // Empty array?
+    if (eat(']'))
+      return DeserializationError::Ok;
+
+    TFilter elementFilter = filter[0UL];
+
+    // Read each value
+    for (;;) {
+      if (elementFilter.allow()) {
+        // Allocate slot in array
+        VariantData* value = array.addElement(resources_);
+        if (!value)
+          return DeserializationError::NoMemory;
+
+        // 1 - Parse value
+        err = parseVariant(*value, elementFilter, nestingLimit.decrement());
+        if (err)
+          return err;
+      } else {
+        err = skipVariant(nestingLimit.decrement());
+        if (err)
+          return err;
+      }
+
+      // 2 - Skip spaces
+      err = skipSpacesAndComments();
+      if (err)
+        return err;
+
+      // 3 - More values?
+      if (eat(']'))
+        return DeserializationError::Ok;
+      if (!eat(','))
+        return DeserializationError::InvalidInput;
+    }
+  }
+
+  DeserializationError::Code skipArray(
+      DeserializationOption::NestingLimit nestingLimit) {
+    DeserializationError::Code err;
+
+    if (nestingLimit.reached())
+      return DeserializationError::TooDeep;
+
+    // Skip opening braket
+    ARDUINOJSON_ASSERT(current() == '[');
+    move();
+
+    // Read each value
+    for (;;) {
+      // 1 - Skip value
+      err = skipVariant(nestingLimit.decrement());
+      if (err)
+        return err;
+
+      // 2 - Skip spaces
+      err = skipSpacesAndComments();
+      if (err)
+        return err;
+
+      // 3 - More values?
+      if (eat(']'))
+        return DeserializationError::Ok;
+      if (!eat(','))
+        return DeserializationError::InvalidInput;
+    }
+  }
+
+  template <typename TFilter>
+  DeserializationError::Code parseObject(
+      ObjectData& object, TFilter filter,
+      DeserializationOption::NestingLimit nestingLimit) {
+    DeserializationError::Code err;
+
+    if (nestingLimit.reached())
+      return DeserializationError::TooDeep;
+
+    // Skip opening brace
+    ARDUINOJSON_ASSERT(current() == '{');
+    move();
+
+    // Skip spaces
+    err = skipSpacesAndComments();
+    if (err)
+      return err;
+
+    // Empty object?
+    if (eat('}'))
+      return DeserializationError::Ok;
+
+    // Read each key value pair
+    for (;;) {
+      // Parse key
+      err = parseKey();
+      if (err)
+        return err;
+
+      // Skip spaces
+      err = skipSpacesAndComments();
+      if (err)
+        return err;
+
+      // Colon
+      if (!eat(':'))
+        return DeserializationError::InvalidInput;
+
+      JsonString key = stringBuilder_.str();
+
+      TFilter memberFilter = filter[key];
+
+      if (memberFilter.allow()) {
+        auto member = object.getMember(adaptString(key), resources_);
+        if (!member) {
+          auto keyVariant = object.addPair(&member, resources_);
+          if (!keyVariant)
+            return DeserializationError::NoMemory;
+
+          stringBuilder_.save(keyVariant);
+        } else {
+          member->clear(resources_);
+        }
+
+        // Parse value
+        err = parseVariant(*member, memberFilter, nestingLimit.decrement());
+        if (err)
+          return err;
+      } else {
+        err = skipVariant(nestingLimit.decrement());
+        if (err)
+          return err;
+      }
+
+      // Skip spaces
+      err = skipSpacesAndComments();
+      if (err)
+        return err;
+
+      // More keys/values?
+      if (eat('}'))
+        return DeserializationError::Ok;
+      if (!eat(','))
+        return DeserializationError::InvalidInput;
+
+      // Skip spaces
+      err = skipSpacesAndComments();
+      if (err)
+        return err;
+    }
+  }
+
+  DeserializationError::Code skipObject(
+      DeserializationOption::NestingLimit nestingLimit) {
+    DeserializationError::Code err;
+
+    if (nestingLimit.reached())
+      return DeserializationError::TooDeep;
+
+    // Skip opening brace
+    ARDUINOJSON_ASSERT(current() == '{');
+    move();
+
+    // Skip spaces
+    err = skipSpacesAndComments();
+    if (err)
+      return err;
+
+    // Empty object?
+    if (eat('}'))
+      return DeserializationError::Ok;
+
+    // Read each key value pair
+    for (;;) {
+      // Skip key
+      err = skipKey();
+      if (err)
+        return err;
+
+      // Skip spaces
+      err = skipSpacesAndComments();
+      if (err)
+        return err;
+
+      // Colon
+      if (!eat(':'))
+        return DeserializationError::InvalidInput;
+
+      // Skip value
+      err = skipVariant(nestingLimit.decrement());
+      if (err)
+        return err;
+
+      // Skip spaces
+      err = skipSpacesAndComments();
+      if (err)
+        return err;
+
+      // More keys/values?
+      if (eat('}'))
+        return DeserializationError::Ok;
+      if (!eat(','))
+        return DeserializationError::InvalidInput;
+
+      err = skipSpacesAndComments();
+      if (err)
+        return err;
+    }
+  }
+
+  DeserializationError::Code parseKey() {
+    stringBuilder_.startString();
+    if (isQuote(current())) {
+      return parseQuotedString();
+    } else {
+      return parseNonQuotedString();
+    }
+  }
+
+  DeserializationError::Code parseStringValue(VariantData& variant) {
+    DeserializationError::Code err;
+
+    stringBuilder_.startString();
+
+    err = parseQuotedString();
+    if (err)
+      return err;
+
+    stringBuilder_.save(&variant);
+
+    return DeserializationError::Ok;
+  }
+
+  DeserializationError::Code parseQuotedString() {
+#if ARDUINOJSON_DECODE_UNICODE
+    Utf16::Codepoint codepoint;
+    DeserializationError::Code err;
+#endif
+    const char stopChar = current();
+
+    move();
+    for (;;) {
+      char c = current();
+      move();
+      if (c == stopChar)
+        break;
+
+      if (c == '\0')
+        return DeserializationError::IncompleteInput;
+
+      if (c == '\\') {
+        c = current();
+
+        if (c == '\0')
+          return DeserializationError::IncompleteInput;
+
+        if (c == 'u') {
+#if ARDUINOJSON_DECODE_UNICODE
+          move();
+          uint16_t codeunit;
+          err = parseHex4(codeunit);
+          if (err)
+            return err;
+          if (codepoint.append(codeunit))
+            Utf8::encodeCodepoint(codepoint.value(), stringBuilder_);
+#else
+          stringBuilder_.append('\\');
+#endif
+          continue;
+        }
+
+        // replace char
+        c = EscapeSequence::unescapeChar(c);
+        if (c == '\0')
+          return DeserializationError::InvalidInput;
+        move();
+      }
+
+      stringBuilder_.append(c);
+    }
+
+    if (!stringBuilder_.isValid())
+      return DeserializationError::NoMemory;
+
+    return DeserializationError::Ok;
+  }
+
+  DeserializationError::Code parseNonQuotedString() {
+    char c = current();
+    ARDUINOJSON_ASSERT(c);
+
+    if (canBeInNonQuotedString(c)) {  // no quotes
+      do {
+        move();
+        stringBuilder_.append(c);
+        c = current();
+      } while (canBeInNonQuotedString(c));
+    } else {
+      return DeserializationError::InvalidInput;
+    }
+
+    if (!stringBuilder_.isValid())
+      return DeserializationError::NoMemory;
+
+    return DeserializationError::Ok;
+  }
+
+  DeserializationError::Code skipKey() {
+    if (isQuote(current())) {
+      return skipQuotedString();
+    } else {
+      return skipNonQuotedString();
+    }
+  }
+
+  DeserializationError::Code skipQuotedString() {
+    const char stopChar = current();
+
+    move();
+    for (;;) {
+      char c = current();
+      move();
+      if (c == stopChar)
+        break;
+      if (c == '\0')
+        return DeserializationError::IncompleteInput;
+      if (c == '\\') {
+        if (current() != '\0')
+          move();
+      }
+    }
+
+    return DeserializationError::Ok;
+  }
+
+  DeserializationError::Code skipNonQuotedString() {
+    char c = current();
+    while (canBeInNonQuotedString(c)) {
+      move();
+      c = current();
+    }
+    return DeserializationError::Ok;
+  }
+
+  DeserializationError::Code parseNumericValue(VariantData& result) {
+    uint8_t n = 0;
+
+    char c = current();
+    while (canBeInNumber(c) && n < 63) {
+      move();
+      buffer_[n++] = c;
+      c = current();
+    }
+    buffer_[n] = 0;
+
+    auto number = parseNumber(buffer_);
+    switch (number.type()) {
+      case NumberType::UnsignedInteger:
+        if (result.setInteger(number.asUnsignedInteger(), resources_))
+          return DeserializationError::Ok;
+        else
+          return DeserializationError::NoMemory;
+
+      case NumberType::SignedInteger:
+        if (result.setInteger(number.asSignedInteger(), resources_))
+          return DeserializationError::Ok;
+        else
+          return DeserializationError::NoMemory;
+
+      case NumberType::Float:
+        if (result.setFloat(number.asFloat(), resources_))
+          return DeserializationError::Ok;
+        else
+          return DeserializationError::NoMemory;
+
+#if ARDUINOJSON_USE_DOUBLE
+      case NumberType::Double:
+        if (result.setFloat(number.asDouble(), resources_))
+          return DeserializationError::Ok;
+        else
+          return DeserializationError::NoMemory;
+#endif
+
+      default:
+        return DeserializationError::InvalidInput;
+    }
+  }
+
+  DeserializationError::Code skipNumericValue() {
+    char c = current();
+    while (canBeInNumber(c)) {
+      move();
+      c = current();
+    }
+    return DeserializationError::Ok;
+  }
+
+  DeserializationError::Code parseHex4(uint16_t& result) {
+    result = 0;
+    for (uint8_t i = 0; i < 4; ++i) {
+      char digit = current();
+      if (!digit)
+        return DeserializationError::IncompleteInput;
+      uint8_t value = decodeHex(digit);
+      if (value > 0x0F)
+        return DeserializationError::InvalidInput;
+      result = uint16_t((result << 4) | value);
+      move();
+    }
+    return DeserializationError::Ok;
+  }
+
+  static inline bool isBetween(char c, char min, char max) {
+    return min <= c && c <= max;
+  }
+
+  static inline bool canBeInNumber(char c) {
+    return isBetween(c, '0', '9') || c == '+' || c == '-' || c == '.' ||
+#if ARDUINOJSON_ENABLE_NAN || ARDUINOJSON_ENABLE_INFINITY
+           isBetween(c, 'A', 'Z') || isBetween(c, 'a', 'z');
+#else
+           c == 'e' || c == 'E';
+#endif
+  }
+
+  static inline bool canBeInNonQuotedString(char c) {
+    return isBetween(c, '0', '9') || isBetween(c, '_', 'z') ||
+           isBetween(c, 'A', 'Z');
+  }
+
+  static inline bool isQuote(char c) {
+    return c == '\'' || c == '\"';
+  }
+
+  static inline uint8_t decodeHex(char c) {
+    if (c < 'A')
+      return uint8_t(c - '0');
+    c = char(c & ~0x20);  // uppercase
+    return uint8_t(c - 'A' + 10);
+  }
+
+  DeserializationError::Code skipSpacesAndComments() {
+    for (;;) {
+      switch (current()) {
+        // end of string
+        case '\0':
+          return foundSomething_ ? DeserializationError::IncompleteInput
+                                 : DeserializationError::EmptyInput;
+
+        // spaces
+        case ' ':
+        case '\t':
+        case '\r':
+        case '\n':
+          move();
+          continue;
+
+#if ARDUINOJSON_ENABLE_COMMENTS
+        // comments
+        case '/':
+          move();  // skip '/'
+          switch (current()) {
+            // block comment
+            case '*': {
+              move();  // skip '*'
+              bool wasStar = false;
+              for (;;) {
+                char c = current();
+                if (c == '\0')
+                  return DeserializationError::IncompleteInput;
+                if (c == '/' && wasStar) {
+                  move();
+                  break;
+                }
+                wasStar = c == '*';
+                move();
+              }
+              break;
+            }
+
+            // trailing comment
+            case '/':
+              // no need to skip "//"
+              for (;;) {
+                move();
+                char c = current();
+                if (c == '\0')
+                  return DeserializationError::IncompleteInput;
+                if (c == '\n')
+                  break;
+              }
+              break;
+
+            // not a comment, just a '/'
+            default:
+              return DeserializationError::InvalidInput;
+          }
+          break;
+#endif
+
+        default:
+          foundSomething_ = true;
+          return DeserializationError::Ok;
+      }
+    }
+  }
+
+  DeserializationError::Code skipKeyword(const char* s) {
+    while (*s) {
+      char c = current();
+      if (c == '\0')
+        return DeserializationError::IncompleteInput;
+      if (*s != c)
+        return DeserializationError::InvalidInput;
+      ++s;
+      move();
+    }
+    return DeserializationError::Ok;
+  }
+
+  StringBuilder stringBuilder_;
+  bool foundSomething_;
+  Latch<TReader> latch_;
+  ResourceManager* resources_;
+  char buffer_[64];  // using a member instead of a local variable because it
+                     // ended in the recursive path after compiler inlined the
+                     // code
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
+
+ARDUINOJSON_BEGIN_PUBLIC_NAMESPACE
+
+// Parses a JSON input, filters, and puts the result in a JsonDocument.
+// https://arduinojson.org/v7/api/json/deserializejson/
+template <typename TDestination, typename... Args,
+          detail::enable_if_t<
+              detail::is_deserialize_destination<TDestination>::value, int> = 0>
+inline DeserializationError deserializeJson(TDestination&& dst,
+                                            Args&&... args) {
+  using namespace detail;
+  return deserialize<JsonDeserializer>(detail::forward<TDestination>(dst),
+                                       detail::forward<Args>(args)...);
+}
+
+// Parses a JSON input, filters, and puts the result in a JsonDocument.
+// https://arduinojson.org/v7/api/json/deserializejson/
+template <typename TDestination, typename TChar, typename... Args,
+          detail::enable_if_t<
+              detail::is_deserialize_destination<TDestination>::value, int> = 0>
+inline DeserializationError deserializeJson(TDestination&& dst, TChar* input,
+                                            Args&&... args) {
+  using namespace detail;
+  return deserialize<JsonDeserializer>(detail::forward<TDestination>(dst),
+                                       input, detail::forward<Args>(args)...);
+}
+
+ARDUINOJSON_END_PUBLIC_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Json/JsonSerializer.hpp b/lib/ArduinoJson/ArduinoJson/Json/JsonSerializer.hpp
new file mode 100644
index 0000000..81a9933
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Json/JsonSerializer.hpp
@@ -0,0 +1,165 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Json/TextFormatter.hpp>
+#include <ArduinoJson/Serialization/measure.hpp>
+#include <ArduinoJson/Serialization/serialize.hpp>
+#include <ArduinoJson/Variant/VariantDataVisitor.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <typename TWriter>
+class JsonSerializer : public VariantDataVisitor<size_t> {
+ public:
+  static const bool producesText = true;
+
+  JsonSerializer(TWriter writer, const ResourceManager* resources)
+      : formatter_(writer), resources_(resources) {}
+
+  size_t visit(const ArrayData& array) {
+    write('[');
+
+    auto slotId = array.head();
+
+    while (slotId != NULL_SLOT) {
+      auto slot = resources_->getVariant(slotId);
+
+      slot->accept(*this, resources_);
+
+      slotId = slot->next();
+
+      if (slotId != NULL_SLOT)
+        write(',');
+    }
+
+    write(']');
+    return bytesWritten();
+  }
+
+  size_t visit(const ObjectData& object) {
+    write('{');
+
+    auto slotId = object.head();
+
+    bool isKey = true;
+
+    while (slotId != NULL_SLOT) {
+      auto slot = resources_->getVariant(slotId);
+      slot->accept(*this, resources_);
+
+      slotId = slot->next();
+
+      if (slotId != NULL_SLOT)
+        write(isKey ? ':' : ',');
+
+      isKey = !isKey;
+    }
+
+    write('}');
+    return bytesWritten();
+  }
+
+  template <typename T>
+  enable_if_t<is_floating_point<T>::value, size_t> visit(T value) {
+    formatter_.writeFloat(value);
+    return bytesWritten();
+  }
+
+  size_t visit(const char* value) {
+    formatter_.writeString(value);
+    return bytesWritten();
+  }
+
+  size_t visit(JsonString value) {
+    formatter_.writeString(value.c_str(), value.size());
+    return bytesWritten();
+  }
+
+  size_t visit(RawString value) {
+    formatter_.writeRaw(value.data(), value.size());
+    return bytesWritten();
+  }
+
+  size_t visit(JsonInteger value) {
+    formatter_.writeInteger(value);
+    return bytesWritten();
+  }
+
+  size_t visit(JsonUInt value) {
+    formatter_.writeInteger(value);
+    return bytesWritten();
+  }
+
+  size_t visit(bool value) {
+    formatter_.writeBoolean(value);
+    return bytesWritten();
+  }
+
+  size_t visit(nullptr_t) {
+    formatter_.writeRaw("null");
+    return bytesWritten();
+  }
+
+ protected:
+  size_t bytesWritten() const {
+    return formatter_.bytesWritten();
+  }
+
+  void write(char c) {
+    formatter_.writeRaw(c);
+  }
+
+  void write(const char* s) {
+    formatter_.writeRaw(s);
+  }
+
+ private:
+  TextFormatter<TWriter> formatter_;
+
+ protected:
+  const ResourceManager* resources_;
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
+
+ARDUINOJSON_BEGIN_PUBLIC_NAMESPACE
+
+// Produces a minified JSON document.
+// https://arduinojson.org/v7/api/json/serializejson/
+template <
+    typename TDestination,
+    detail::enable_if_t<!detail::is_pointer<TDestination>::value, int> = 0>
+size_t serializeJson(JsonVariantConst source, TDestination& destination) {
+  using namespace detail;
+  return serialize<JsonSerializer>(source, destination);
+}
+
+// Produces a minified JSON document.
+// https://arduinojson.org/v7/api/json/serializejson/
+inline size_t serializeJson(JsonVariantConst source, void* buffer,
+                            size_t bufferSize) {
+  using namespace detail;
+  return serialize<JsonSerializer>(source, buffer, bufferSize);
+}
+
+// Computes the length of the document that serializeJson() produces.
+// https://arduinojson.org/v7/api/json/measurejson/
+inline size_t measureJson(JsonVariantConst source) {
+  using namespace detail;
+  return measure<JsonSerializer>(source);
+}
+
+#if ARDUINOJSON_ENABLE_STD_STREAM
+template <typename T,
+          detail::enable_if_t<
+              detail::is_convertible<T, JsonVariantConst>::value, int> = 0>
+inline std::ostream& operator<<(std::ostream& os, const T& source) {
+  serializeJson(source, os);
+  return os;
+}
+#endif
+
+ARDUINOJSON_END_PUBLIC_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Json/Latch.hpp b/lib/ArduinoJson/ArduinoJson/Json/Latch.hpp
new file mode 100644
index 0000000..f9a5a9b
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Json/Latch.hpp
@@ -0,0 +1,56 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Polyfills/assert.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <typename TReader>
+class Latch {
+ public:
+  Latch(TReader reader) : reader_(reader), loaded_(false) {
+#if ARDUINOJSON_DEBUG
+    ended_ = false;
+#endif
+  }
+
+  void clear() {
+    loaded_ = false;
+  }
+
+  int last() const {
+    return current_;
+  }
+
+  FORCE_INLINE char current() {
+    if (!loaded_) {
+      load();
+    }
+    return current_;
+  }
+
+ private:
+  void load() {
+    ARDUINOJSON_ASSERT(!ended_);
+    int c = reader_.read();
+#if ARDUINOJSON_DEBUG
+    if (c <= 0)
+      ended_ = true;
+#endif
+    current_ = static_cast<char>(c > 0 ? c : 0);
+    loaded_ = true;
+  }
+
+  TReader reader_;
+  char current_;  // NOLINT(clang-analyzer-optin.cplusplus.UninitializedObject)
+                  // Not initialized in constructor (+10 bytes on AVR)
+  bool loaded_;
+#if ARDUINOJSON_DEBUG
+  bool ended_;
+#endif
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Json/PrettyJsonSerializer.hpp b/lib/ArduinoJson/ArduinoJson/Json/PrettyJsonSerializer.hpp
new file mode 100644
index 0000000..9de517b
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Json/PrettyJsonSerializer.hpp
@@ -0,0 +1,110 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Configuration.hpp>
+#include <ArduinoJson/Json/JsonSerializer.hpp>
+#include <ArduinoJson/Serialization/measure.hpp>
+#include <ArduinoJson/Serialization/serialize.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <typename TWriter>
+class PrettyJsonSerializer : public JsonSerializer<TWriter> {
+  using base = JsonSerializer<TWriter>;
+
+ public:
+  PrettyJsonSerializer(TWriter writer, const ResourceManager* resources)
+      : base(writer, resources), nesting_(0) {}
+
+  size_t visit(const ArrayData& array) {
+    auto it = array.createIterator(base::resources_);
+    if (!it.done()) {
+      base::write("[\r\n");
+      nesting_++;
+      while (!it.done()) {
+        indent();
+        it->accept(*this, base::resources_);
+
+        it.next(base::resources_);
+        base::write(it.done() ? "\r\n" : ",\r\n");
+      }
+      nesting_--;
+      indent();
+      base::write("]");
+    } else {
+      base::write("[]");
+    }
+    return this->bytesWritten();
+  }
+
+  size_t visit(const ObjectData& object) {
+    auto it = object.createIterator(base::resources_);
+    if (!it.done()) {
+      base::write("{\r\n");
+      nesting_++;
+      bool isKey = true;
+      while (!it.done()) {
+        if (isKey)
+          indent();
+        it->accept(*this, base::resources_);
+        it.next(base::resources_);
+        if (isKey)
+          base::write(": ");
+        else
+          base::write(it.done() ? "\r\n" : ",\r\n");
+        isKey = !isKey;
+      }
+      nesting_--;
+      indent();
+      base::write("}");
+    } else {
+      base::write("{}");
+    }
+    return this->bytesWritten();
+  }
+
+  using base::visit;
+
+ private:
+  void indent() {
+    for (uint8_t i = 0; i < nesting_; i++)
+      base::write(ARDUINOJSON_TAB);
+  }
+
+  uint8_t nesting_;
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
+
+ARDUINOJSON_BEGIN_PUBLIC_NAMESPACE
+
+// Produces JsonDocument to create a prettified JSON document.
+// https://arduinojson.org/v7/api/json/serializejsonpretty/
+template <
+    typename TDestination,
+    detail::enable_if_t<!detail::is_pointer<TDestination>::value, int> = 0>
+inline size_t serializeJsonPretty(JsonVariantConst source,
+                                  TDestination& destination) {
+  using namespace ArduinoJson::detail;
+  return serialize<PrettyJsonSerializer>(source, destination);
+}
+
+// Produces JsonDocument to create a prettified JSON document.
+// https://arduinojson.org/v7/api/json/serializejsonpretty/
+inline size_t serializeJsonPretty(JsonVariantConst source, void* buffer,
+                                  size_t bufferSize) {
+  using namespace ArduinoJson::detail;
+  return serialize<PrettyJsonSerializer>(source, buffer, bufferSize);
+}
+
+// Computes the length of the document that serializeJsonPretty() produces.
+// https://arduinojson.org/v7/api/json/measurejsonpretty/
+inline size_t measureJsonPretty(JsonVariantConst source) {
+  using namespace ArduinoJson::detail;
+  return measure<PrettyJsonSerializer>(source);
+}
+
+ARDUINOJSON_END_PUBLIC_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Json/TextFormatter.hpp b/lib/ArduinoJson/ArduinoJson/Json/TextFormatter.hpp
new file mode 100644
index 0000000..f5457fe
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Json/TextFormatter.hpp
@@ -0,0 +1,177 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <stdint.h>
+#include <string.h>  // for strlen
+
+#include <ArduinoJson/Json/EscapeSequence.hpp>
+#include <ArduinoJson/Numbers/FloatParts.hpp>
+#include <ArduinoJson/Numbers/JsonInteger.hpp>
+#include <ArduinoJson/Polyfills/assert.hpp>
+#include <ArduinoJson/Polyfills/attributes.hpp>
+#include <ArduinoJson/Polyfills/type_traits.hpp>
+#include <ArduinoJson/Serialization/CountingDecorator.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <typename TWriter>
+class TextFormatter {
+ public:
+  explicit TextFormatter(TWriter writer) : writer_(writer) {}
+
+  TextFormatter& operator=(const TextFormatter&) = delete;
+
+  // Returns the number of bytes sent to the TWriter implementation.
+  size_t bytesWritten() const {
+    return writer_.count();
+  }
+
+  void writeBoolean(bool value) {
+    if (value)
+      writeRaw("true");
+    else
+      writeRaw("false");
+  }
+
+  void writeString(const char* value) {
+    ARDUINOJSON_ASSERT(value != NULL);
+    writeRaw('\"');
+    while (*value)
+      writeChar(*value++);
+    writeRaw('\"');
+  }
+
+  void writeString(const char* value, size_t n) {
+    ARDUINOJSON_ASSERT(value != NULL);
+    writeRaw('\"');
+    while (n--)
+      writeChar(*value++);
+    writeRaw('\"');
+  }
+
+  void writeChar(char c) {
+    char specialChar = EscapeSequence::escapeChar(c);
+    if (specialChar) {
+      writeRaw('\\');
+      writeRaw(specialChar);
+    } else if (c) {
+      writeRaw(c);
+    } else {
+      writeRaw("\\u0000");
+    }
+  }
+
+  template <typename T>
+  void writeFloat(T value) {
+    writeFloat(JsonFloat(value), sizeof(T) >= 8 ? 9 : 6);
+  }
+
+  void writeFloat(JsonFloat value, int8_t decimalPlaces) {
+    if (isnan(value))
+      return writeRaw(ARDUINOJSON_ENABLE_NAN ? "NaN" : "null");
+
+#if ARDUINOJSON_ENABLE_INFINITY
+    if (value < 0.0) {
+      writeRaw('-');
+      value = -value;
+    }
+
+    if (isinf(value))
+      return writeRaw("Infinity");
+#else
+    if (isinf(value))
+      return writeRaw("null");
+
+    if (value < 0.0) {
+      writeRaw('-');
+      value = -value;
+    }
+#endif
+
+    auto parts = decomposeFloat(value, decimalPlaces);
+
+    writeInteger(parts.integral);
+    if (parts.decimalPlaces)
+      writeDecimals(parts.decimal, parts.decimalPlaces);
+
+    if (parts.exponent) {
+      writeRaw('e');
+      writeInteger(parts.exponent);
+    }
+  }
+
+  template <typename T>
+  enable_if_t<is_signed<T>::value> writeInteger(T value) {
+    using unsigned_type = make_unsigned_t<T>;
+    unsigned_type unsigned_value;
+    if (value < 0) {
+      writeRaw('-');
+      unsigned_value = unsigned_type(unsigned_type(~value) + 1);
+    } else {
+      unsigned_value = unsigned_type(value);
+    }
+    writeInteger(unsigned_value);
+  }
+
+  template <typename T>
+  enable_if_t<is_unsigned<T>::value> writeInteger(T value) {
+    char buffer[22];
+    char* end = buffer + sizeof(buffer);
+    char* begin = end;
+
+    // write the string in reverse order
+    do {
+      *--begin = char(value % 10 + '0');
+      value = T(value / 10);
+    } while (value);
+
+    // and dump it in the right order
+    writeRaw(begin, end);
+  }
+
+  void writeDecimals(uint32_t value, int8_t width) {
+    // buffer should be big enough for all digits and the dot
+    char buffer[16];
+    char* end = buffer + sizeof(buffer);
+    char* begin = end;
+
+    // write the string in reverse order
+    while (width--) {
+      *--begin = char(value % 10 + '0');
+      value /= 10;
+    }
+    *--begin = '.';
+
+    // and dump it in the right order
+    writeRaw(begin, end);
+  }
+
+  void writeRaw(const char* s) {
+    writer_.write(reinterpret_cast<const uint8_t*>(s), strlen(s));
+  }
+
+  void writeRaw(const char* s, size_t n) {
+    writer_.write(reinterpret_cast<const uint8_t*>(s), n);
+  }
+
+  void writeRaw(const char* begin, const char* end) {
+    writer_.write(reinterpret_cast<const uint8_t*>(begin),
+                  static_cast<size_t>(end - begin));
+  }
+
+  template <size_t N>
+  void writeRaw(const char (&s)[N]) {
+    writer_.write(reinterpret_cast<const uint8_t*>(s), N - 1);
+  }
+  void writeRaw(char c) {
+    writer_.write(static_cast<uint8_t>(c));
+  }
+
+ protected:
+  CountingDecorator<TWriter> writer_;
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Json/Utf16.hpp b/lib/ArduinoJson/ArduinoJson/Json/Utf16.hpp
new file mode 100644
index 0000000..a81d5a5
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Json/Utf16.hpp
@@ -0,0 +1,67 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+
+#include <stdint.h>  // uint16_t, uint32_t
+
+// The high surrogate may be uninitialized if the pair is invalid,
+// we choose to ignore the problem to reduce the size of the code
+// Garbage in => Garbage out
+#if defined(__GNUC__)
+#  if __GNUC__ >= 7
+#    pragma GCC diagnostic push
+#    pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
+#  endif
+#endif
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+namespace Utf16 {
+inline bool isHighSurrogate(uint16_t codeunit) {
+  return codeunit >= 0xD800 && codeunit < 0xDC00;
+}
+
+inline bool isLowSurrogate(uint16_t codeunit) {
+  return codeunit >= 0xDC00 && codeunit < 0xE000;
+}
+
+class Codepoint {
+ public:
+  Codepoint() : highSurrogate_(0), codepoint_(0) {}
+
+  bool append(uint16_t codeunit) {
+    if (isHighSurrogate(codeunit)) {
+      highSurrogate_ = codeunit & 0x3FF;
+      return false;
+    }
+
+    if (isLowSurrogate(codeunit)) {
+      codepoint_ =
+          uint32_t(0x10000 + ((highSurrogate_ << 10) | (codeunit & 0x3FF)));
+      return true;
+    }
+
+    codepoint_ = codeunit;
+    return true;
+  }
+
+  uint32_t value() const {
+    return codepoint_;
+  }
+
+ private:
+  uint16_t highSurrogate_;
+  uint32_t codepoint_;
+};
+}  // namespace Utf16
+ARDUINOJSON_END_PRIVATE_NAMESPACE
+
+#if defined(__GNUC__)
+#  if __GNUC__ >= 8
+#    pragma GCC diagnostic pop
+#  endif
+#endif
diff --git a/lib/ArduinoJson/ArduinoJson/Json/Utf8.hpp b/lib/ArduinoJson/ArduinoJson/Json/Utf8.hpp
new file mode 100644
index 0000000..d89185a
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Json/Utf8.hpp
@@ -0,0 +1,46 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+namespace Utf8 {
+template <typename TStringBuilder>
+inline void encodeCodepoint(uint32_t codepoint32, TStringBuilder& str) {
+  // this function was optimize for code size on AVR
+
+  if (codepoint32 < 0x80) {
+    str.append(char(codepoint32));
+  } else {
+    // a buffer to store the string in reverse
+    char buf[5];
+    char* p = buf;
+
+    *(p++) = 0;
+    *(p++) = char((codepoint32 | 0x80) & 0xBF);
+    uint16_t codepoint16 = uint16_t(codepoint32 >> 6);
+    if (codepoint16 < 0x20) {  // 0x800
+      *(p++) = char(codepoint16 | 0xC0);
+    } else {
+      *(p++) = char((codepoint16 | 0x80) & 0xBF);
+      codepoint16 = uint16_t(codepoint16 >> 6);
+      if (codepoint16 < 0x10) {  // 0x10000
+        *(p++) = char(codepoint16 | 0xE0);
+      } else {
+        *(p++) = char((codepoint16 | 0x80) & 0xBF);
+        codepoint16 = uint16_t(codepoint16 >> 6);
+        *(p++) = char(codepoint16 | 0xF0);
+      }
+    }
+
+    while (*(--p)) {
+      str.append(*p);
+    }
+  }
+}
+}  // namespace Utf8
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Memory/Alignment.hpp b/lib/ArduinoJson/ArduinoJson/Memory/Alignment.hpp
new file mode 100644
index 0000000..92d0ed5
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Memory/Alignment.hpp
@@ -0,0 +1,60 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+
+#include <stddef.h>  // size_t
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+#if ARDUINOJSON_ENABLE_ALIGNMENT
+
+inline bool isAligned(size_t value) {
+  const size_t mask = sizeof(void*) - 1;
+  size_t addr = value;
+  return (addr & mask) == 0;
+}
+
+inline size_t addPadding(size_t bytes) {
+  const size_t mask = sizeof(void*) - 1;
+  return (bytes + mask) & ~mask;
+}
+
+template <size_t bytes>
+struct AddPadding {
+  static const size_t mask = sizeof(void*) - 1;
+  static const size_t value = (bytes + mask) & ~mask;
+};
+
+#else
+
+inline bool isAligned(size_t) {
+  return true;
+}
+
+inline size_t addPadding(size_t bytes) {
+  return bytes;
+}
+
+template <size_t bytes>
+struct AddPadding {
+  static const size_t value = bytes;
+};
+
+#endif
+
+template <typename T>
+inline bool isAligned(T* ptr) {
+  return isAligned(reinterpret_cast<size_t>(ptr));
+}
+
+template <typename T>
+inline T* addPadding(T* p) {
+  size_t address = addPadding(reinterpret_cast<size_t>(p));
+  return reinterpret_cast<T*>(address);
+}
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Memory/Allocator.hpp b/lib/ArduinoJson/ArduinoJson/Memory/Allocator.hpp
new file mode 100644
index 0000000..3f88869
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Memory/Allocator.hpp
@@ -0,0 +1,49 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+
+#include <stdlib.h>  // malloc, free
+
+ARDUINOJSON_BEGIN_PUBLIC_NAMESPACE
+
+class Allocator {
+ public:
+  virtual void* allocate(size_t size) = 0;
+  virtual void deallocate(void* ptr) = 0;
+  virtual void* reallocate(void* ptr, size_t new_size) = 0;
+
+ protected:
+  ~Allocator() = default;
+};
+
+namespace detail {
+class DefaultAllocator : public Allocator {
+ public:
+  void* allocate(size_t size) override {
+    return malloc(size);
+  }
+
+  void deallocate(void* ptr) override {
+    free(ptr);
+  }
+
+  void* reallocate(void* ptr, size_t new_size) override {
+    return realloc(ptr, new_size);
+  }
+
+  static Allocator* instance() {
+    static DefaultAllocator allocator;
+    return &allocator;
+  }
+
+ private:
+  DefaultAllocator() = default;
+  ~DefaultAllocator() = default;
+};
+}  // namespace detail
+
+ARDUINOJSON_END_PUBLIC_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Memory/MemoryPool.hpp b/lib/ArduinoJson/ArduinoJson/Memory/MemoryPool.hpp
new file mode 100644
index 0000000..06b2750
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Memory/MemoryPool.hpp
@@ -0,0 +1,110 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Memory/Allocator.hpp>
+#include <ArduinoJson/Polyfills/assert.hpp>
+#include <ArduinoJson/Polyfills/integer.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+using SlotId = uint_t<ARDUINOJSON_SLOT_ID_SIZE * 8>;
+using SlotCount = SlotId;
+const SlotId NULL_SLOT = SlotId(-1);
+
+template <typename T>
+class Slot {
+ public:
+  Slot() : ptr_(nullptr), id_(NULL_SLOT) {}
+  Slot(T* p, SlotId id) : ptr_(p), id_(id) {
+    ARDUINOJSON_ASSERT((p == nullptr) == (id == NULL_SLOT));
+  }
+
+  explicit operator bool() const {
+    return ptr_ != nullptr;
+  }
+
+  SlotId id() const {
+    return id_;
+  }
+
+  T* ptr() const {
+    return ptr_;
+  }
+
+  T* operator->() const {
+    ARDUINOJSON_ASSERT(ptr_ != nullptr);
+    return ptr_;
+  }
+
+ private:
+  T* ptr_;
+  SlotId id_;
+};
+
+template <typename T>
+class MemoryPool {
+ public:
+  void create(SlotCount cap, Allocator* allocator) {
+    ARDUINOJSON_ASSERT(cap > 0);
+    slots_ = reinterpret_cast<T*>(allocator->allocate(slotsToBytes(cap)));
+    capacity_ = slots_ ? cap : 0;
+    usage_ = 0;
+  }
+
+  void destroy(Allocator* allocator) {
+    if (slots_)
+      allocator->deallocate(slots_);
+    slots_ = nullptr;
+    capacity_ = 0;
+    usage_ = 0;
+  }
+
+  Slot<T> allocSlot() {
+    if (!slots_)
+      return {};
+    if (usage_ >= capacity_)
+      return {};
+    auto index = usage_++;
+    return {slots_ + index, SlotId(index)};
+  }
+
+  T* getSlot(SlotId id) const {
+    ARDUINOJSON_ASSERT(id < usage_);
+    return slots_ + id;
+  }
+
+  void clear() {
+    usage_ = 0;
+  }
+
+  void shrinkToFit(Allocator* allocator) {
+    auto newSlots = reinterpret_cast<T*>(
+        allocator->reallocate(slots_, slotsToBytes(usage_)));
+    if (newSlots) {
+      slots_ = newSlots;
+      capacity_ = usage_;
+    }
+  }
+
+  SlotCount usage() const {
+    return usage_;
+  }
+
+  static SlotCount bytesToSlots(size_t n) {
+    return static_cast<SlotCount>(n / sizeof(T));
+  }
+
+  static size_t slotsToBytes(SlotCount n) {
+    return n * sizeof(T);
+  }
+
+ private:
+  SlotCount capacity_;
+  SlotCount usage_;
+  T* slots_;
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Memory/MemoryPoolList.hpp b/lib/ArduinoJson/ArduinoJson/Memory/MemoryPoolList.hpp
new file mode 100644
index 0000000..8af82cb
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Memory/MemoryPoolList.hpp
@@ -0,0 +1,214 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Memory/MemoryPool.hpp>
+#include <ArduinoJson/Polyfills/assert.hpp>
+#include <ArduinoJson/Polyfills/utility.hpp>
+
+#include <string.h>  // memcpy
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+using PoolCount = SlotId;
+
+template <typename T>
+class MemoryPoolList {
+  struct FreeSlot {
+    SlotId next;
+  };
+
+  static_assert(sizeof(FreeSlot) <= sizeof(T), "T is too small");
+
+ public:
+  using Pool = MemoryPool<T>;
+
+  MemoryPoolList() = default;
+
+  ~MemoryPoolList() {
+    ARDUINOJSON_ASSERT(count_ == 0);
+  }
+
+  friend void swap(MemoryPoolList& a, MemoryPoolList& b) {
+    bool aUsedPreallocated = a.pools_ == a.preallocatedPools_;
+    bool bUsedPreallocated = b.pools_ == b.preallocatedPools_;
+
+    // Who is using preallocated pools?
+    if (aUsedPreallocated && bUsedPreallocated) {
+      // both of us => swap preallocated pools
+      for (PoolCount i = 0; i < ARDUINOJSON_INITIAL_POOL_COUNT; i++)
+        swap_(a.preallocatedPools_[i], b.preallocatedPools_[i]);
+    } else if (bUsedPreallocated) {
+      // only b => copy b's preallocated pools and give him a's pointer
+      for (PoolCount i = 0; i < b.count_; i++)
+        a.preallocatedPools_[i] = b.preallocatedPools_[i];
+      b.pools_ = a.pools_;
+      a.pools_ = a.preallocatedPools_;
+    } else if (aUsedPreallocated) {
+      // only a => copy a's preallocated pools and give him b's pointer
+      for (PoolCount i = 0; i < a.count_; i++)
+        b.preallocatedPools_[i] = a.preallocatedPools_[i];
+      a.pools_ = b.pools_;
+      b.pools_ = b.preallocatedPools_;
+    } else {
+      // neither => swap pointers
+      swap_(a.pools_, b.pools_);
+    }
+
+    swap_(a.count_, b.count_);
+    swap_(a.capacity_, b.capacity_);
+    swap_(a.freeList_, b.freeList_);
+  }
+
+  MemoryPoolList& operator=(MemoryPoolList&& src) {
+    ARDUINOJSON_ASSERT(count_ == 0);
+    if (src.pools_ == src.preallocatedPools_) {
+      memcpy(preallocatedPools_, src.preallocatedPools_,
+             sizeof(preallocatedPools_));
+      pools_ = preallocatedPools_;
+    } else {
+      pools_ = src.pools_;
+      src.pools_ = nullptr;
+    }
+    count_ = src.count_;
+    capacity_ = src.capacity_;
+    src.count_ = 0;
+    src.capacity_ = 0;
+    return *this;
+  }
+
+  Slot<T> allocSlot(Allocator* allocator) {
+    // try to allocate from free list
+    if (freeList_ != NULL_SLOT) {
+      return allocFromFreeList();
+    }
+
+    // try to allocate from last pool (other pools are full)
+    if (count_) {
+      auto slot = allocFromLastPool();
+      if (slot)
+        return slot;
+    }
+
+    // create a new pool and try again
+    auto pool = addPool(allocator);
+    if (!pool)
+      return {};
+
+    return allocFromLastPool();
+  }
+
+  void freeSlot(Slot<T> slot) {
+    reinterpret_cast<FreeSlot*>(slot.ptr())->next = freeList_;
+    freeList_ = slot.id();
+  }
+
+  T* getSlot(SlotId id) const {
+    if (id == NULL_SLOT)
+      return nullptr;
+    auto poolIndex = SlotId(id / ARDUINOJSON_POOL_CAPACITY);
+    auto indexInPool = SlotId(id % ARDUINOJSON_POOL_CAPACITY);
+    ARDUINOJSON_ASSERT(poolIndex < count_);
+    return pools_[poolIndex].getSlot(indexInPool);
+  }
+
+  void clear(Allocator* allocator) {
+    for (PoolCount i = 0; i < count_; i++)
+      pools_[i].destroy(allocator);
+    count_ = 0;
+    freeList_ = NULL_SLOT;
+    if (pools_ != preallocatedPools_) {
+      allocator->deallocate(pools_);
+      pools_ = preallocatedPools_;
+      capacity_ = ARDUINOJSON_INITIAL_POOL_COUNT;
+    }
+  }
+
+  SlotCount usage() const {
+    SlotCount total = 0;
+    for (PoolCount i = 0; i < count_; i++)
+      total = SlotCount(total + pools_[i].usage());
+    return total;
+  }
+
+  size_t size() const {
+    return Pool::slotsToBytes(usage());
+  }
+
+  void shrinkToFit(Allocator* allocator) {
+    if (count_ > 0)
+      pools_[count_ - 1].shrinkToFit(allocator);
+    if (pools_ != preallocatedPools_ && count_ != capacity_) {
+      pools_ = static_cast<Pool*>(
+          allocator->reallocate(pools_, count_ * sizeof(Pool)));
+      ARDUINOJSON_ASSERT(pools_ != nullptr);  // realloc to smaller can't fail
+      capacity_ = count_;
+    }
+  }
+
+ private:
+  Slot<T> allocFromFreeList() {
+    ARDUINOJSON_ASSERT(freeList_ != NULL_SLOT);
+    auto id = freeList_;
+    auto slot = getSlot(freeList_);
+    freeList_ = reinterpret_cast<FreeSlot*>(slot)->next;
+    return {slot, id};
+  }
+
+  Slot<T> allocFromLastPool() {
+    ARDUINOJSON_ASSERT(count_ > 0);
+    auto poolIndex = SlotId(count_ - 1);
+    auto slot = pools_[poolIndex].allocSlot();
+    if (!slot)
+      return {};
+    return {slot.ptr(),
+            SlotId(poolIndex * ARDUINOJSON_POOL_CAPACITY + slot.id())};
+  }
+
+  Pool* addPool(Allocator* allocator) {
+    if (count_ == capacity_ && !increaseCapacity(allocator))
+      return nullptr;
+    auto pool = &pools_[count_++];
+    SlotCount poolCapacity = ARDUINOJSON_POOL_CAPACITY;
+    if (count_ == maxPools)  // last pool is smaller because of NULL_SLOT
+      poolCapacity--;
+    pool->create(poolCapacity, allocator);
+    return pool;
+  }
+
+  bool increaseCapacity(Allocator* allocator) {
+    if (capacity_ == maxPools)
+      return false;
+    void* newPools;
+    auto newCapacity = PoolCount(capacity_ * 2);
+
+    if (pools_ == preallocatedPools_) {
+      newPools = allocator->allocate(newCapacity * sizeof(Pool));
+      if (!newPools)
+        return false;
+      memcpy(newPools, preallocatedPools_, sizeof(preallocatedPools_));
+    } else {
+      newPools = allocator->reallocate(pools_, newCapacity * sizeof(Pool));
+      if (!newPools)
+        return false;
+    }
+
+    pools_ = static_cast<Pool*>(newPools);
+    capacity_ = newCapacity;
+    return true;
+  }
+
+  Pool preallocatedPools_[ARDUINOJSON_INITIAL_POOL_COUNT];
+  Pool* pools_ = preallocatedPools_;
+  PoolCount count_ = 0;
+  PoolCount capacity_ = ARDUINOJSON_INITIAL_POOL_COUNT;
+  SlotId freeList_ = NULL_SLOT;
+
+ public:
+  static const PoolCount maxPools =
+      PoolCount(NULL_SLOT / ARDUINOJSON_POOL_CAPACITY + 1);
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Memory/ResourceManager.hpp b/lib/ArduinoJson/ArduinoJson/Memory/ResourceManager.hpp
new file mode 100644
index 0000000..22b8236
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Memory/ResourceManager.hpp
@@ -0,0 +1,131 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Memory/Allocator.hpp>
+#include <ArduinoJson/Memory/MemoryPoolList.hpp>
+#include <ArduinoJson/Memory/StringPool.hpp>
+#include <ArduinoJson/Polyfills/assert.hpp>
+#include <ArduinoJson/Polyfills/utility.hpp>
+#include <ArduinoJson/Strings/StringAdapters.hpp>
+#include <ArduinoJson/Variant/VariantData.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+class VariantData;
+class VariantWithId;
+
+class ResourceManager {
+  union SlotData {
+    VariantData variant;
+#if ARDUINOJSON_USE_EXTENSIONS
+    VariantExtension extension;
+#endif
+  };
+
+ public:
+  constexpr static size_t slotSize = sizeof(SlotData);
+
+  ResourceManager(Allocator* allocator = DefaultAllocator::instance())
+      : allocator_(allocator), overflowed_(false) {}
+
+  ~ResourceManager() {
+    stringPool_.clear(allocator_);
+    variantPools_.clear(allocator_);
+  }
+
+  ResourceManager(const ResourceManager&) = delete;
+  ResourceManager& operator=(const ResourceManager& src) = delete;
+
+  friend void swap(ResourceManager& a, ResourceManager& b) {
+    swap(a.stringPool_, b.stringPool_);
+    swap(a.variantPools_, b.variantPools_);
+    swap_(a.allocator_, b.allocator_);
+    swap_(a.overflowed_, b.overflowed_);
+  }
+
+  Allocator* allocator() const {
+    return allocator_;
+  }
+
+  size_t size() const {
+    return variantPools_.size() + stringPool_.size();
+  }
+
+  bool overflowed() const {
+    return overflowed_;
+  }
+
+  Slot<VariantData> allocVariant();
+  void freeVariant(Slot<VariantData> slot);
+  VariantData* getVariant(SlotId id) const;
+
+#if ARDUINOJSON_USE_EXTENSIONS
+  Slot<VariantExtension> allocExtension();
+  void freeExtension(SlotId slot);
+  VariantExtension* getExtension(SlotId id) const;
+#endif
+
+  template <typename TAdaptedString>
+  StringNode* saveString(TAdaptedString str) {
+    if (str.isNull())
+      return 0;
+
+    auto node = stringPool_.add(str, allocator_);
+    if (!node)
+      overflowed_ = true;
+
+    return node;
+  }
+
+  void saveString(StringNode* node) {
+    stringPool_.add(node);
+  }
+
+  template <typename TAdaptedString>
+  StringNode* getString(const TAdaptedString& str) const {
+    return stringPool_.get(str);
+  }
+
+  StringNode* createString(size_t length) {
+    auto node = StringNode::create(length, allocator_);
+    if (!node)
+      overflowed_ = true;
+    return node;
+  }
+
+  StringNode* resizeString(StringNode* node, size_t length) {
+    node = StringNode::resize(node, length, allocator_);
+    if (!node)
+      overflowed_ = true;
+    return node;
+  }
+
+  void destroyString(StringNode* node) {
+    StringNode::destroy(node, allocator_);
+  }
+
+  void dereferenceString(const char* s) {
+    stringPool_.dereference(s, allocator_);
+  }
+
+  void clear() {
+    variantPools_.clear(allocator_);
+    overflowed_ = false;
+    stringPool_.clear(allocator_);
+  }
+
+  void shrinkToFit() {
+    variantPools_.shrinkToFit(allocator_);
+  }
+
+ private:
+  Allocator* allocator_;
+  bool overflowed_;
+  StringPool stringPool_;
+  MemoryPoolList<SlotData> variantPools_;
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Memory/ResourceManagerImpl.hpp b/lib/ArduinoJson/ArduinoJson/Memory/ResourceManagerImpl.hpp
new file mode 100644
index 0000000..a200436
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Memory/ResourceManagerImpl.hpp
@@ -0,0 +1,52 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Collection/CollectionData.hpp>
+#include <ArduinoJson/Memory/ResourceManager.hpp>
+#include <ArduinoJson/Polyfills/alias_cast.hpp>
+#include <ArduinoJson/Variant/VariantData.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+inline Slot<VariantData> ResourceManager::allocVariant() {
+  auto p = variantPools_.allocSlot(allocator_);
+  if (!p) {
+    overflowed_ = true;
+    return {};
+  }
+  return {new (&p->variant) VariantData, p.id()};
+}
+
+inline void ResourceManager::freeVariant(Slot<VariantData> variant) {
+  variant->clear(this);
+  variantPools_.freeSlot({alias_cast<SlotData*>(variant.ptr()), variant.id()});
+}
+
+inline VariantData* ResourceManager::getVariant(SlotId id) const {
+  return reinterpret_cast<VariantData*>(variantPools_.getSlot(id));
+}
+
+#if ARDUINOJSON_USE_EXTENSIONS
+inline Slot<VariantExtension> ResourceManager::allocExtension() {
+  auto p = variantPools_.allocSlot(allocator_);
+  if (!p) {
+    overflowed_ = true;
+    return {};
+  }
+  return {&p->extension, p.id()};
+}
+
+inline void ResourceManager::freeExtension(SlotId id) {
+  auto p = getExtension(id);
+  variantPools_.freeSlot({reinterpret_cast<SlotData*>(p), id});
+}
+
+inline VariantExtension* ResourceManager::getExtension(SlotId id) const {
+  return &variantPools_.getSlot(id)->extension;
+}
+#endif
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Memory/StringBuffer.hpp b/lib/ArduinoJson/ArduinoJson/Memory/StringBuffer.hpp
new file mode 100644
index 0000000..1b6f06c
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Memory/StringBuffer.hpp
@@ -0,0 +1,79 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Memory/ResourceManager.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+class StringBuffer {
+ public:
+  StringBuffer(ResourceManager* resources) : resources_(resources) {}
+
+  ~StringBuffer() {
+    if (node_)
+      resources_->destroyString(node_);
+  }
+
+  char* reserve(size_t capacity) {
+    if (node_ && capacity > node_->length) {
+      // existing buffer is too small, we need to reallocate
+      resources_->destroyString(node_);
+      node_ = nullptr;
+    }
+    if (!node_)
+      node_ = resources_->createString(capacity);
+    if (!node_)
+      return nullptr;
+    size_ = capacity;
+    node_->data[capacity] = 0;  // null-terminate the string
+    return node_->data;
+  }
+
+  JsonString str() const {
+    ARDUINOJSON_ASSERT(node_ != nullptr);
+    return JsonString(node_->data, node_->length);
+  }
+
+  void save(VariantData* data) {
+    ARDUINOJSON_ASSERT(node_ != nullptr);
+    const char* s = node_->data;
+    if (isTinyString(s, size_))
+      data->setTinyString(adaptString(s, size_));
+    else
+      data->setOwnedString(commitStringNode());
+  }
+
+  void saveRaw(VariantData* data) {
+    data->setRawString(commitStringNode());
+  }
+
+ private:
+  StringNode* commitStringNode() {
+    ARDUINOJSON_ASSERT(node_ != nullptr);
+    node_->data[size_] = 0;
+    auto node = resources_->getString(adaptString(node_->data, size_));
+    if (node) {
+      node->references++;
+      return node;
+    }
+
+    if (node_->length != size_) {
+      node = resources_->resizeString(node_, size_);
+      ARDUINOJSON_ASSERT(node != nullptr);  // realloc to smaller can't fail
+    } else {
+      node = node_;
+    }
+    node_ = nullptr;
+    resources_->saveString(node);
+    return node;
+  }
+
+  ResourceManager* resources_;
+  StringNode* node_ = nullptr;
+  size_t size_ = 0;
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Memory/StringBuilder.hpp b/lib/ArduinoJson/ArduinoJson/Memory/StringBuilder.hpp
new file mode 100644
index 0000000..5961c52
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Memory/StringBuilder.hpp
@@ -0,0 +1,88 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Memory/ResourceManager.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+class StringBuilder {
+ public:
+  static const size_t initialCapacity = 31;
+
+  StringBuilder(ResourceManager* resources) : resources_(resources) {}
+
+  ~StringBuilder() {
+    if (node_)
+      resources_->destroyString(node_);
+  }
+
+  void startString() {
+    size_ = 0;
+    if (!node_)
+      node_ = resources_->createString(initialCapacity);
+  }
+
+  void save(VariantData* variant) {
+    ARDUINOJSON_ASSERT(variant != nullptr);
+    ARDUINOJSON_ASSERT(node_ != nullptr);
+
+    char* p = node_->data;
+    if (isTinyString(p, size_)) {
+      variant->setTinyString(adaptString(p, size_));
+      return;
+    }
+
+    p[size_] = 0;
+    StringNode* node = resources_->getString(adaptString(p, size_));
+    if (!node) {
+      node = resources_->resizeString(node_, size_);
+      ARDUINOJSON_ASSERT(node != nullptr);  // realloc to smaller can't fail
+      resources_->saveString(node);
+      node_ = nullptr;  // next time we need a new string
+    } else {
+      node->references++;
+    }
+    variant->setOwnedString(node);
+  }
+
+  void append(const char* s) {
+    while (*s)
+      append(*s++);
+  }
+
+  void append(const char* s, size_t n) {
+    while (n-- > 0)  // TODO: memcpy
+      append(*s++);
+  }
+
+  void append(char c) {
+    if (node_ && size_ == node_->length)
+      node_ = resources_->resizeString(node_, size_ * 2U + 1);
+    if (node_)
+      node_->data[size_++] = c;
+  }
+
+  bool isValid() const {
+    return node_ != nullptr;
+  }
+
+  size_t size() const {
+    return size_;
+  }
+
+  JsonString str() const {
+    ARDUINOJSON_ASSERT(node_ != nullptr);
+    node_->data[size_] = 0;
+    return JsonString(node_->data, size_);
+  }
+
+ private:
+  ResourceManager* resources_;
+  StringNode* node_ = nullptr;
+  size_t size_ = 0;
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Memory/StringNode.hpp b/lib/ArduinoJson/ArduinoJson/Memory/StringNode.hpp
new file mode 100644
index 0000000..7a6ca35
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Memory/StringNode.hpp
@@ -0,0 +1,75 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Memory/Allocator.hpp>
+#include <ArduinoJson/Namespace.hpp>
+#include <ArduinoJson/Polyfills/assert.hpp>
+#include <ArduinoJson/Polyfills/integer.hpp>
+#include <ArduinoJson/Polyfills/limits.hpp>
+
+#include <stddef.h>  // offsetof
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+struct StringNode {
+  // Use the same type as SlotId to store the reference count
+  // (there can never be more references than slots)
+  using references_type = uint_t<ARDUINOJSON_SLOT_ID_SIZE * 8>;
+
+  using length_type = uint_t<ARDUINOJSON_STRING_LENGTH_SIZE * 8>;
+
+  struct StringNode* next;
+  references_type references;
+  length_type length;
+  char data[1];
+
+  static constexpr size_t maxLength = numeric_limits<length_type>::highest();
+
+  static constexpr size_t sizeForLength(size_t n) {
+    return n + 1 + offsetof(StringNode, data);
+  }
+
+  static StringNode* create(size_t length, Allocator* allocator) {
+    if (length > maxLength)
+      return nullptr;
+    auto size = sizeForLength(length);
+    if (size < length)  // integer overflow
+      return nullptr;   // (not testable on 64-bit)
+    auto node = reinterpret_cast<StringNode*>(allocator->allocate(size));
+    if (node) {
+      node->length = length_type(length);
+      node->references = 1;
+    }
+    return node;
+  }
+
+  static StringNode* resize(StringNode* node, size_t length,
+                            Allocator* allocator) {
+    ARDUINOJSON_ASSERT(node != nullptr);
+    StringNode* newNode;
+    if (length <= maxLength)
+      newNode = reinterpret_cast<StringNode*>(
+          allocator->reallocate(node, sizeForLength(length)));
+    else
+      newNode = nullptr;
+    if (newNode)
+      newNode->length = length_type(length);
+    else
+      allocator->deallocate(node);
+    return newNode;
+  }
+
+  static void destroy(StringNode* node, Allocator* allocator) {
+    allocator->deallocate(node);
+  }
+};
+
+// Returns the size (in bytes) of an string with n characters.
+constexpr size_t sizeofString(size_t n) {
+  return StringNode::sizeForLength(n);
+}
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Memory/StringPool.hpp b/lib/ArduinoJson/ArduinoJson/Memory/StringPool.hpp
new file mode 100644
index 0000000..06e1b99
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Memory/StringPool.hpp
@@ -0,0 +1,102 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Memory/Allocator.hpp>
+#include <ArduinoJson/Memory/StringNode.hpp>
+#include <ArduinoJson/Polyfills/assert.hpp>
+#include <ArduinoJson/Polyfills/utility.hpp>
+#include <ArduinoJson/Strings/StringAdapters.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+class StringPool {
+ public:
+  StringPool() = default;
+  StringPool(const StringPool&) = delete;
+  void operator=(StringPool&& src) = delete;
+
+  ~StringPool() {
+    ARDUINOJSON_ASSERT(strings_ == nullptr);
+  }
+
+  friend void swap(StringPool& a, StringPool& b) {
+    swap_(a.strings_, b.strings_);
+  }
+
+  void clear(Allocator* allocator) {
+    while (strings_) {
+      auto node = strings_;
+      strings_ = node->next;
+      StringNode::destroy(node, allocator);
+    }
+  }
+
+  size_t size() const {
+    size_t total = 0;
+    for (auto node = strings_; node; node = node->next)
+      total += sizeofString(node->length);
+    return total;
+  }
+
+  template <typename TAdaptedString>
+  StringNode* add(TAdaptedString str, Allocator* allocator) {
+    ARDUINOJSON_ASSERT(str.isNull() == false);
+
+    auto node = get(str);
+    if (node) {
+      node->references++;
+      return node;
+    }
+
+    size_t n = str.size();
+
+    node = StringNode::create(n, allocator);
+    if (!node)
+      return nullptr;
+
+    stringGetChars(str, node->data, n);
+    node->data[n] = 0;  // force NUL terminator
+    add(node);
+    return node;
+  }
+
+  void add(StringNode* node) {
+    ARDUINOJSON_ASSERT(node != nullptr);
+    node->next = strings_;
+    strings_ = node;
+  }
+
+  template <typename TAdaptedString>
+  StringNode* get(const TAdaptedString& str) const {
+    for (auto node = strings_; node; node = node->next) {
+      if (stringEquals(str, adaptString(node->data, node->length)))
+        return node;
+    }
+    return nullptr;
+  }
+
+  void dereference(const char* s, Allocator* allocator) {
+    StringNode* prev = nullptr;
+    for (auto node = strings_; node; node = node->next) {
+      if (node->data == s) {
+        if (--node->references == 0) {
+          if (prev)
+            prev->next = node->next;
+          else
+            strings_ = node->next;
+          StringNode::destroy(node, allocator);
+        }
+        return;
+      }
+      prev = node;
+    }
+  }
+
+ private:
+  StringNode* strings_ = nullptr;
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Misc/SerializedValue.hpp b/lib/ArduinoJson/ArduinoJson/Misc/SerializedValue.hpp
new file mode 100644
index 0000000..4c9404e
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Misc/SerializedValue.hpp
@@ -0,0 +1,71 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Strings/StringAdapters.hpp>
+
+ARDUINOJSON_BEGIN_PUBLIC_NAMESPACE
+
+// A special type of data that can be used to insert pregenerated JSON portions.
+template <typename T>
+class SerializedValue {
+ public:
+  explicit SerializedValue(T str) : str_(str) {}
+  operator T() const {
+    return str_;
+  }
+
+  const char* data() const {
+    return str_.c_str();
+  }
+
+  size_t size() const {
+    // CAUTION: the old Arduino String doesn't have size()
+    return str_.length();
+  }
+
+ private:
+  T str_;
+};
+
+template <typename TChar>
+class SerializedValue<TChar*> {
+ public:
+  explicit SerializedValue(TChar* p, size_t n) : data_(p), size_(n) {}
+  operator TChar*() const {
+    return data_;
+  }
+
+  TChar* data() const {
+    return data_;
+  }
+
+  size_t size() const {
+    return size_;
+  }
+
+ private:
+  TChar* data_;
+  size_t size_;
+};
+
+using RawString = SerializedValue<const char*>;
+
+template <typename T>
+inline SerializedValue<T> serialized(T str) {
+  return SerializedValue<T>(str);
+}
+
+template <typename TChar>
+inline SerializedValue<TChar*> serialized(TChar* p) {
+  return SerializedValue<TChar*>(p, detail::adaptString(p).size());
+}
+
+template <typename TChar>
+inline SerializedValue<TChar*> serialized(TChar* p, size_t n) {
+  return SerializedValue<TChar*>(p, n);
+}
+
+ARDUINOJSON_END_PUBLIC_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/MsgPack/MsgPackBinary.hpp b/lib/ArduinoJson/ArduinoJson/MsgPack/MsgPackBinary.hpp
new file mode 100644
index 0000000..2c0f6b7
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/MsgPack/MsgPackBinary.hpp
@@ -0,0 +1,97 @@
+#pragma once
+
+#include <ArduinoJson/Variant/Converter.hpp>
+
+ARDUINOJSON_BEGIN_PUBLIC_NAMESPACE
+
+class MsgPackBinary {
+ public:
+  MsgPackBinary() : data_(nullptr), size_(0) {}
+  explicit MsgPackBinary(const void* c, size_t size) : data_(c), size_(size) {}
+
+  const void* data() const {
+    return data_;
+  }
+
+  size_t size() const {
+    return size_;
+  }
+
+ private:
+  const void* data_;
+  size_t size_;
+};
+
+template <>
+struct Converter<MsgPackBinary> : private detail::VariantAttorney {
+  static void toJson(MsgPackBinary src, JsonVariant dst) {
+    auto data = VariantAttorney::getData(dst);
+    if (!data)
+      return;
+    auto resources = getResourceManager(dst);
+    data->clear(resources);
+    if (src.data()) {
+      size_t headerSize = src.size() >= 0x10000 ? 5
+                          : src.size() >= 0x100 ? 3
+                                                : 2;
+      auto str = resources->createString(src.size() + headerSize);
+      if (str) {
+        resources->saveString(str);
+        auto ptr = reinterpret_cast<uint8_t*>(str->data);
+        switch (headerSize) {
+          case 2:
+            ptr[0] = uint8_t(0xc4);
+            ptr[1] = uint8_t(src.size() & 0xff);
+            break;
+          case 3:
+            ptr[0] = uint8_t(0xc5);
+            ptr[1] = uint8_t(src.size() >> 8 & 0xff);
+            ptr[2] = uint8_t(src.size() & 0xff);
+            break;
+          case 5:
+            ptr[0] = uint8_t(0xc6);
+            ptr[1] = uint8_t(src.size() >> 24 & 0xff);
+            ptr[2] = uint8_t(src.size() >> 16 & 0xff);
+            ptr[3] = uint8_t(src.size() >> 8 & 0xff);
+            ptr[4] = uint8_t(src.size() & 0xff);
+            break;
+          default:
+            ARDUINOJSON_ASSERT(false);
+        }
+        memcpy(ptr + headerSize, src.data(), src.size());
+        data->setRawString(str);
+        return;
+      }
+    }
+  }
+
+  static MsgPackBinary fromJson(JsonVariantConst src) {
+    auto data = getData(src);
+    if (!data)
+      return {};
+    auto rawstr = data->asRawString();
+    auto p = reinterpret_cast<const uint8_t*>(rawstr.c_str());
+    auto n = rawstr.size();
+    if (n >= 2 && p[0] == 0xc4) {  // bin 8
+      size_t size = p[1];
+      if (size + 2 == n)
+        return MsgPackBinary(p + 2, size);
+    } else if (n >= 3 && p[0] == 0xc5) {  // bin 16
+      size_t size = size_t(p[1] << 8) | p[2];
+      if (size + 3 == n)
+        return MsgPackBinary(p + 3, size);
+    } else if (n >= 5 && p[0] == 0xc6) {  // bin 32
+      size_t size =
+          size_t(p[1] << 24) | size_t(p[2] << 16) | size_t(p[3] << 8) | p[4];
+      if (size + 5 == n)
+        return MsgPackBinary(p + 5, size);
+    }
+    return {};
+  }
+
+  static bool checkJson(JsonVariantConst src) {
+    return fromJson(src).data() != nullptr;
+  }
+};
+
+ARDUINOJSON_END_PUBLIC_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/MsgPack/MsgPackDeserializer.hpp b/lib/ArduinoJson/ArduinoJson/MsgPack/MsgPackDeserializer.hpp
new file mode 100644
index 0000000..7199305
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/MsgPack/MsgPackDeserializer.hpp
@@ -0,0 +1,487 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Deserialization/deserialize.hpp>
+#include <ArduinoJson/Memory/ResourceManager.hpp>
+#include <ArduinoJson/Memory/StringBuffer.hpp>
+#include <ArduinoJson/MsgPack/endianness.hpp>
+#include <ArduinoJson/MsgPack/ieee754.hpp>
+#include <ArduinoJson/Polyfills/type_traits.hpp>
+#include <ArduinoJson/Variant/VariantData.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <typename TReader>
+class MsgPackDeserializer {
+ public:
+  MsgPackDeserializer(ResourceManager* resources, TReader reader)
+      : resources_(resources),
+        reader_(reader),
+        stringBuffer_(resources),
+        foundSomething_(false) {}
+
+  template <typename TFilter>
+  DeserializationError parse(VariantData& variant, TFilter filter,
+                             DeserializationOption::NestingLimit nestingLimit) {
+    DeserializationError::Code err;
+    err = parseVariant(&variant, filter, nestingLimit);
+    return foundSomething_ ? err : DeserializationError::EmptyInput;
+  }
+
+ private:
+  template <typename TFilter>
+  DeserializationError::Code parseVariant(
+      VariantData* variant, TFilter filter,
+      DeserializationOption::NestingLimit nestingLimit) {
+    DeserializationError::Code err;
+
+    uint8_t header[5];
+    err = readBytes(header, 1);
+    if (err)
+      return err;
+
+    const uint8_t& code = header[0];
+
+    foundSomething_ = true;
+
+    bool allowValue = filter.allowValue();
+
+    if (allowValue) {
+      // callers pass a null pointer only when value must be ignored
+      ARDUINOJSON_ASSERT(variant != 0);
+    }
+
+    if (code >= 0xcc && code <= 0xd3) {
+      auto width = uint8_t(1U << ((code - 0xcc) % 4));
+      if (allowValue)
+        return readInteger(variant, width, code >= 0xd0);
+      else
+        return skipBytes(width);
+    }
+
+    switch (code) {
+      case 0xc0:
+        // already null
+        return DeserializationError::Ok;
+
+      case 0xc1:
+        return DeserializationError::InvalidInput;
+
+      case 0xc2:
+      case 0xc3:
+        if (allowValue)
+          variant->setBoolean(code == 0xc3);
+        return DeserializationError::Ok;
+
+      case 0xca:
+        if (allowValue)
+          return readFloat<float>(variant);
+        else
+          return skipBytes(4);
+
+      case 0xcb:
+        if (allowValue)
+          return readDouble<double>(variant);
+        else
+          return skipBytes(8);
+    }
+
+    if (code <= 0x7f || code >= 0xe0) {  // fixint
+      if (allowValue)
+        variant->setInteger(static_cast<int8_t>(code), resources_);
+      return DeserializationError::Ok;
+    }
+
+    uint8_t sizeBytes = 0;
+    size_t size = 0;
+    bool isExtension = code >= 0xc7 && code <= 0xc9;
+
+    switch (code) {
+      case 0xc4:  // bin 8
+      case 0xc7:  // ext 8
+      case 0xd9:  // str 8
+        sizeBytes = 1;
+        break;
+
+      case 0xc5:  // bin 16
+      case 0xc8:  // ext 16
+      case 0xda:  // str 16
+      case 0xdc:  // array 16
+      case 0xde:  // map 16
+        sizeBytes = 2;
+        break;
+
+      case 0xc6:  // bin 32
+      case 0xc9:  // ext 32
+      case 0xdb:  // str 32
+      case 0xdd:  // array 32
+      case 0xdf:  // map 32
+        sizeBytes = 4;
+        break;
+    }
+
+    if (code >= 0xd4 && code <= 0xd8) {  // fixext
+      size = size_t(1) << (code - 0xd4);
+      isExtension = true;
+    }
+
+    switch (code & 0xf0) {
+      case 0x90:  // fixarray
+      case 0x80:  // fixmap
+        size = code & 0x0F;
+        break;
+    }
+
+    switch (code & 0xe0) {
+      case 0xa0:  // fixstr
+        size = code & 0x1f;
+        break;
+    }
+
+    if (sizeBytes) {
+      err = readBytes(header + 1, sizeBytes);
+      if (err)
+        return err;
+
+      uint32_t size32 = 0;
+      for (uint8_t i = 0; i < sizeBytes; i++)
+        size32 = (size32 << 8) | header[i + 1];
+
+      size = size_t(size32);
+      if (size < size32)                        // integer overflow
+        return DeserializationError::NoMemory;  // (not testable on 32/64-bit)
+    }
+
+    // array 16, 32 and fixarray
+    if (code == 0xdc || code == 0xdd || (code & 0xf0) == 0x90)
+      return readArray(variant, size, filter, nestingLimit);
+
+    // map 16, 32 and fixmap
+    if (code == 0xde || code == 0xdf || (code & 0xf0) == 0x80)
+      return readObject(variant, size, filter, nestingLimit);
+
+    // str 8, 16, 32 and fixstr
+    if (code == 0xd9 || code == 0xda || code == 0xdb || (code & 0xe0) == 0xa0) {
+      if (allowValue)
+        return readString(variant, size);
+      else
+        return skipBytes(size);
+    }
+
+    if (isExtension)
+      size++;  // to include the type
+
+    if (allowValue)
+      return readRawString(variant, header, uint8_t(1 + sizeBytes), size);
+    else
+      return skipBytes(size);
+  }
+
+  DeserializationError::Code readByte(uint8_t& value) {
+    int c = reader_.read();
+    if (c < 0)
+      return DeserializationError::IncompleteInput;
+    value = static_cast<uint8_t>(c);
+    return DeserializationError::Ok;
+  }
+
+  DeserializationError::Code readBytes(void* p, size_t n) {
+    if (reader_.readBytes(reinterpret_cast<char*>(p), n) == n)
+      return DeserializationError::Ok;
+    return DeserializationError::IncompleteInput;
+  }
+
+  template <typename T>
+  DeserializationError::Code readBytes(T& value) {
+    return readBytes(&value, sizeof(value));
+  }
+
+  DeserializationError::Code skipBytes(size_t n) {
+    for (; n; --n) {
+      if (reader_.read() < 0)
+        return DeserializationError::IncompleteInput;
+    }
+    return DeserializationError::Ok;
+  }
+
+  DeserializationError::Code readInteger(VariantData* variant, uint8_t width,
+                                         bool isSigned) {
+    uint8_t buffer[8];
+
+    auto err = readBytes(buffer, width);
+    if (err)
+      return err;
+
+    union {
+      int64_t signedValue;
+      uint64_t unsignedValue;
+    };
+
+    if (isSigned)
+      signedValue = static_cast<int8_t>(buffer[0]);  // propagate sign bit
+    else
+      unsignedValue = static_cast<uint8_t>(buffer[0]);
+
+    for (uint8_t i = 1; i < width; i++)
+      unsignedValue = (unsignedValue << 8) | buffer[i];
+
+    if (isSigned) {
+      auto truncatedValue = static_cast<JsonInteger>(signedValue);
+      if (truncatedValue == signedValue) {
+        if (!variant->setInteger(truncatedValue, resources_))
+          return DeserializationError::NoMemory;
+      }
+      // else set null on overflow
+    } else {
+      auto truncatedValue = static_cast<JsonUInt>(unsignedValue);
+      if (truncatedValue == unsignedValue)
+        if (!variant->setInteger(truncatedValue, resources_))
+          return DeserializationError::NoMemory;
+      // else set null on overflow
+    }
+
+    return DeserializationError::Ok;
+  }
+
+  template <typename T>
+  enable_if_t<sizeof(T) == 4, DeserializationError::Code> readFloat(
+      VariantData* variant) {
+    DeserializationError::Code err;
+    T value;
+
+    err = readBytes(value);
+    if (err)
+      return err;
+
+    fixEndianness(value);
+    variant->setFloat(value, resources_);
+
+    return DeserializationError::Ok;
+  }
+
+  template <typename T>
+  enable_if_t<sizeof(T) == 8, DeserializationError::Code> readDouble(
+      VariantData* variant) {
+    DeserializationError::Code err;
+    T value;
+
+    err = readBytes(value);
+    if (err)
+      return err;
+
+    fixEndianness(value);
+    if (variant->setFloat(value, resources_))
+      return DeserializationError::Ok;
+    else
+      return DeserializationError::NoMemory;
+  }
+
+  template <typename T>
+  enable_if_t<sizeof(T) == 4, DeserializationError::Code> readDouble(
+      VariantData* variant) {
+    DeserializationError::Code err;
+    uint8_t i[8];  // input is 8 bytes
+    T value;       // output is 4 bytes
+    uint8_t* o = reinterpret_cast<uint8_t*>(&value);
+
+    err = readBytes(i, 8);
+    if (err)
+      return err;
+
+    doubleToFloat(i, o);
+    fixEndianness(value);
+    variant->setFloat(value, resources_);
+
+    return DeserializationError::Ok;
+  }
+
+  DeserializationError::Code readString(VariantData* variant, size_t n) {
+    DeserializationError::Code err;
+
+    err = readString(n);
+    if (err)
+      return err;
+
+    stringBuffer_.save(variant);
+    return DeserializationError::Ok;
+  }
+
+  DeserializationError::Code readString(size_t n) {
+    char* p = stringBuffer_.reserve(n);
+    if (!p)
+      return DeserializationError::NoMemory;
+
+    return readBytes(p, n);
+  }
+
+  DeserializationError::Code readRawString(VariantData* variant,
+                                           const void* header,
+                                           uint8_t headerSize, size_t n) {
+    auto totalSize = size_t(headerSize + n);
+    if (totalSize < n)                        // integer overflow
+      return DeserializationError::NoMemory;  // (not testable on 64-bit)
+
+    char* p = stringBuffer_.reserve(totalSize);
+    if (!p)
+      return DeserializationError::NoMemory;
+
+    memcpy(p, header, headerSize);
+
+    auto err = readBytes(p + headerSize, n);
+    if (err)
+      return err;
+
+    stringBuffer_.saveRaw(variant);
+    return DeserializationError::Ok;
+  }
+
+  template <typename TFilter>
+  DeserializationError::Code readArray(
+      VariantData* variant, size_t n, TFilter filter,
+      DeserializationOption::NestingLimit nestingLimit) {
+    DeserializationError::Code err;
+
+    if (nestingLimit.reached())
+      return DeserializationError::TooDeep;
+
+    bool allowArray = filter.allowArray();
+
+    ArrayData* array;
+    if (allowArray) {
+      ARDUINOJSON_ASSERT(variant != 0);
+      array = &variant->toArray();
+    } else {
+      array = 0;
+    }
+
+    TFilter elementFilter = filter[0U];
+
+    for (; n; --n) {
+      VariantData* value;
+
+      if (elementFilter.allow()) {
+        ARDUINOJSON_ASSERT(array != 0);
+        value = array->addElement(resources_);
+        if (!value)
+          return DeserializationError::NoMemory;
+      } else {
+        value = 0;
+      }
+
+      err = parseVariant(value, elementFilter, nestingLimit.decrement());
+      if (err)
+        return err;
+    }
+
+    return DeserializationError::Ok;
+  }
+
+  template <typename TFilter>
+  DeserializationError::Code readObject(
+      VariantData* variant, size_t n, TFilter filter,
+      DeserializationOption::NestingLimit nestingLimit) {
+    DeserializationError::Code err;
+
+    if (nestingLimit.reached())
+      return DeserializationError::TooDeep;
+
+    ObjectData* object;
+    if (filter.allowObject()) {
+      ARDUINOJSON_ASSERT(variant != 0);
+      object = &variant->toObject();
+    } else {
+      object = 0;
+    }
+
+    for (; n; --n) {
+      err = readKey();
+      if (err)
+        return err;
+
+      JsonString key = stringBuffer_.str();
+      TFilter memberFilter = filter[key.c_str()];
+      VariantData* member = 0;
+
+      if (memberFilter.allow()) {
+        ARDUINOJSON_ASSERT(object != 0);
+
+        auto keyVariant = object->addPair(&member, resources_);
+        if (!keyVariant)
+          return DeserializationError::NoMemory;
+
+        stringBuffer_.save(keyVariant);
+      }
+
+      err = parseVariant(member, memberFilter, nestingLimit.decrement());
+      if (err)
+        return err;
+    }
+
+    return DeserializationError::Ok;
+  }
+
+  DeserializationError::Code readKey() {
+    DeserializationError::Code err;
+    uint8_t code;
+
+    err = readByte(code);
+    if (err)
+      return err;
+
+    if ((code & 0xe0) == 0xa0)
+      return readString(code & 0x1f);
+
+    if (code >= 0xd9 && code <= 0xdb) {
+      uint8_t sizeBytes = uint8_t(1U << (code - 0xd9));
+      uint32_t size = 0;
+      for (uint8_t i = 0; i < sizeBytes; i++) {
+        err = readByte(code);
+        if (err)
+          return err;
+        size = (size << 8) | code;
+      }
+      return readString(size);
+    }
+
+    return DeserializationError::InvalidInput;
+  }
+
+  ResourceManager* resources_;
+  TReader reader_;
+  StringBuffer stringBuffer_;
+  bool foundSomething_;
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
+
+ARDUINOJSON_BEGIN_PUBLIC_NAMESPACE
+
+// Parses a MessagePack input and puts the result in a JsonDocument.
+// https://arduinojson.org/v7/api/msgpack/deserializemsgpack/
+template <typename TDestination, typename... Args,
+          detail::enable_if_t<
+              detail::is_deserialize_destination<TDestination>::value, int> = 0>
+inline DeserializationError deserializeMsgPack(TDestination&& dst,
+                                               Args&&... args) {
+  using namespace detail;
+  return deserialize<MsgPackDeserializer>(detail::forward<TDestination>(dst),
+                                          detail::forward<Args>(args)...);
+}
+
+// Parses a MessagePack input and puts the result in a JsonDocument.
+// https://arduinojson.org/v7/api/msgpack/deserializemsgpack/
+template <typename TDestination, typename TChar, typename... Args,
+          detail::enable_if_t<
+              detail::is_deserialize_destination<TDestination>::value, int> = 0>
+inline DeserializationError deserializeMsgPack(TDestination&& dst, TChar* input,
+                                               Args&&... args) {
+  using namespace detail;
+  return deserialize<MsgPackDeserializer>(detail::forward<TDestination>(dst),
+                                          input,
+                                          detail::forward<Args>(args)...);
+}
+
+ARDUINOJSON_END_PUBLIC_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/MsgPack/MsgPackExtension.hpp b/lib/ArduinoJson/ArduinoJson/MsgPack/MsgPackExtension.hpp
new file mode 100644
index 0000000..b51eb30
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/MsgPack/MsgPackExtension.hpp
@@ -0,0 +1,120 @@
+#pragma once
+
+#include <ArduinoJson/Variant/Converter.hpp>
+
+ARDUINOJSON_BEGIN_PUBLIC_NAMESPACE
+
+class MsgPackExtension {
+ public:
+  MsgPackExtension() : data_(nullptr), size_(0), type_(0) {}
+  explicit MsgPackExtension(int8_t type, const void* data, size_t size)
+      : data_(data), size_(size), type_(type) {}
+
+  int8_t type() const {
+    return type_;
+  }
+
+  const void* data() const {
+    return data_;
+  }
+
+  size_t size() const {
+    return size_;
+  }
+
+ private:
+  const void* data_;
+  size_t size_;
+  int8_t type_;
+};
+
+template <>
+struct Converter<MsgPackExtension> : private detail::VariantAttorney {
+  static void toJson(MsgPackExtension src, JsonVariant dst) {
+    auto data = VariantAttorney::getData(dst);
+    if (!data)
+      return;
+    auto resources = getResourceManager(dst);
+    data->clear(resources);
+    if (src.data()) {
+      uint8_t format, sizeBytes;
+      if (src.size() >= 0x10000) {
+        format = 0xc9;  // ext 32
+        sizeBytes = 4;
+      } else if (src.size() >= 0x100) {
+        format = 0xc8;  // ext 16
+        sizeBytes = 2;
+      } else if (src.size() == 16) {
+        format = 0xd8;  // fixext 16
+        sizeBytes = 0;
+      } else if (src.size() == 8) {
+        format = 0xd7;  // fixext 8
+        sizeBytes = 0;
+      } else if (src.size() == 4) {
+        format = 0xd6;  // fixext 4
+        sizeBytes = 0;
+      } else if (src.size() == 2) {
+        format = 0xd5;  // fixext 2
+        sizeBytes = 0;
+      } else if (src.size() == 1) {
+        format = 0xd4;  // fixext 1
+        sizeBytes = 0;
+      } else {
+        format = 0xc7;  // ext 8
+        sizeBytes = 1;
+      }
+
+      auto str = resources->createString(src.size() + 2 + sizeBytes);
+      if (str) {
+        resources->saveString(str);
+        auto ptr = reinterpret_cast<uint8_t*>(str->data);
+        *ptr++ = uint8_t(format);
+        for (uint8_t i = 0; i < sizeBytes; i++)
+          *ptr++ = uint8_t(src.size() >> (sizeBytes - i - 1) * 8 & 0xff);
+        *ptr++ = uint8_t(src.type());
+        memcpy(ptr, src.data(), src.size());
+        data->setRawString(str);
+        return;
+      }
+    }
+  }
+
+  static MsgPackExtension fromJson(JsonVariantConst src) {
+    auto data = getData(src);
+    if (!data)
+      return {};
+    auto rawstr = data->asRawString();
+    if (rawstr.size() == 0)
+      return {};
+    auto p = reinterpret_cast<const uint8_t*>(rawstr.c_str());
+
+    size_t payloadSize = 0;
+    uint8_t headerSize = 0;
+
+    const uint8_t& code = p[0];
+
+    if (code >= 0xd4 && code <= 0xd8) {  // fixext 1
+      headerSize = 2;
+      payloadSize = size_t(1) << (code - 0xd4);
+    }
+
+    if (code >= 0xc7 && code <= 0xc9) {
+      uint8_t sizeBytes = uint8_t(1 << (code - 0xc7));
+      for (uint8_t i = 0; i < sizeBytes; i++)
+        payloadSize = (payloadSize << 8) | p[1 + i];
+      headerSize = uint8_t(2 + sizeBytes);
+    }
+
+    if (rawstr.size() == headerSize + payloadSize)
+      return MsgPackExtension(int8_t(p[headerSize - 1]), p + headerSize,
+                              payloadSize);
+
+    return {};
+  }
+
+  static bool checkJson(JsonVariantConst src) {
+    return fromJson(src).data() != nullptr;
+  }
+};
+
+ARDUINOJSON_END_PUBLIC_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/MsgPack/MsgPackSerializer.hpp b/lib/ArduinoJson/ArduinoJson/MsgPack/MsgPackSerializer.hpp
new file mode 100644
index 0000000..27d3679
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/MsgPack/MsgPackSerializer.hpp
@@ -0,0 +1,244 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/MsgPack/endianness.hpp>
+#include <ArduinoJson/Polyfills/assert.hpp>
+#include <ArduinoJson/Polyfills/type_traits.hpp>
+#include <ArduinoJson/Serialization/CountingDecorator.hpp>
+#include <ArduinoJson/Serialization/measure.hpp>
+#include <ArduinoJson/Serialization/serialize.hpp>
+#include <ArduinoJson/Variant/VariantData.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <typename TWriter>
+class MsgPackSerializer : public VariantDataVisitor<size_t> {
+ public:
+  static const bool producesText = false;
+
+  MsgPackSerializer(TWriter writer, const ResourceManager* resources)
+      : writer_(writer), resources_(resources) {}
+
+  template <typename T>
+  enable_if_t<is_floating_point<T>::value && sizeof(T) == 4, size_t> visit(
+      T value32) {
+    if (canConvertNumber<JsonInteger>(value32)) {
+      JsonInteger truncatedValue = JsonInteger(value32);
+      if (value32 == T(truncatedValue))
+        return visit(truncatedValue);
+    }
+    writeByte(0xCA);
+    writeInteger(value32);
+    return bytesWritten();
+  }
+
+  template <typename T>
+  ARDUINOJSON_NO_SANITIZE("float-cast-overflow")
+  enable_if_t<is_floating_point<T>::value && sizeof(T) == 8, size_t> visit(
+      T value64) {
+    float value32 = float(value64);
+    if (value32 == value64)
+      return visit(value32);
+    writeByte(0xCB);
+    writeInteger(value64);
+    return bytesWritten();
+  }
+
+  size_t visit(const ArrayData& array) {
+    size_t n = array.size(resources_);
+    if (n < 0x10) {
+      writeByte(uint8_t(0x90 + n));
+    } else if (n < 0x10000) {
+      writeByte(0xDC);
+      writeInteger(uint16_t(n));
+    } else {
+      writeByte(0xDD);
+      writeInteger(uint32_t(n));
+    }
+
+    auto slotId = array.head();
+    while (slotId != NULL_SLOT) {
+      auto slot = resources_->getVariant(slotId);
+      slot->accept(*this, resources_);
+      slotId = slot->next();
+    }
+
+    return bytesWritten();
+  }
+
+  size_t visit(const ObjectData& object) {
+    size_t n = object.size(resources_);
+    if (n < 0x10) {
+      writeByte(uint8_t(0x80 + n));
+    } else if (n < 0x10000) {
+      writeByte(0xDE);
+      writeInteger(uint16_t(n));
+    } else {
+      writeByte(0xDF);
+      writeInteger(uint32_t(n));
+    }
+
+    auto slotId = object.head();
+    while (slotId != NULL_SLOT) {
+      auto slot = resources_->getVariant(slotId);
+      slot->accept(*this, resources_);
+      slotId = slot->next();
+    }
+
+    return bytesWritten();
+  }
+
+  size_t visit(const char* value) {
+    return visit(JsonString(value));
+  }
+
+  size_t visit(JsonString value) {
+    ARDUINOJSON_ASSERT(!value.isNull());
+
+    auto n = value.size();
+
+    if (n < 0x20) {
+      writeByte(uint8_t(0xA0 + n));
+    } else if (n < 0x100) {
+      writeByte(0xD9);
+      writeInteger(uint8_t(n));
+    } else if (n < 0x10000) {
+      writeByte(0xDA);
+      writeInteger(uint16_t(n));
+    } else {
+      writeByte(0xDB);
+      writeInteger(uint32_t(n));
+    }
+    writeBytes(reinterpret_cast<const uint8_t*>(value.c_str()), n);
+    return bytesWritten();
+  }
+
+  size_t visit(RawString value) {
+    writeBytes(reinterpret_cast<const uint8_t*>(value.data()), value.size());
+    return bytesWritten();
+  }
+
+  size_t visit(JsonInteger value) {
+    if (value > 0) {
+      visit(static_cast<JsonUInt>(value));
+    } else if (value >= -0x20) {
+      writeInteger(int8_t(value));
+    } else if (value >= -0x80) {
+      writeByte(0xD0);
+      writeInteger(int8_t(value));
+    } else if (value >= -0x8000) {
+      writeByte(0xD1);
+      writeInteger(int16_t(value));
+    }
+#if ARDUINOJSON_USE_LONG_LONG
+    else if (value >= -0x80000000LL)
+#else
+    else
+#endif
+    {
+      writeByte(0xD2);
+      writeInteger(int32_t(value));
+    }
+#if ARDUINOJSON_USE_LONG_LONG
+    else {
+      writeByte(0xD3);
+      writeInteger(int64_t(value));
+    }
+#endif
+    return bytesWritten();
+  }
+
+  size_t visit(JsonUInt value) {
+    if (value <= 0x7F) {
+      writeInteger(uint8_t(value));
+    } else if (value <= 0xFF) {
+      writeByte(0xCC);
+      writeInteger(uint8_t(value));
+    } else if (value <= 0xFFFF) {
+      writeByte(0xCD);
+      writeInteger(uint16_t(value));
+    }
+#if ARDUINOJSON_USE_LONG_LONG
+    else if (value <= 0xFFFFFFFF)
+#else
+    else
+#endif
+    {
+      writeByte(0xCE);
+      writeInteger(uint32_t(value));
+    }
+#if ARDUINOJSON_USE_LONG_LONG
+    else {
+      writeByte(0xCF);
+      writeInteger(uint64_t(value));
+    }
+#endif
+    return bytesWritten();
+  }
+
+  size_t visit(bool value) {
+    writeByte(value ? 0xC3 : 0xC2);
+    return bytesWritten();
+  }
+
+  size_t visit(nullptr_t) {
+    writeByte(0xC0);
+    return bytesWritten();
+  }
+
+ private:
+  size_t bytesWritten() const {
+    return writer_.count();
+  }
+
+  void writeByte(uint8_t c) {
+    writer_.write(c);
+  }
+
+  void writeBytes(const uint8_t* p, size_t n) {
+    writer_.write(p, n);
+  }
+
+  template <typename T>
+  void writeInteger(T value) {
+    fixEndianness(value);
+    writeBytes(reinterpret_cast<uint8_t*>(&value), sizeof(value));
+  }
+
+  CountingDecorator<TWriter> writer_;
+  const ResourceManager* resources_;
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
+
+ARDUINOJSON_BEGIN_PUBLIC_NAMESPACE
+
+// Produces a MessagePack document.
+// https://arduinojson.org/v7/api/msgpack/serializemsgpack/
+template <
+    typename TDestination,
+    detail::enable_if_t<!detail::is_pointer<TDestination>::value, int> = 0>
+inline size_t serializeMsgPack(JsonVariantConst source, TDestination& output) {
+  using namespace ArduinoJson::detail;
+  return serialize<MsgPackSerializer>(source, output);
+}
+
+// Produces a MessagePack document.
+// https://arduinojson.org/v7/api/msgpack/serializemsgpack/
+inline size_t serializeMsgPack(JsonVariantConst source, void* output,
+                               size_t size) {
+  using namespace ArduinoJson::detail;
+  return serialize<MsgPackSerializer>(source, output, size);
+}
+
+// Computes the length of the document that serializeMsgPack() produces.
+// https://arduinojson.org/v7/api/msgpack/measuremsgpack/
+inline size_t measureMsgPack(JsonVariantConst source) {
+  using namespace ArduinoJson::detail;
+  return measure<MsgPackSerializer>(source);
+}
+
+ARDUINOJSON_END_PUBLIC_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/MsgPack/endianness.hpp b/lib/ArduinoJson/ArduinoJson/MsgPack/endianness.hpp
new file mode 100644
index 0000000..0b1948c
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/MsgPack/endianness.hpp
@@ -0,0 +1,46 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Polyfills/type_traits.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+#if ARDUINOJSON_LITTLE_ENDIAN
+inline void swapBytes(uint8_t& a, uint8_t& b) {
+  uint8_t t(a);
+  a = b;
+  b = t;
+}
+
+inline void fixEndianness(uint8_t* p, integral_constant<size_t, 8>) {
+  swapBytes(p[0], p[7]);
+  swapBytes(p[1], p[6]);
+  swapBytes(p[2], p[5]);
+  swapBytes(p[3], p[4]);
+}
+
+inline void fixEndianness(uint8_t* p, integral_constant<size_t, 4>) {
+  swapBytes(p[0], p[3]);
+  swapBytes(p[1], p[2]);
+}
+
+inline void fixEndianness(uint8_t* p, integral_constant<size_t, 2>) {
+  swapBytes(p[0], p[1]);
+}
+
+inline void fixEndianness(uint8_t*, integral_constant<size_t, 1>) {}
+
+template <typename T>
+inline void fixEndianness(T& value) {
+  fixEndianness(reinterpret_cast<uint8_t*>(&value),
+                integral_constant<size_t, sizeof(T)>());
+}
+#else
+template <typename T>
+inline void fixEndianness(T&) {}
+#endif
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/MsgPack/ieee754.hpp b/lib/ArduinoJson/ArduinoJson/MsgPack/ieee754.hpp
new file mode 100644
index 0000000..952ef39
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/MsgPack/ieee754.hpp
@@ -0,0 +1,18 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+inline void doubleToFloat(const uint8_t d[8], uint8_t f[4]) {
+  f[0] = uint8_t((d[0] & 0xC0) | (d[0] << 3 & 0x3f) | (d[1] >> 5));
+  f[1] = uint8_t((d[1] << 3) | (d[2] >> 5));
+  f[2] = uint8_t((d[2] << 3) | (d[3] >> 5));
+  f[3] = uint8_t((d[3] << 3) | (d[4] >> 5));
+}
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Namespace.hpp b/lib/ArduinoJson/ArduinoJson/Namespace.hpp
new file mode 100644
index 0000000..f583037
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Namespace.hpp
@@ -0,0 +1,42 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Configuration.hpp>
+#include <ArduinoJson/Polyfills/preprocessor.hpp>
+#include <ArduinoJson/version.hpp>
+
+#ifndef ARDUINOJSON_VERSION_NAMESPACE
+
+#  define ARDUINOJSON_VERSION_NAMESPACE                               \
+    ARDUINOJSON_CONCAT5(                                              \
+        ARDUINOJSON_VERSION_MACRO,                                    \
+        ARDUINOJSON_BIN2ALPHA(ARDUINOJSON_ENABLE_PROGMEM,             \
+                              ARDUINOJSON_USE_LONG_LONG,              \
+                              ARDUINOJSON_USE_DOUBLE, 1),             \
+        ARDUINOJSON_BIN2ALPHA(                                        \
+            ARDUINOJSON_ENABLE_NAN, ARDUINOJSON_ENABLE_INFINITY,      \
+            ARDUINOJSON_ENABLE_COMMENTS, ARDUINOJSON_DECODE_UNICODE), \
+        ARDUINOJSON_SLOT_ID_SIZE, ARDUINOJSON_STRING_LENGTH_SIZE)
+
+#endif
+
+#define ARDUINOJSON_BEGIN_PUBLIC_NAMESPACE \
+  namespace ArduinoJson {                  \
+  inline namespace ARDUINOJSON_VERSION_NAMESPACE {
+
+#define ARDUINOJSON_END_PUBLIC_NAMESPACE \
+  }                                      \
+  }
+
+#define ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE        \
+  namespace ArduinoJson {                          \
+  inline namespace ARDUINOJSON_VERSION_NAMESPACE { \
+  namespace detail {
+
+#define ARDUINOJSON_END_PRIVATE_NAMESPACE \
+  }                                       \
+  }                                       \
+  }
diff --git a/lib/ArduinoJson/ArduinoJson/Numbers/FloatParts.hpp b/lib/ArduinoJson/ArduinoJson/Numbers/FloatParts.hpp
new file mode 100644
index 0000000..cbc06fe
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Numbers/FloatParts.hpp
@@ -0,0 +1,95 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Configuration.hpp>
+#include <ArduinoJson/Numbers/FloatTraits.hpp>
+#include <ArduinoJson/Numbers/JsonFloat.hpp>
+#include <ArduinoJson/Polyfills/math.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+struct FloatParts {
+  uint32_t integral;
+  uint32_t decimal;
+  int16_t exponent;
+  int8_t decimalPlaces;
+};
+
+template <typename TFloat>
+inline int16_t normalize(TFloat& value) {
+  using traits = FloatTraits<TFloat>;
+  int16_t powersOf10 = 0;
+
+  int8_t index = sizeof(TFloat) == 8 ? 8 : 5;
+  int bit = 1 << index;
+
+  if (value >= ARDUINOJSON_POSITIVE_EXPONENTIATION_THRESHOLD) {
+    for (; index >= 0; index--) {
+      if (value >= traits::positiveBinaryPowersOfTen()[index]) {
+        value *= traits::negativeBinaryPowersOfTen()[index];
+        powersOf10 = int16_t(powersOf10 + bit);
+      }
+      bit >>= 1;
+    }
+  }
+
+  if (value > 0 && value <= ARDUINOJSON_NEGATIVE_EXPONENTIATION_THRESHOLD) {
+    for (; index >= 0; index--) {
+      if (value < traits::negativeBinaryPowersOfTen()[index] * 10) {
+        value *= traits::positiveBinaryPowersOfTen()[index];
+        powersOf10 = int16_t(powersOf10 - bit);
+      }
+      bit >>= 1;
+    }
+  }
+
+  return powersOf10;
+}
+
+constexpr uint32_t pow10(int exponent) {
+  return (exponent == 0) ? 1 : 10 * pow10(exponent - 1);
+}
+
+inline FloatParts decomposeFloat(JsonFloat value, int8_t decimalPlaces) {
+  uint32_t maxDecimalPart = pow10(decimalPlaces);
+
+  int16_t exponent = normalize(value);
+
+  uint32_t integral = uint32_t(value);
+  // reduce number of decimal places by the number of integral places
+  for (uint32_t tmp = integral; tmp >= 10; tmp /= 10) {
+    maxDecimalPart /= 10;
+    decimalPlaces--;
+  }
+
+  JsonFloat remainder =
+      (value - JsonFloat(integral)) * JsonFloat(maxDecimalPart);
+
+  uint32_t decimal = uint32_t(remainder);
+  remainder = remainder - JsonFloat(decimal);
+
+  // rounding:
+  // increment by 1 if remainder >= 0.5
+  decimal += uint32_t(remainder * 2);
+  if (decimal >= maxDecimalPart) {
+    decimal = 0;
+    integral++;
+    if (exponent && integral >= 10) {
+      exponent++;
+      integral = 1;
+    }
+  }
+
+  // remove trailing zeros
+  while (decimal % 10 == 0 && decimalPlaces > 0) {
+    decimal /= 10;
+    decimalPlaces--;
+  }
+
+  return {integral, decimal, exponent, decimalPlaces};
+}
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Numbers/FloatTraits.hpp b/lib/ArduinoJson/ArduinoJson/Numbers/FloatTraits.hpp
new file mode 100644
index 0000000..80111c9
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Numbers/FloatTraits.hpp
@@ -0,0 +1,220 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <stddef.h>  // for size_t
+#include <stdint.h>
+
+#include <ArduinoJson/Configuration.hpp>
+#include <ArduinoJson/Polyfills/alias_cast.hpp>
+#include <ArduinoJson/Polyfills/math.hpp>
+#include <ArduinoJson/Polyfills/pgmspace_generic.hpp>
+#include <ArduinoJson/Polyfills/preprocessor.hpp>
+#include <ArduinoJson/Polyfills/type_traits.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <typename T, size_t = sizeof(T)>
+struct FloatTraits {};
+
+template <typename T>
+struct FloatTraits<T, 8 /*64bits*/> {
+  using mantissa_type = uint64_t;
+  static const short mantissa_bits = 52;
+  static const mantissa_type mantissa_max =
+      (mantissa_type(1) << mantissa_bits) - 1;
+
+  using exponent_type = int16_t;
+  static const exponent_type exponent_max = 308;
+
+  static const size_t binaryPowersOfTen = 9;
+
+  static pgm_ptr<T> positiveBinaryPowersOfTen() {
+    ARDUINOJSON_DEFINE_PROGMEM_ARRAY(  //
+        uint64_t, factors,
+        {
+            0x4024000000000000,  // 1e1
+            0x4059000000000000,  // 1e2
+            0x40C3880000000000,  // 1e4
+            0x4197D78400000000,  // 1e8
+            0x4341C37937E08000,  // 1e16
+            0x4693B8B5B5056E17,  // 1e32
+            0x4D384F03E93FF9F5,  // 1e64
+            0x5A827748F9301D32,  // 1e128
+            0x75154FDD7F73BF3C,  // 1e256
+        });
+    return pgm_ptr<T>(reinterpret_cast<const T*>(factors));
+  }
+
+  static pgm_ptr<T> negativeBinaryPowersOfTen() {
+    ARDUINOJSON_DEFINE_PROGMEM_ARRAY(  //
+        uint64_t, factors,
+        {
+            0x3FB999999999999A,  // 1e-1
+            0x3F847AE147AE147B,  // 1e-2
+            0x3F1A36E2EB1C432D,  // 1e-4
+            0x3E45798EE2308C3A,  // 1e-8
+            0x3C9CD2B297D889BC,  // 1e-16
+            0x3949F623D5A8A733,  // 1e-32
+            0x32A50FFD44F4A73D,  // 1e-64
+            0x255BBA08CF8C979D,  // 1e-128
+            0x0AC8062864AC6F43   // 1e-256
+        });
+    return pgm_ptr<T>(reinterpret_cast<const T*>(factors));
+  }
+
+  static T nan() {
+    return forge(0x7ff8000000000000);
+  }
+
+  static T inf() {
+    return forge(0x7ff0000000000000);
+  }
+
+  static T highest() {
+    return forge(0x7FEFFFFFFFFFFFFF);
+  }
+
+  template <typename TOut>  // int64_t
+  static T highest_for(
+      enable_if_t<is_integral<TOut>::value && is_signed<TOut>::value &&
+                      sizeof(TOut) == 8,
+                  signed>* = 0) {
+    return forge(0x43DFFFFFFFFFFFFF);  //  9.2233720368547748e+18
+  }
+
+  template <typename TOut>  // uint64_t
+  static T highest_for(
+      enable_if_t<is_integral<TOut>::value && is_unsigned<TOut>::value &&
+                      sizeof(TOut) == 8,
+                  unsigned>* = 0) {
+    return forge(0x43EFFFFFFFFFFFFF);  //  1.8446744073709549568e+19
+  }
+
+  static T lowest() {
+    return forge(0xFFEFFFFFFFFFFFFF);
+  }
+
+  // constructs a double floating point values from its binary representation
+  // we use this function to workaround platforms with single precision literals
+  // (for example, when -fsingle-precision-constant is passed to GCC)
+  static T forge(uint64_t bits) {
+    return alias_cast<T>(bits);
+  }
+};
+
+template <typename T>
+struct FloatTraits<T, 4 /*32bits*/> {
+  using mantissa_type = uint32_t;
+  static const short mantissa_bits = 23;
+  static const mantissa_type mantissa_max =
+      (mantissa_type(1) << mantissa_bits) - 1;
+
+  using exponent_type = int8_t;
+  static const exponent_type exponent_max = 38;
+
+  static const size_t binaryPowersOfTen = 6;
+
+  static pgm_ptr<T> positiveBinaryPowersOfTen() {
+    ARDUINOJSON_DEFINE_PROGMEM_ARRAY(uint32_t, factors,
+                                     {
+                                         0x41200000,  // 1e1f
+                                         0x42c80000,  // 1e2f
+                                         0x461c4000,  // 1e4f
+                                         0x4cbebc20,  // 1e8f
+                                         0x5a0e1bca,  // 1e16f
+                                         0x749dc5ae   // 1e32f
+                                     });
+    return pgm_ptr<T>(reinterpret_cast<const T*>(factors));
+  }
+
+  static pgm_ptr<T> negativeBinaryPowersOfTen() {
+    ARDUINOJSON_DEFINE_PROGMEM_ARRAY(uint32_t, factors,
+                                     {
+                                         0x3dcccccd,  // 1e-1f
+                                         0x3c23d70a,  // 1e-2f
+                                         0x38d1b717,  // 1e-4f
+                                         0x322bcc77,  // 1e-8f
+                                         0x24e69595,  // 1e-16f
+                                         0x0a4fb11f   // 1e-32f
+                                     });
+    return pgm_ptr<T>(reinterpret_cast<const T*>(factors));
+  }
+
+  static T forge(uint32_t bits) {
+    return alias_cast<T>(bits);
+  }
+
+  static T nan() {
+    return forge(0x7fc00000);
+  }
+
+  static T inf() {
+    return forge(0x7f800000);
+  }
+
+  static T highest() {
+    return forge(0x7f7fffff);
+  }
+
+  template <typename TOut>  // int32_t
+  static T highest_for(
+      enable_if_t<is_integral<TOut>::value && is_signed<TOut>::value &&
+                      sizeof(TOut) == 4,
+                  signed>* = 0) {
+    return forge(0x4EFFFFFF);  // 2.14748352E9
+  }
+
+  template <typename TOut>  // uint32_t
+  static T highest_for(
+      enable_if_t<is_integral<TOut>::value && is_unsigned<TOut>::value &&
+                      sizeof(TOut) == 4,
+                  unsigned>* = 0) {
+    return forge(0x4F7FFFFF);  // 4.29496704E9
+  }
+
+  template <typename TOut>  // int64_t
+  static T highest_for(
+      enable_if_t<is_integral<TOut>::value && is_signed<TOut>::value &&
+                      sizeof(TOut) == 8,
+                  signed>* = 0) {
+    return forge(0x5EFFFFFF);  // 9.22337148709896192E18
+  }
+
+  template <typename TOut>  // uint64_t
+  static T highest_for(
+      enable_if_t<is_integral<TOut>::value && is_unsigned<TOut>::value &&
+                      sizeof(TOut) == 8,
+                  unsigned>* = 0) {
+    return forge(0x5F7FFFFF);  // 1.844674297419792384E19
+  }
+
+  static T lowest() {
+    return forge(0xFf7fffff);
+  }
+};
+
+template <typename TFloat, typename TExponent>
+inline TFloat make_float(TFloat m, TExponent e) {
+  using traits = FloatTraits<TFloat>;
+
+  auto powersOfTen = e > 0 ? traits::positiveBinaryPowersOfTen()
+                           : traits::negativeBinaryPowersOfTen();
+  auto count = traits::binaryPowersOfTen;
+
+  if (e <= 0)
+    e = TExponent(-e);
+
+  for (uint8_t index = 0; e != 0; index++) {
+    if (index >= count)
+      return traits::nan();
+    if (e & 1)
+      m *= powersOfTen[index];
+    e >>= 1;
+  }
+  return m;
+}
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Numbers/JsonFloat.hpp b/lib/ArduinoJson/ArduinoJson/Numbers/JsonFloat.hpp
new file mode 100644
index 0000000..bca3c3a
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Numbers/JsonFloat.hpp
@@ -0,0 +1,18 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Configuration.hpp>
+#include <ArduinoJson/Namespace.hpp>
+
+ARDUINOJSON_BEGIN_PUBLIC_NAMESPACE
+
+#if ARDUINOJSON_USE_DOUBLE
+using JsonFloat = double;
+#else
+using JsonFloat = float;
+#endif
+
+ARDUINOJSON_END_PUBLIC_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Numbers/JsonInteger.hpp b/lib/ArduinoJson/ArduinoJson/Numbers/JsonInteger.hpp
new file mode 100644
index 0000000..ebff1c4
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Numbers/JsonInteger.hpp
@@ -0,0 +1,28 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Configuration.hpp>
+#include <ArduinoJson/Namespace.hpp>
+
+#include <stdint.h>  // int64_t
+
+ARDUINOJSON_BEGIN_PUBLIC_NAMESPACE
+
+#if ARDUINOJSON_USE_LONG_LONG
+using JsonInteger = int64_t;
+using JsonUInt = uint64_t;
+#else
+using JsonInteger = long;
+using JsonUInt = unsigned long;
+#endif
+
+ARDUINOJSON_END_PUBLIC_NAMESPACE
+
+#define ARDUINOJSON_ASSERT_INTEGER_TYPE_IS_SUPPORTED(T)                  \
+  static_assert(sizeof(T) <= sizeof(ArduinoJson::JsonInteger),           \
+                "To use 64-bit integers with ArduinoJson, you must set " \
+                "ARDUINOJSON_USE_LONG_LONG to 1. See "                   \
+                "https://arduinojson.org/v7/api/config/use_long_long/");
diff --git a/lib/ArduinoJson/ArduinoJson/Numbers/arithmeticCompare.hpp b/lib/ArduinoJson/ArduinoJson/Numbers/arithmeticCompare.hpp
new file mode 100644
index 0000000..d548cb1
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Numbers/arithmeticCompare.hpp
@@ -0,0 +1,116 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Numbers/JsonInteger.hpp>
+#include <ArduinoJson/Polyfills/type_traits.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+enum CompareResult {
+  COMPARE_RESULT_DIFFER = 0,
+  COMPARE_RESULT_EQUAL = 1,
+  COMPARE_RESULT_GREATER = 2,
+  COMPARE_RESULT_LESS = 4,
+
+  COMPARE_RESULT_GREATER_OR_EQUAL = 3,
+  COMPARE_RESULT_LESS_OR_EQUAL = 5
+};
+
+template <typename T>
+CompareResult arithmeticCompare(const T& lhs, const T& rhs) {
+  if (lhs < rhs)
+    return COMPARE_RESULT_LESS;
+  else if (lhs > rhs)
+    return COMPARE_RESULT_GREATER;
+  else
+    return COMPARE_RESULT_EQUAL;
+}
+
+template <typename T1, typename T2>
+CompareResult arithmeticCompare(
+    const T1& lhs, const T2& rhs,
+    enable_if_t<is_integral<T1>::value && is_integral<T2>::value &&
+                sizeof(T1) < sizeof(T2)>* = 0) {
+  return arithmeticCompare<T2>(static_cast<T2>(lhs), rhs);
+}
+
+template <typename T1, typename T2>
+CompareResult arithmeticCompare(
+    const T1& lhs, const T2& rhs,
+    enable_if_t<is_integral<T1>::value && is_integral<T2>::value &&
+                sizeof(T2) < sizeof(T1)>* = 0) {
+  return arithmeticCompare<T1>(lhs, static_cast<T1>(rhs));
+}
+
+template <typename T1, typename T2>
+CompareResult arithmeticCompare(
+    const T1& lhs, const T2& rhs,
+    enable_if_t<is_integral<T1>::value && is_integral<T2>::value &&
+                is_signed<T1>::value == is_signed<T2>::value &&
+                sizeof(T2) == sizeof(T1)>* = 0) {
+  return arithmeticCompare<T1>(lhs, static_cast<T1>(rhs));
+}
+
+template <typename T1, typename T2>
+CompareResult arithmeticCompare(
+    const T1& lhs, const T2& rhs,
+    enable_if_t<is_integral<T1>::value && is_integral<T2>::value &&
+                is_unsigned<T1>::value && is_signed<T2>::value &&
+                sizeof(T2) == sizeof(T1)>* = 0) {
+  if (rhs < 0)
+    return COMPARE_RESULT_GREATER;
+  return arithmeticCompare<T1>(lhs, static_cast<T1>(rhs));
+}
+
+template <typename T1, typename T2>
+CompareResult arithmeticCompare(
+    const T1& lhs, const T2& rhs,
+    enable_if_t<is_integral<T1>::value && is_integral<T2>::value &&
+                is_signed<T1>::value && is_unsigned<T2>::value &&
+                sizeof(T2) == sizeof(T1)>* = 0) {
+  if (lhs < 0)
+    return COMPARE_RESULT_LESS;
+  return arithmeticCompare<T2>(static_cast<T2>(lhs), rhs);
+}
+
+template <typename T1, typename T2>
+CompareResult arithmeticCompare(
+    const T1& lhs, const T2& rhs,
+    enable_if_t<is_floating_point<T1>::value || is_floating_point<T2>::value>* =
+        0) {
+  return arithmeticCompare<double>(static_cast<double>(lhs),
+                                   static_cast<double>(rhs));
+}
+
+template <typename T2>
+CompareResult arithmeticCompareNegateLeft(
+    JsonUInt, const T2&, enable_if_t<is_unsigned<T2>::value>* = 0) {
+  return COMPARE_RESULT_LESS;
+}
+
+template <typename T2>
+CompareResult arithmeticCompareNegateLeft(
+    JsonUInt lhs, const T2& rhs, enable_if_t<is_signed<T2>::value>* = 0) {
+  if (rhs > 0)
+    return COMPARE_RESULT_LESS;
+  return arithmeticCompare(-rhs, static_cast<T2>(lhs));
+}
+
+template <typename T1>
+CompareResult arithmeticCompareNegateRight(
+    const T1&, JsonUInt, enable_if_t<is_unsigned<T1>::value>* = 0) {
+  return COMPARE_RESULT_GREATER;
+}
+
+template <typename T1>
+CompareResult arithmeticCompareNegateRight(
+    const T1& lhs, JsonUInt rhs, enable_if_t<is_signed<T1>::value>* = 0) {
+  if (lhs > 0)
+    return COMPARE_RESULT_GREATER;
+  return arithmeticCompare(static_cast<T1>(rhs), -lhs);
+}
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Numbers/convertNumber.hpp b/lib/ArduinoJson/ArduinoJson/Numbers/convertNumber.hpp
new file mode 100644
index 0000000..ce44830
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Numbers/convertNumber.hpp
@@ -0,0 +1,145 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#if defined(__clang__)
+#  pragma clang diagnostic push
+#  pragma clang diagnostic ignored "-Wconversion"
+#elif defined(__GNUC__)
+#  pragma GCC diagnostic push
+#  pragma GCC diagnostic ignored "-Wconversion"
+#endif
+
+#include <ArduinoJson/Numbers/FloatTraits.hpp>
+#include <ArduinoJson/Numbers/JsonFloat.hpp>
+#include <ArduinoJson/Polyfills/limits.hpp>
+#include <ArduinoJson/Polyfills/type_traits.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+// uint32 -> int32
+// uint64 -> int32
+template <typename TOut, typename TIn>
+enable_if_t<is_integral<TIn>::value && is_unsigned<TIn>::value &&
+                is_integral<TOut>::value && sizeof(TOut) <= sizeof(TIn),
+            bool>
+canConvertNumber(TIn value) {
+  return value <= TIn(numeric_limits<TOut>::highest());
+}
+
+// uint32 -> int64
+template <typename TOut, typename TIn>
+enable_if_t<is_integral<TIn>::value && is_unsigned<TIn>::value &&
+                is_integral<TOut>::value && sizeof(TIn) < sizeof(TOut),
+            bool>
+canConvertNumber(TIn) {
+  return true;
+}
+
+// uint32 -> float
+// int32 -> float
+template <typename TOut, typename TIn>
+enable_if_t<is_integral<TIn>::value && is_floating_point<TOut>::value, bool>
+canConvertNumber(TIn) {
+  return true;
+}
+
+// int64 -> int32
+template <typename TOut, typename TIn>
+enable_if_t<is_integral<TIn>::value && is_signed<TIn>::value &&
+                is_integral<TOut>::value && is_signed<TOut>::value &&
+                sizeof(TOut) < sizeof(TIn),
+            bool>
+canConvertNumber(TIn value) {
+  return value >= TIn(numeric_limits<TOut>::lowest()) &&
+         value <= TIn(numeric_limits<TOut>::highest());
+}
+
+// int32 -> int32
+// int32 -> int64
+template <typename TOut, typename TIn>
+enable_if_t<is_integral<TIn>::value && is_signed<TIn>::value &&
+                is_integral<TOut>::value && is_signed<TOut>::value &&
+                sizeof(TIn) <= sizeof(TOut),
+            bool>
+canConvertNumber(TIn) {
+  return true;
+}
+
+// int32 -> uint32
+// int32 -> uint64
+template <typename TOut, typename TIn>
+enable_if_t<is_integral<TIn>::value && is_signed<TIn>::value &&
+                is_integral<TOut>::value && is_unsigned<TOut>::value &&
+                sizeof(TOut) >= sizeof(TIn),
+            bool>
+canConvertNumber(TIn value) {
+  if (value < 0)
+    return false;
+  return TOut(value) <= numeric_limits<TOut>::highest();
+}
+
+// int32 -> uint16
+template <typename TOut, typename TIn>
+enable_if_t<is_integral<TIn>::value && is_signed<TIn>::value &&
+                is_integral<TOut>::value && is_unsigned<TOut>::value &&
+                sizeof(TOut) < sizeof(TIn),
+            bool>
+canConvertNumber(TIn value) {
+  if (value < 0)
+    return false;
+  return value <= TIn(numeric_limits<TOut>::highest());
+}
+
+// float32 -> int16
+// float64 -> int32
+template <typename TOut, typename TIn>
+enable_if_t<is_floating_point<TIn>::value && is_integral<TOut>::value &&
+                sizeof(TOut) < sizeof(TIn),
+            bool>
+canConvertNumber(TIn value) {
+  return value >= numeric_limits<TOut>::lowest() &&
+         value <= numeric_limits<TOut>::highest();
+}
+
+// float32 -> int32
+// float32 -> uint32
+// float32 -> int64
+// float32 -> uint64
+// float64 -> int64
+// float64 -> uint64
+template <typename TOut, typename TIn>
+enable_if_t<is_floating_point<TIn>::value && is_integral<TOut>::value &&
+                sizeof(TOut) >= sizeof(TIn),
+            bool>
+canConvertNumber(TIn value) {
+  // Avoid error "9.22337e+18 is outside the range of representable values of
+  // type 'long'"
+  return value >= numeric_limits<TOut>::lowest() &&
+         value <= FloatTraits<TIn>::template highest_for<TOut>();
+}
+
+// float32 -> float32
+// float64 -> float64
+// float64 -> float32
+template <typename TOut, typename TIn>
+enable_if_t<is_floating_point<TIn>::value && is_floating_point<TOut>::value,
+            bool>
+canConvertNumber(TIn) {
+  return true;
+}
+
+template <typename TOut, typename TIn>
+TOut convertNumber(TIn value) {
+  return canConvertNumber<TOut>(value) ? TOut(value) : 0;
+}
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
+
+#if defined(__clang__)
+#  pragma clang diagnostic pop
+#elif defined(__GNUC__)
+#  pragma GCC diagnostic pop
+#endif
diff --git a/lib/ArduinoJson/ArduinoJson/Numbers/parseNumber.hpp b/lib/ArduinoJson/ArduinoJson/Numbers/parseNumber.hpp
new file mode 100644
index 0000000..bbe4e8d
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Numbers/parseNumber.hpp
@@ -0,0 +1,238 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Numbers/FloatTraits.hpp>
+#include <ArduinoJson/Numbers/JsonFloat.hpp>
+#include <ArduinoJson/Numbers/convertNumber.hpp>
+#include <ArduinoJson/Polyfills/assert.hpp>
+#include <ArduinoJson/Polyfills/ctype.hpp>
+#include <ArduinoJson/Polyfills/math.hpp>
+#include <ArduinoJson/Polyfills/type_traits.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <typename A, typename B>
+using largest_type = conditional_t<(sizeof(A) > sizeof(B)), A, B>;
+
+enum class NumberType : uint8_t {
+  Invalid,
+  Float,
+  SignedInteger,
+  UnsignedInteger,
+#if ARDUINOJSON_USE_DOUBLE
+  Double,
+#endif
+};
+
+union NumberValue {
+  NumberValue() {}
+  NumberValue(float x) : asFloat(x) {}
+  NumberValue(JsonInteger x) : asSignedInteger(x) {}
+  NumberValue(JsonUInt x) : asUnsignedInteger(x) {}
+#if ARDUINOJSON_USE_DOUBLE
+  NumberValue(double x) : asDouble(x) {}
+#endif
+
+  JsonInteger asSignedInteger;
+  JsonUInt asUnsignedInteger;
+  float asFloat;
+#if ARDUINOJSON_USE_DOUBLE
+  double asDouble;
+#endif
+};
+
+class Number {
+  NumberType type_;
+  NumberValue value_;
+
+ public:
+  Number() : type_(NumberType::Invalid) {}
+  Number(float value) : type_(NumberType::Float), value_(value) {}
+  Number(JsonInteger value) : type_(NumberType::SignedInteger), value_(value) {}
+  Number(JsonUInt value) : type_(NumberType::UnsignedInteger), value_(value) {}
+#if ARDUINOJSON_USE_DOUBLE
+  Number(double value) : type_(NumberType::Double), value_(value) {}
+#endif
+
+  template <typename T>
+  T convertTo() const {
+    switch (type_) {
+      case NumberType::Float:
+        return convertNumber<T>(value_.asFloat);
+      case NumberType::SignedInteger:
+        return convertNumber<T>(value_.asSignedInteger);
+      case NumberType::UnsignedInteger:
+        return convertNumber<T>(value_.asUnsignedInteger);
+#if ARDUINOJSON_USE_DOUBLE
+      case NumberType::Double:
+        return convertNumber<T>(value_.asDouble);
+#endif
+      default:
+        return T();
+    }
+  }
+
+  NumberType type() const {
+    return type_;
+  }
+
+  JsonInteger asSignedInteger() const {
+    ARDUINOJSON_ASSERT(type_ == NumberType::SignedInteger);
+    return value_.asSignedInteger;
+  }
+
+  JsonUInt asUnsignedInteger() const {
+    ARDUINOJSON_ASSERT(type_ == NumberType::UnsignedInteger);
+    return value_.asUnsignedInteger;
+  }
+
+  float asFloat() const {
+    ARDUINOJSON_ASSERT(type_ == NumberType::Float);
+    return value_.asFloat;
+  }
+
+#if ARDUINOJSON_USE_DOUBLE
+  double asDouble() const {
+    ARDUINOJSON_ASSERT(type_ == NumberType::Double);
+    return value_.asDouble;
+  }
+#endif
+};
+
+inline Number parseNumber(const char* s) {
+  using traits = FloatTraits<JsonFloat>;
+  using mantissa_t = largest_type<traits::mantissa_type, JsonUInt>;
+  using exponent_t = traits::exponent_type;
+
+  ARDUINOJSON_ASSERT(s != 0);
+
+  bool is_negative = false;
+  switch (*s) {
+    case '-':
+      is_negative = true;
+      s++;
+      break;
+    case '+':
+      s++;
+      break;
+  }
+
+#if ARDUINOJSON_ENABLE_NAN
+  if (*s == 'n' || *s == 'N') {
+    return Number(traits::nan());
+  }
+#endif
+
+#if ARDUINOJSON_ENABLE_INFINITY
+  if (*s == 'i' || *s == 'I') {
+    return Number(is_negative ? -traits::inf() : traits::inf());
+  }
+#endif
+
+  if (!isdigit(*s) && *s != '.')
+    return Number();
+
+  mantissa_t mantissa = 0;
+  exponent_t exponent_offset = 0;
+  const mantissa_t maxUint = JsonUInt(-1);
+
+  while (isdigit(*s)) {
+    uint8_t digit = uint8_t(*s - '0');
+    if (mantissa > maxUint / 10)
+      break;
+    mantissa *= 10;
+    if (mantissa > maxUint - digit)
+      break;
+    mantissa += digit;
+    s++;
+  }
+
+  if (*s == '\0') {
+    if (is_negative) {
+      const mantissa_t sintMantissaMax = mantissa_t(1)
+                                         << (sizeof(JsonInteger) * 8 - 1);
+      if (mantissa <= sintMantissaMax) {
+        return Number(JsonInteger(~mantissa + 1));
+      }
+    } else {
+      return Number(JsonUInt(mantissa));
+    }
+  }
+
+  // avoid mantissa overflow
+  while (mantissa > traits::mantissa_max) {
+    mantissa /= 10;
+    exponent_offset++;
+  }
+
+  // remaing digits can't fit in the mantissa
+  while (isdigit(*s)) {
+    exponent_offset++;
+    s++;
+  }
+
+  if (*s == '.') {
+    s++;
+    while (isdigit(*s)) {
+      if (mantissa < traits::mantissa_max / 10) {
+        mantissa = mantissa * 10 + uint8_t(*s - '0');
+        exponent_offset--;
+      }
+      s++;
+    }
+  }
+
+  int exponent = 0;
+  if (*s == 'e' || *s == 'E') {
+    s++;
+    bool negative_exponent = false;
+    if (*s == '-') {
+      negative_exponent = true;
+      s++;
+    } else if (*s == '+') {
+      s++;
+    }
+
+    while (isdigit(*s)) {
+      exponent = exponent * 10 + (*s - '0');
+      if (exponent + exponent_offset > traits::exponent_max) {
+        if (negative_exponent)
+          return Number(is_negative ? -0.0f : 0.0f);
+        else
+          return Number(is_negative ? -traits::inf() : traits::inf());
+      }
+      s++;
+    }
+    if (negative_exponent)
+      exponent = -exponent;
+  }
+  exponent += exponent_offset;
+
+  // we should be at the end of the string, otherwise it's an error
+  if (*s != '\0')
+    return Number();
+
+#if ARDUINOJSON_USE_DOUBLE
+  bool isDouble = exponent < -FloatTraits<float>::exponent_max ||
+                  exponent > FloatTraits<float>::exponent_max ||
+                  mantissa > FloatTraits<float>::mantissa_max;
+  if (isDouble) {
+    auto final_result = make_float(double(mantissa), exponent);
+    return Number(is_negative ? -final_result : final_result);
+  } else
+#endif
+  {
+    auto final_result = make_float(float(mantissa), exponent);
+    return Number(is_negative ? -final_result : final_result);
+  }
+}
+
+template <typename T>
+inline T parseNumber(const char* s) {
+  return parseNumber(s).convertTo<T>();
+}
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Object/JsonObject.hpp b/lib/ArduinoJson/ArduinoJson/Object/JsonObject.hpp
new file mode 100644
index 0000000..f3ed357
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Object/JsonObject.hpp
@@ -0,0 +1,245 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Object/JsonObjectConst.hpp>
+#include <ArduinoJson/Object/MemberProxy.hpp>
+
+ARDUINOJSON_BEGIN_PUBLIC_NAMESPACE
+
+class JsonArray;
+
+// A reference to an object in a JsonDocument.
+// https://arduinojson.org/v7/api/jsonobject/
+class JsonObject : public detail::VariantOperators<JsonObject> {
+  friend class detail::VariantAttorney;
+
+ public:
+  using iterator = JsonObjectIterator;
+
+  // Creates an unbound reference.
+  JsonObject() : data_(0), resources_(0) {}
+
+  // INTERNAL USE ONLY
+  JsonObject(detail::ObjectData* data, detail::ResourceManager* resource)
+      : data_(data), resources_(resource) {}
+
+  operator JsonVariant() const {
+    void* data = data_;  // prevent warning cast-align
+    return JsonVariant(reinterpret_cast<detail::VariantData*>(data),
+                       resources_);
+  }
+
+  operator JsonObjectConst() const {
+    return JsonObjectConst(data_, resources_);
+  }
+
+  operator JsonVariantConst() const {
+    return JsonVariantConst(collectionToVariant(data_), resources_);
+  }
+
+  // Returns true if the reference is unbound.
+  // https://arduinojson.org/v7/api/jsonobject/isnull/
+  bool isNull() const {
+    return data_ == 0;
+  }
+
+  // Returns true if the reference is bound.
+  // https://arduinojson.org/v7/api/jsonobject/isnull/
+  operator bool() const {
+    return data_ != 0;
+  }
+
+  // Returns the depth (nesting level) of the object.
+  // https://arduinojson.org/v7/api/jsonobject/nesting/
+  size_t nesting() const {
+    return detail::VariantData::nesting(collectionToVariant(data_), resources_);
+  }
+
+  // Returns the number of members in the object.
+  // https://arduinojson.org/v7/api/jsonobject/size/
+  size_t size() const {
+    return data_ ? data_->size(resources_) : 0;
+  }
+
+  // Returns an iterator to the first key-value pair of the object.
+  // https://arduinojson.org/v7/api/jsonobject/begin/
+  iterator begin() const {
+    if (!data_)
+      return iterator();
+    return iterator(data_->createIterator(resources_), resources_);
+  }
+
+  // Returns an iterator following the last key-value pair of the object.
+  // https://arduinojson.org/v7/api/jsonobject/end/
+  iterator end() const {
+    return iterator();
+  }
+
+  // Removes all the members of the object.
+  // https://arduinojson.org/v7/api/jsonobject/clear/
+  void clear() const {
+    detail::ObjectData::clear(data_, resources_);
+  }
+
+  // Copies an object.
+  // https://arduinojson.org/v7/api/jsonobject/set/
+  bool set(JsonObjectConst src) {
+    if (!data_ || !src.data_)
+      return false;
+
+    clear();
+    for (auto kvp : src) {
+      if (!operator[](kvp.key()).set(kvp.value()))
+        return false;
+    }
+
+    return true;
+  }
+
+  // Gets or sets the member with specified key.
+  // https://arduinojson.org/v7/api/jsonobject/subscript/
+  template <typename TString,
+            detail::enable_if_t<detail::IsString<TString>::value, int> = 0>
+  detail::MemberProxy<JsonObject, detail::AdaptedString<TString>> operator[](
+      const TString& key) const {
+    return {*this, detail::adaptString(key)};
+  }
+
+  // Gets or sets the member with specified key.
+  // https://arduinojson.org/v7/api/jsonobject/subscript/
+  template <typename TChar,
+            detail::enable_if_t<detail::IsString<TChar*>::value &&
+                                    !detail::is_const<TChar>::value,
+                                int> = 0>
+  detail::MemberProxy<JsonObject, detail::AdaptedString<TChar*>> operator[](
+      TChar* key) const {
+    return {*this, detail::adaptString(key)};
+  }
+
+  // Gets or sets the member with specified key.
+  // https://arduinojson.org/v7/api/jsonobject/subscript/
+  template <typename TVariant,
+            detail::enable_if_t<detail::IsVariant<TVariant>::value, int> = 0>
+  detail::MemberProxy<JsonObject, detail::AdaptedString<JsonString>> operator[](
+      const TVariant& key) const {
+    return {*this, detail::adaptString(key.template as<JsonString>())};
+  }
+
+  // Removes the member at the specified iterator.
+  // https://arduinojson.org/v7/api/jsonobject/remove/
+  FORCE_INLINE void remove(iterator it) const {
+    detail::ObjectData::remove(data_, it.iterator_, resources_);
+  }
+
+  // Removes the member with the specified key.
+  // https://arduinojson.org/v7/api/jsonobject/remove/
+  template <typename TString,
+            detail::enable_if_t<detail::IsString<TString>::value, int> = 0>
+  void remove(const TString& key) const {
+    detail::ObjectData::removeMember(data_, detail::adaptString(key),
+                                     resources_);
+  }
+
+  // Removes the member with the specified key.
+  // https://arduinojson.org/v7/api/jsonobject/remove/
+  template <typename TVariant,
+            detail::enable_if_t<detail::IsVariant<TVariant>::value, int> = 0>
+  void remove(const TVariant& key) const {
+    if (key.template is<const char*>())
+      remove(key.template as<const char*>());
+  }
+
+  // Removes the member with the specified key.
+  // https://arduinojson.org/v7/api/jsonobject/remove/
+  template <typename TChar>
+  FORCE_INLINE void remove(TChar* key) const {
+    detail::ObjectData::removeMember(data_, detail::adaptString(key),
+                                     resources_);
+  }
+
+  // DEPRECATED: use obj[key].is<T>() instead
+  // https://arduinojson.org/v7/api/jsonobject/containskey/
+  template <typename TString,
+            detail::enable_if_t<detail::IsString<TString>::value, int> = 0>
+  ARDUINOJSON_DEPRECATED("use obj[key].is<T>() instead")
+  bool containsKey(const TString& key) const {
+    return detail::ObjectData::getMember(data_, detail::adaptString(key),
+                                         resources_) != 0;
+  }
+
+  // DEPRECATED: use obj["key"].is<T>() instead
+  // https://arduinojson.org/v7/api/jsonobject/containskey/
+  template <typename TChar,
+            detail::enable_if_t<detail::IsString<TChar*>::value &&
+                                    !detail::is_const<TChar>::value,
+                                int> = 0>
+  ARDUINOJSON_DEPRECATED("use obj[\"key\"].is<T>() instead")
+  bool containsKey(TChar* key) const {
+    return detail::ObjectData::getMember(data_, detail::adaptString(key),
+                                         resources_) != 0;
+  }
+
+  // DEPRECATED: use obj[key].is<T>() instead
+  // https://arduinojson.org/v7/api/jsonobject/containskey/
+  template <typename TVariant,
+            detail::enable_if_t<detail::IsVariant<TVariant>::value, int> = 0>
+  ARDUINOJSON_DEPRECATED("use obj[key].is<T>() instead")
+  bool containsKey(const TVariant& key) const {
+    return containsKey(key.template as<const char*>());
+  }
+
+  // DEPRECATED: use obj[key].to<JsonArray>() instead
+  template <typename TChar>
+  ARDUINOJSON_DEPRECATED("use obj[key].to<JsonArray>() instead")
+  JsonArray createNestedArray(TChar* key) const {
+    return operator[](key).template to<JsonArray>();
+  }
+
+  // DEPRECATED: use obj[key].to<JsonArray>() instead
+  template <typename TString>
+  ARDUINOJSON_DEPRECATED("use obj[key].to<JsonArray>() instead")
+  JsonArray createNestedArray(const TString& key) const {
+    return operator[](key).template to<JsonArray>();
+  }
+
+  // DEPRECATED: use obj[key].to<JsonObject>() instead
+  template <typename TChar>
+  ARDUINOJSON_DEPRECATED("use obj[key].to<JsonObject>() instead")
+  JsonObject createNestedObject(TChar* key) {
+    return operator[](key).template to<JsonObject>();
+  }
+
+  // DEPRECATED: use obj[key].to<JsonObject>() instead
+  template <typename TString>
+  ARDUINOJSON_DEPRECATED("use obj[key].to<JsonObject>() instead")
+  JsonObject createNestedObject(const TString& key) {
+    return operator[](key).template to<JsonObject>();
+  }
+
+  // DEPRECATED: always returns zero
+  ARDUINOJSON_DEPRECATED("always returns zero")
+  size_t memoryUsage() const {
+    return 0;
+  }
+
+ private:
+  detail::ResourceManager* getResourceManager() const {
+    return resources_;
+  }
+
+  detail::VariantData* getData() const {
+    return detail::collectionToVariant(data_);
+  }
+
+  detail::VariantData* getOrCreateData() const {
+    return detail::collectionToVariant(data_);
+  }
+
+  detail::ObjectData* data_;
+  detail::ResourceManager* resources_;
+};
+
+ARDUINOJSON_END_PUBLIC_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Object/JsonObjectConst.hpp b/lib/ArduinoJson/ArduinoJson/Object/JsonObjectConst.hpp
new file mode 100644
index 0000000..ca3062b
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Object/JsonObjectConst.hpp
@@ -0,0 +1,166 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Object/JsonObjectIterator.hpp>
+#include <ArduinoJson/Variant/VariantOperators.hpp>
+
+ARDUINOJSON_BEGIN_PUBLIC_NAMESPACE
+
+// A read-only reference to an object in a JsonDocument.
+// https://arduinojson.org/v7/api/jsonobjectconst/
+class JsonObjectConst : public detail::VariantOperators<JsonObjectConst> {
+  friend class JsonObject;
+  friend class detail::VariantAttorney;
+
+ public:
+  using iterator = JsonObjectConstIterator;
+
+  // Creates an unbound reference.
+  JsonObjectConst() : data_(0), resources_(0) {}
+
+  // INTERNAL USE ONLY
+  JsonObjectConst(const detail::ObjectData* data,
+                  const detail::ResourceManager* resources)
+      : data_(data), resources_(resources) {}
+
+  operator JsonVariantConst() const {
+    return JsonVariantConst(getData(), resources_);
+  }
+
+  // Returns true if the reference is unbound.
+  // https://arduinojson.org/v7/api/jsonobjectconst/isnull/
+  bool isNull() const {
+    return data_ == 0;
+  }
+
+  // Returns true if the reference is bound.
+  // https://arduinojson.org/v7/api/jsonobjectconst/isnull/
+  operator bool() const {
+    return data_ != 0;
+  }
+
+  // Returns the depth (nesting level) of the object.
+  // https://arduinojson.org/v7/api/jsonobjectconst/nesting/
+  size_t nesting() const {
+    return detail::VariantData::nesting(getData(), resources_);
+  }
+
+  // Returns the number of members in the object.
+  // https://arduinojson.org/v7/api/jsonobjectconst/size/
+  size_t size() const {
+    return data_ ? data_->size(resources_) : 0;
+  }
+
+  // Returns an iterator to the first key-value pair of the object.
+  // https://arduinojson.org/v7/api/jsonobjectconst/begin/
+  iterator begin() const {
+    if (!data_)
+      return iterator();
+    return iterator(data_->createIterator(resources_), resources_);
+  }
+
+  // Returns an iterator following the last key-value pair of the object.
+  // https://arduinojson.org/v7/api/jsonobjectconst/end/
+  iterator end() const {
+    return iterator();
+  }
+
+  // DEPRECATED: use obj[key].is<T>() instead
+  // https://arduinojson.org/v7/api/jsonobjectconst/containskey/
+  template <typename TString,
+            detail::enable_if_t<detail::IsString<TString>::value, int> = 0>
+  ARDUINOJSON_DEPRECATED("use obj[key].is<T>() instead")
+  bool containsKey(const TString& key) const {
+    return detail::ObjectData::getMember(data_, detail::adaptString(key),
+                                         resources_) != 0;
+  }
+
+  // DEPRECATED: use obj["key"].is<T>() instead
+  // https://arduinojson.org/v7/api/jsonobjectconst/containskey/
+  template <typename TChar>
+  ARDUINOJSON_DEPRECATED("use obj[\"key\"].is<T>() instead")
+  bool containsKey(TChar* key) const {
+    return detail::ObjectData::getMember(data_, detail::adaptString(key),
+                                         resources_) != 0;
+  }
+
+  // DEPRECATED: use obj[key].is<T>() instead
+  // https://arduinojson.org/v7/api/jsonobjectconst/containskey/
+  template <typename TVariant,
+            detail::enable_if_t<detail::IsVariant<TVariant>::value, int> = 0>
+  ARDUINOJSON_DEPRECATED("use obj[key].is<T>() instead")
+  bool containsKey(const TVariant& key) const {
+    return containsKey(key.template as<const char*>());
+  }
+
+  // Gets the member with specified key.
+  // https://arduinojson.org/v7/api/jsonobjectconst/subscript/
+  template <typename TString,
+            detail::enable_if_t<detail::IsString<TString>::value, int> = 0>
+  JsonVariantConst operator[](const TString& key) const {
+    return JsonVariantConst(detail::ObjectData::getMember(
+                                data_, detail::adaptString(key), resources_),
+                            resources_);
+  }
+
+  // Gets the member with specified key.
+  // https://arduinojson.org/v7/api/jsonobjectconst/subscript/
+  template <typename TChar,
+            detail::enable_if_t<detail::IsString<TChar*>::value &&
+                                    !detail::is_const<TChar>::value,
+                                int> = 0>
+  JsonVariantConst operator[](TChar* key) const {
+    return JsonVariantConst(detail::ObjectData::getMember(
+                                data_, detail::adaptString(key), resources_),
+                            resources_);
+  }
+
+  // Gets the member with specified key.
+  // https://arduinojson.org/v7/api/jsonobjectconst/subscript/
+  template <typename TVariant,
+            detail::enable_if_t<detail::IsVariant<TVariant>::value, int> = 0>
+  JsonVariantConst operator[](const TVariant& key) const {
+    if (key.template is<JsonString>())
+      return operator[](key.template as<JsonString>());
+    else
+      return JsonVariantConst();
+  }
+
+  // DEPRECATED: always returns zero
+  ARDUINOJSON_DEPRECATED("always returns zero")
+  size_t memoryUsage() const {
+    return 0;
+  }
+
+ private:
+  const detail::VariantData* getData() const {
+    return collectionToVariant(data_);
+  }
+
+  const detail::ObjectData* data_;
+  const detail::ResourceManager* resources_;
+};
+
+inline bool operator==(JsonObjectConst lhs, JsonObjectConst rhs) {
+  if (!lhs && !rhs)  // both are null
+    return true;
+
+  if (!lhs || !rhs)  // only one is null
+    return false;
+
+  size_t count = 0;
+  for (auto kvp : lhs) {
+    auto rhsValue = rhs[kvp.key()];
+    if (rhsValue.isUnbound())
+      return false;
+    if (kvp.value() != rhsValue)
+      return false;
+    count++;
+  }
+  return count == rhs.size();
+}
+
+ARDUINOJSON_END_PUBLIC_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Object/JsonObjectIterator.hpp b/lib/ArduinoJson/ArduinoJson/Object/JsonObjectIterator.hpp
new file mode 100644
index 0000000..c3c43e7
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Object/JsonObjectIterator.hpp
@@ -0,0 +1,83 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Object/JsonPair.hpp>
+
+ARDUINOJSON_BEGIN_PUBLIC_NAMESPACE
+
+class JsonObjectIterator {
+  friend class JsonObject;
+
+ public:
+  JsonObjectIterator() {}
+
+  explicit JsonObjectIterator(detail::ObjectData::iterator iterator,
+                              detail::ResourceManager* resources)
+      : iterator_(iterator), resources_(resources) {}
+
+  JsonPair operator*() const {
+    return JsonPair(iterator_, resources_);
+  }
+  Ptr<JsonPair> operator->() {
+    return operator*();
+  }
+
+  bool operator==(const JsonObjectIterator& other) const {
+    return iterator_ == other.iterator_;
+  }
+
+  bool operator!=(const JsonObjectIterator& other) const {
+    return iterator_ != other.iterator_;
+  }
+
+  JsonObjectIterator& operator++() {
+    iterator_.next(resources_);  // key
+    iterator_.next(resources_);  // value
+    return *this;
+  }
+
+ private:
+  detail::ObjectData::iterator iterator_;
+  detail::ResourceManager* resources_;
+};
+
+class JsonObjectConstIterator {
+  friend class JsonObject;
+
+ public:
+  JsonObjectConstIterator() {}
+
+  explicit JsonObjectConstIterator(detail::ObjectData::iterator iterator,
+                                   const detail::ResourceManager* resources)
+      : iterator_(iterator), resources_(resources) {}
+
+  JsonPairConst operator*() const {
+    return JsonPairConst(iterator_, resources_);
+  }
+  Ptr<JsonPairConst> operator->() {
+    return operator*();
+  }
+
+  bool operator==(const JsonObjectConstIterator& other) const {
+    return iterator_ == other.iterator_;
+  }
+
+  bool operator!=(const JsonObjectConstIterator& other) const {
+    return iterator_ != other.iterator_;
+  }
+
+  JsonObjectConstIterator& operator++() {
+    iterator_.next(resources_);  // key
+    iterator_.next(resources_);  // value
+    return *this;
+  }
+
+ private:
+  detail::ObjectData::iterator iterator_;
+  const detail::ResourceManager* resources_;
+};
+
+ARDUINOJSON_END_PUBLIC_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Object/JsonPair.hpp b/lib/ArduinoJson/ArduinoJson/Object/JsonPair.hpp
new file mode 100644
index 0000000..67b185f
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Object/JsonPair.hpp
@@ -0,0 +1,70 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Strings/JsonString.hpp>
+#include <ArduinoJson/Variant/JsonVariant.hpp>
+#include <ArduinoJson/Variant/JsonVariantConst.hpp>
+
+ARDUINOJSON_BEGIN_PUBLIC_NAMESPACE
+
+// A key-value pair.
+// https://arduinojson.org/v7/api/jsonobject/begin_end/
+class JsonPair {
+ public:
+  // INTERNAL USE ONLY
+  JsonPair(detail::ObjectData::iterator iterator,
+           detail::ResourceManager* resources) {
+    if (!iterator.done()) {
+      key_ = iterator->asString();
+      iterator.next(resources);
+      value_ = JsonVariant(iterator.data(), resources);
+    }
+  }
+
+  // Returns the key.
+  JsonString key() const {
+    return key_;
+  }
+
+  // Returns the value.
+  JsonVariant value() {
+    return value_;
+  }
+
+ private:
+  JsonString key_;
+  JsonVariant value_;
+};
+
+// A read-only key-value pair.
+// https://arduinojson.org/v7/api/jsonobjectconst/begin_end/
+class JsonPairConst {
+ public:
+  JsonPairConst(detail::ObjectData::iterator iterator,
+                const detail::ResourceManager* resources) {
+    if (!iterator.done()) {
+      key_ = iterator->asString();
+      iterator.next(resources);
+      value_ = JsonVariantConst(iterator.data(), resources);
+    }
+  }
+
+  // Returns the key.
+  JsonString key() const {
+    return key_;
+  }
+
+  // Returns the value.
+  JsonVariantConst value() const {
+    return value_;
+  }
+
+ private:
+  JsonString key_;
+  JsonVariantConst value_;
+};
+
+ARDUINOJSON_END_PUBLIC_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Object/MemberProxy.hpp b/lib/ArduinoJson/ArduinoJson/Object/MemberProxy.hpp
new file mode 100644
index 0000000..6c11af4
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Object/MemberProxy.hpp
@@ -0,0 +1,77 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Variant/VariantRefBase.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+// A proxy class to get or set a member of an object.
+// https://arduinojson.org/v7/api/jsonobject/subscript/
+template <typename TUpstream, typename AdaptedString>
+class MemberProxy
+    : public VariantRefBase<MemberProxy<TUpstream, AdaptedString>>,
+      public VariantOperators<MemberProxy<TUpstream, AdaptedString>> {
+  friend class VariantAttorney;
+
+  friend class VariantRefBase<MemberProxy<TUpstream, AdaptedString>>;
+
+  template <typename, typename>
+  friend class MemberProxy;
+
+  template <typename>
+  friend class ElementProxy;
+
+ public:
+  MemberProxy(TUpstream upstream, AdaptedString key)
+      : upstream_(upstream), key_(key) {}
+
+  MemberProxy& operator=(const MemberProxy& src) {
+    this->set(src);
+    return *this;
+  }
+
+  template <typename T>
+  MemberProxy& operator=(const T& src) {
+    this->set(src);
+    return *this;
+  }
+
+  template <typename T, enable_if_t<!is_const<T>::value, int> = 0>
+  MemberProxy& operator=(T* src) {
+    this->set(src);
+    return *this;
+  }
+
+ private:
+  // clang-format off
+  MemberProxy(const MemberProxy& src) // Error here? See https://arduinojson.org/v7/proxy-non-copyable/
+      : upstream_(src.upstream_), key_(src.key_) {}
+  // clang-format on
+
+  ResourceManager* getResourceManager() const {
+    return VariantAttorney::getResourceManager(upstream_);
+  }
+
+  VariantData* getData() const {
+    return VariantData::getMember(
+        VariantAttorney::getData(upstream_), key_,
+        VariantAttorney::getResourceManager(upstream_));
+  }
+
+  VariantData* getOrCreateData() const {
+    auto data = VariantAttorney::getOrCreateData(upstream_);
+    if (!data)
+      return nullptr;
+    return data->getOrAddMember(key_,
+                                VariantAttorney::getResourceManager(upstream_));
+  }
+
+ private:
+  TUpstream upstream_;
+  AdaptedString key_;
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Object/ObjectData.hpp b/lib/ArduinoJson/ArduinoJson/Object/ObjectData.hpp
new file mode 100644
index 0000000..9344f59
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Object/ObjectData.hpp
@@ -0,0 +1,70 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Collection/CollectionData.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+class ObjectData : public CollectionData {
+ public:
+  template <typename TAdaptedString>
+  VariantData* addMember(TAdaptedString key, ResourceManager* resources);
+
+  VariantData* addPair(VariantData** value, ResourceManager* resources);
+
+  template <typename TAdaptedString>
+  VariantData* getOrAddMember(TAdaptedString key, ResourceManager* resources);
+
+  template <typename TAdaptedString>
+  VariantData* getMember(TAdaptedString key,
+                         const ResourceManager* resources) const;
+
+  template <typename TAdaptedString>
+  static VariantData* getMember(const ObjectData* object, TAdaptedString key,
+                                const ResourceManager* resources) {
+    if (!object)
+      return nullptr;
+    return object->getMember(key, resources);
+  }
+
+  template <typename TAdaptedString>
+  void removeMember(TAdaptedString key, ResourceManager* resources);
+
+  template <typename TAdaptedString>
+  static void removeMember(ObjectData* obj, TAdaptedString key,
+                           ResourceManager* resources) {
+    if (!obj)
+      return;
+    obj->removeMember(key, resources);
+  }
+
+  void remove(iterator it, ResourceManager* resources) {
+    CollectionData::removePair(it, resources);
+  }
+
+  static void remove(ObjectData* obj, ObjectData::iterator it,
+                     ResourceManager* resources) {
+    if (!obj)
+      return;
+    obj->remove(it, resources);
+  }
+
+  size_t size(const ResourceManager* resources) const {
+    return CollectionData::size(resources) / 2;
+  }
+
+  static size_t size(const ObjectData* obj, const ResourceManager* resources) {
+    if (!obj)
+      return 0;
+    return obj->size(resources);
+  }
+
+ private:
+  template <typename TAdaptedString>
+  iterator findKey(TAdaptedString key, const ResourceManager* resources) const;
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Object/ObjectImpl.hpp b/lib/ArduinoJson/ArduinoJson/Object/ObjectImpl.hpp
new file mode 100644
index 0000000..d36a2e0
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Object/ObjectImpl.hpp
@@ -0,0 +1,92 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Object/ObjectData.hpp>
+#include <ArduinoJson/Variant/VariantCompare.hpp>
+#include <ArduinoJson/Variant/VariantData.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <typename TAdaptedString>
+inline VariantData* ObjectData::getMember(
+    TAdaptedString key, const ResourceManager* resources) const {
+  auto it = findKey(key, resources);
+  if (it.done())
+    return nullptr;
+  it.next(resources);
+  return it.data();
+}
+
+template <typename TAdaptedString>
+VariantData* ObjectData::getOrAddMember(TAdaptedString key,
+                                        ResourceManager* resources) {
+  auto data = getMember(key, resources);
+  if (data)
+    return data;
+  return addMember(key, resources);
+}
+
+template <typename TAdaptedString>
+inline ObjectData::iterator ObjectData::findKey(
+    TAdaptedString key, const ResourceManager* resources) const {
+  if (key.isNull())
+    return iterator();
+  bool isKey = true;
+  for (auto it = createIterator(resources); !it.done(); it.next(resources)) {
+    if (isKey && stringEquals(key, adaptString(it->asString())))
+      return it;
+    isKey = !isKey;
+  }
+  return iterator();
+}
+
+template <typename TAdaptedString>
+inline void ObjectData::removeMember(TAdaptedString key,
+                                     ResourceManager* resources) {
+  remove(findKey(key, resources), resources);
+}
+
+template <typename TAdaptedString>
+inline VariantData* ObjectData::addMember(TAdaptedString key,
+                                          ResourceManager* resources) {
+  auto keySlot = resources->allocVariant();
+  if (!keySlot)
+    return nullptr;
+
+  auto valueSlot = resources->allocVariant();
+  if (!valueSlot)
+    return nullptr;
+
+  if (!keySlot->setString(key, resources))
+    return nullptr;
+
+  CollectionData::appendPair(keySlot, valueSlot, resources);
+
+  return valueSlot.ptr();
+}
+
+inline VariantData* ObjectData::addPair(VariantData** value,
+                                        ResourceManager* resources) {
+  auto keySlot = resources->allocVariant();
+  if (!keySlot)
+    return nullptr;
+
+  auto valueSlot = resources->allocVariant();
+  if (!valueSlot)
+    return nullptr;
+  *value = valueSlot.ptr();
+
+  CollectionData::appendPair(keySlot, valueSlot, resources);
+
+  return keySlot.ptr();
+}
+
+// Returns the size (in bytes) of an object with n members.
+constexpr size_t sizeofObject(size_t n) {
+  return 2 * n * ResourceManager::slotSize;
+}
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Polyfills/alias_cast.hpp b/lib/ArduinoJson/ArduinoJson/Polyfills/alias_cast.hpp
new file mode 100644
index 0000000..c00a8ae
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Polyfills/alias_cast.hpp
@@ -0,0 +1,30 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <stdint.h>
+#include <stdlib.h>  // for size_t
+
+#include <ArduinoJson/Configuration.hpp>
+#include "math.hpp"
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <typename T, typename F>
+struct alias_cast_t {
+  union {
+    F raw;
+    T data;
+  };
+};
+
+template <typename T, typename F>
+T alias_cast(F raw_data) {
+  alias_cast_t<T, F> ac;
+  ac.raw = raw_data;
+  return ac.data;
+}
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Polyfills/assert.hpp b/lib/ArduinoJson/ArduinoJson/Polyfills/assert.hpp
new file mode 100644
index 0000000..9479818
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Polyfills/assert.hpp
@@ -0,0 +1,14 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Configuration.hpp>
+
+#if ARDUINOJSON_DEBUG
+#  include <assert.h>
+#  define ARDUINOJSON_ASSERT(X) assert(X)
+#else
+#  define ARDUINOJSON_ASSERT(X) ((void)0)
+#endif
diff --git a/lib/ArduinoJson/ArduinoJson/Polyfills/attributes.hpp b/lib/ArduinoJson/ArduinoJson/Polyfills/attributes.hpp
new file mode 100644
index 0000000..d2aa76e
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Polyfills/attributes.hpp
@@ -0,0 +1,45 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#ifdef _MSC_VER  // Visual Studio
+
+#  define FORCE_INLINE  // __forceinline causes C4714 when returning std::string
+
+#  ifndef ARDUINOJSON_DEPRECATED
+#    define ARDUINOJSON_DEPRECATED(msg) __declspec(deprecated(msg))
+#  endif
+
+#elif defined(__GNUC__)  // GCC or Clang
+
+#  define FORCE_INLINE __attribute__((always_inline))
+
+#  ifndef ARDUINOJSON_DEPRECATED
+#    if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5)
+#      define ARDUINOJSON_DEPRECATED(msg) __attribute__((deprecated(msg)))
+#    else
+#      define ARDUINOJSON_DEPRECATED(msg) __attribute__((deprecated))
+#    endif
+#  endif
+
+#else  // Other compilers
+
+#  define FORCE_INLINE
+
+#  ifndef ARDUINOJSON_DEPRECATED
+#    define ARDUINOJSON_DEPRECATED(msg)
+#  endif
+
+#endif
+
+#if defined(__has_attribute)
+#  if __has_attribute(no_sanitize)
+#    define ARDUINOJSON_NO_SANITIZE(check) __attribute__((no_sanitize(check)))
+#  else
+#    define ARDUINOJSON_NO_SANITIZE(check)
+#  endif
+#else
+#  define ARDUINOJSON_NO_SANITIZE(check)
+#endif
diff --git a/lib/ArduinoJson/ArduinoJson/Polyfills/ctype.hpp b/lib/ArduinoJson/ArduinoJson/Polyfills/ctype.hpp
new file mode 100644
index 0000000..f0491a0
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Polyfills/ctype.hpp
@@ -0,0 +1,21 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+#ifndef isdigit
+inline bool isdigit(char c) {
+  return '0' <= c && c <= '9';
+}
+#endif
+
+inline bool issign(char c) {
+  return '-' == c || c == '+';
+}
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Polyfills/integer.hpp b/lib/ArduinoJson/ArduinoJson/Polyfills/integer.hpp
new file mode 100644
index 0000000..7f5846f
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Polyfills/integer.hpp
@@ -0,0 +1,34 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <stdint.h>  // int8_t, int16_t
+
+#include <ArduinoJson/Namespace.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <int Bits>
+struct uint_;
+
+template <>
+struct uint_<8> {
+  using type = uint8_t;
+};
+
+template <>
+struct uint_<16> {
+  using type = uint16_t;
+};
+
+template <>
+struct uint_<32> {
+  using type = uint32_t;
+};
+
+template <int Bits>
+using uint_t = typename uint_<Bits>::type;
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Polyfills/limits.hpp b/lib/ArduinoJson/ArduinoJson/Polyfills/limits.hpp
new file mode 100644
index 0000000..619ca20
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Polyfills/limits.hpp
@@ -0,0 +1,45 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include "type_traits.hpp"
+
+#ifdef _MSC_VER
+#  pragma warning(push)
+#  pragma warning(disable : 4310)
+#endif
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+// Differs from standard because we can't use the symbols "min" and "max"
+template <typename T, typename Enable = void>
+struct numeric_limits;
+
+template <typename T>
+struct numeric_limits<T, enable_if_t<is_unsigned<T>::value>> {
+  static constexpr T lowest() {
+    return 0;
+  }
+  static constexpr T highest() {
+    return T(-1);
+  }
+};
+
+template <typename T>
+struct numeric_limits<
+    T, enable_if_t<is_integral<T>::value && is_signed<T>::value>> {
+  static constexpr T lowest() {
+    return T(T(1) << (sizeof(T) * 8 - 1));
+  }
+  static constexpr T highest() {
+    return T(~lowest());
+  }
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
+
+#ifdef _MSC_VER
+#  pragma warning(pop)
+#endif
diff --git a/lib/ArduinoJson/ArduinoJson/Polyfills/math.hpp b/lib/ArduinoJson/ArduinoJson/Polyfills/math.hpp
new file mode 100644
index 0000000..4278f33
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Polyfills/math.hpp
@@ -0,0 +1,27 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+// Some libraries #define isnan() and isinf() so we need to check before
+// using this name
+
+#ifndef isnan
+template <typename T>
+bool isnan(T x) {
+  return x != x;
+}
+#endif
+
+#ifndef isinf
+template <typename T>
+bool isinf(T x) {
+  return x != 0.0 && x * 2 == x;
+}
+#endif
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Polyfills/mpl/max.hpp b/lib/ArduinoJson/ArduinoJson/Polyfills/mpl/max.hpp
new file mode 100644
index 0000000..a74ad89
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Polyfills/mpl/max.hpp
@@ -0,0 +1,27 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+
+#include <stddef.h>  // for size_t
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+// A meta-function that returns the highest value
+template <size_t X, size_t Y, bool MaxIsX = (X > Y)>
+struct Max {};
+
+template <size_t X, size_t Y>
+struct Max<X, Y, true> {
+  static const size_t value = X;
+};
+
+template <size_t X, size_t Y>
+struct Max<X, Y, false> {
+  static const size_t value = Y;
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Polyfills/pgmspace.hpp b/lib/ArduinoJson/ArduinoJson/Polyfills/pgmspace.hpp
new file mode 100644
index 0000000..4af6a7a
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Polyfills/pgmspace.hpp
@@ -0,0 +1,144 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#ifdef ARDUINO
+#  include <Arduino.h>
+#else
+// Allow using PROGMEM outside of Arduino (issue #1903)
+class __FlashStringHelper;
+#  include <avr/pgmspace.h>
+#endif
+
+#include <ArduinoJson/Configuration.hpp>
+#include <ArduinoJson/Namespace.hpp>
+#include <ArduinoJson/Polyfills/assert.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+// Wraps a const char* so that the our functions are picked only if the
+// originals are missing
+struct pgm_p {
+  pgm_p(const void* p) : address(reinterpret_cast<const char*>(p)) {}
+  const char* address;
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
+
+#ifndef strlen_P
+inline size_t strlen_P(ArduinoJson::detail::pgm_p s) {
+  const char* p = s.address;
+  ARDUINOJSON_ASSERT(p != NULL);
+  while (pgm_read_byte(p))
+    p++;
+  return size_t(p - s.address);
+}
+#endif
+
+#ifndef strncmp_P
+inline int strncmp_P(const char* a, ArduinoJson::detail::pgm_p b, size_t n) {
+  const char* s1 = a;
+  const char* s2 = b.address;
+  ARDUINOJSON_ASSERT(s1 != NULL);
+  ARDUINOJSON_ASSERT(s2 != NULL);
+  while (n-- > 0) {
+    char c1 = *s1++;
+    char c2 = static_cast<char>(pgm_read_byte(s2++));
+    if (c1 < c2)
+      return -1;
+    if (c1 > c2)
+      return 1;
+    if (c1 == 0 /* and c2 as well */)
+      return 0;
+  }
+  return 0;
+}
+#endif
+
+#ifndef strcmp_P
+inline int strcmp_P(const char* a, ArduinoJson::detail::pgm_p b) {
+  const char* s1 = a;
+  const char* s2 = b.address;
+  ARDUINOJSON_ASSERT(s1 != NULL);
+  ARDUINOJSON_ASSERT(s2 != NULL);
+  for (;;) {
+    char c1 = *s1++;
+    char c2 = static_cast<char>(pgm_read_byte(s2++));
+    if (c1 < c2)
+      return -1;
+    if (c1 > c2)
+      return 1;
+    if (c1 == 0 /* and c2 as well */)
+      return 0;
+  }
+}
+#endif
+
+#ifndef memcmp_P
+inline int memcmp_P(const void* a, ArduinoJson::detail::pgm_p b, size_t n) {
+  const uint8_t* p1 = reinterpret_cast<const uint8_t*>(a);
+  const char* p2 = b.address;
+  ARDUINOJSON_ASSERT(p1 != NULL);
+  ARDUINOJSON_ASSERT(p2 != NULL);
+  while (n-- > 0) {
+    uint8_t v1 = *p1++;
+    uint8_t v2 = pgm_read_byte(p2++);
+    if (v1 != v2)
+      return v1 - v2;
+  }
+  return 0;
+}
+#endif
+
+#ifndef memcpy_P
+inline void* memcpy_P(void* dst, ArduinoJson::detail::pgm_p src, size_t n) {
+  uint8_t* d = reinterpret_cast<uint8_t*>(dst);
+  const char* s = src.address;
+  ARDUINOJSON_ASSERT(d != NULL);
+  ARDUINOJSON_ASSERT(s != NULL);
+  while (n-- > 0) {
+    *d++ = pgm_read_byte(s++);
+  }
+  return dst;
+}
+#endif
+
+#ifndef pgm_read_dword
+inline uint32_t pgm_read_dword(ArduinoJson::detail::pgm_p p) {
+  uint32_t result;
+  memcpy_P(&result, p.address, 4);
+  return result;
+}
+#endif
+
+#ifndef pgm_read_float
+inline float pgm_read_float(ArduinoJson::detail::pgm_p p) {
+  float result;
+  memcpy_P(&result, p.address, sizeof(float));
+  return result;
+}
+#endif
+
+#ifndef pgm_read_double
+#  if defined(__SIZEOF_DOUBLE__) && defined(__SIZEOF_FLOAT__) && \
+      __SIZEOF_DOUBLE__ == __SIZEOF_FLOAT__
+inline double pgm_read_double(ArduinoJson::detail::pgm_p p) {
+  return pgm_read_float(p.address);
+}
+#  else
+inline double pgm_read_double(ArduinoJson::detail::pgm_p p) {
+  double result;
+  memcpy_P(&result, p.address, sizeof(double));
+  return result;
+}
+#  endif
+#endif
+
+#ifndef pgm_read_ptr
+inline void* pgm_read_ptr(ArduinoJson::detail::pgm_p p) {
+  void* result;
+  memcpy_P(&result, p.address, sizeof(result));
+  return result;
+}
+#endif
diff --git a/lib/ArduinoJson/ArduinoJson/Polyfills/pgmspace_generic.hpp b/lib/ArduinoJson/ArduinoJson/Polyfills/pgmspace_generic.hpp
new file mode 100644
index 0000000..3769368
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Polyfills/pgmspace_generic.hpp
@@ -0,0 +1,67 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+
+#if ARDUINOJSON_ENABLE_PROGMEM
+#  include <ArduinoJson/Polyfills/pgmspace.hpp>
+#  include <ArduinoJson/Polyfills/type_traits.hpp>
+#endif
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+#if ARDUINOJSON_ENABLE_PROGMEM
+
+#  ifndef ARDUINOJSON_DEFINE_PROGMEM_ARRAY
+#    define ARDUINOJSON_DEFINE_PROGMEM_ARRAY(type, name, ...) \
+      static type const name[] PROGMEM = __VA_ARGS__;
+#  endif
+
+template <typename T>
+inline const T* pgm_read(const T* const* p) {
+  return reinterpret_cast<const T*>(pgm_read_ptr(p));
+}
+
+inline uint32_t pgm_read(const uint32_t* p) {
+  return pgm_read_dword(p);
+}
+
+inline double pgm_read(const double* p) {
+  return pgm_read_double(p);
+}
+
+inline float pgm_read(const float* p) {
+  return pgm_read_float(p);
+}
+
+#else
+
+#  ifndef ARDUINOJSON_DEFINE_PROGMEM_ARRAY
+#    define ARDUINOJSON_DEFINE_PROGMEM_ARRAY(type, name, ...) \
+      static type const name[] = __VA_ARGS__;
+#  endif
+
+template <typename T>
+inline T pgm_read(const T* p) {
+  return *p;
+}
+
+#endif
+
+template <typename T>
+class pgm_ptr {
+ public:
+  explicit pgm_ptr(const T* ptr) : ptr_(ptr) {}
+
+  T operator[](intptr_t index) const {
+    return pgm_read(ptr_ + index);
+  }
+
+ private:
+  const T* ptr_;
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Polyfills/preprocessor.hpp b/lib/ArduinoJson/ArduinoJson/Polyfills/preprocessor.hpp
new file mode 100644
index 0000000..db64778
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Polyfills/preprocessor.hpp
@@ -0,0 +1,33 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#define ARDUINOJSON_CONCAT_(A, B) A##B
+#define ARDUINOJSON_CONCAT2(A, B) ARDUINOJSON_CONCAT_(A, B)
+#define ARDUINOJSON_CONCAT3(A, B, C) \
+  ARDUINOJSON_CONCAT2(ARDUINOJSON_CONCAT2(A, B), C)
+#define ARDUINOJSON_CONCAT4(A, B, C, D) \
+  ARDUINOJSON_CONCAT2(ARDUINOJSON_CONCAT3(A, B, C), D)
+#define ARDUINOJSON_CONCAT5(A, B, C, D, E) \
+  ARDUINOJSON_CONCAT2(ARDUINOJSON_CONCAT4(A, B, C, D), E)
+
+#define ARDUINOJSON_BIN2ALPHA_0000() A
+#define ARDUINOJSON_BIN2ALPHA_0001() B
+#define ARDUINOJSON_BIN2ALPHA_0010() C
+#define ARDUINOJSON_BIN2ALPHA_0011() D
+#define ARDUINOJSON_BIN2ALPHA_0100() E
+#define ARDUINOJSON_BIN2ALPHA_0101() F
+#define ARDUINOJSON_BIN2ALPHA_0110() G
+#define ARDUINOJSON_BIN2ALPHA_0111() H
+#define ARDUINOJSON_BIN2ALPHA_1000() I
+#define ARDUINOJSON_BIN2ALPHA_1001() J
+#define ARDUINOJSON_BIN2ALPHA_1010() K
+#define ARDUINOJSON_BIN2ALPHA_1011() L
+#define ARDUINOJSON_BIN2ALPHA_1100() M
+#define ARDUINOJSON_BIN2ALPHA_1101() N
+#define ARDUINOJSON_BIN2ALPHA_1110() O
+#define ARDUINOJSON_BIN2ALPHA_1111() P
+#define ARDUINOJSON_BIN2ALPHA_(A, B, C, D) ARDUINOJSON_BIN2ALPHA_##A##B##C##D()
+#define ARDUINOJSON_BIN2ALPHA(A, B, C, D) ARDUINOJSON_BIN2ALPHA_(A, B, C, D)
diff --git a/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits.hpp b/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits.hpp
new file mode 100644
index 0000000..7ed45bc
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits.hpp
@@ -0,0 +1,27 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include "type_traits/conditional.hpp"
+#include "type_traits/decay.hpp"
+#include "type_traits/enable_if.hpp"
+#include "type_traits/function_traits.hpp"
+#include "type_traits/integral_constant.hpp"
+#include "type_traits/is_array.hpp"
+#include "type_traits/is_base_of.hpp"
+#include "type_traits/is_class.hpp"
+#include "type_traits/is_const.hpp"
+#include "type_traits/is_convertible.hpp"
+#include "type_traits/is_enum.hpp"
+#include "type_traits/is_floating_point.hpp"
+#include "type_traits/is_integral.hpp"
+#include "type_traits/is_pointer.hpp"
+#include "type_traits/is_same.hpp"
+#include "type_traits/is_signed.hpp"
+#include "type_traits/is_unsigned.hpp"
+#include "type_traits/make_unsigned.hpp"
+#include "type_traits/remove_const.hpp"
+#include "type_traits/remove_reference.hpp"
+#include "type_traits/void_t.hpp"
diff --git a/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/conditional.hpp b/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/conditional.hpp
new file mode 100644
index 0000000..118e854
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/conditional.hpp
@@ -0,0 +1,25 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <bool Condition, class TrueType, class FalseType>
+struct conditional {
+  using type = TrueType;
+};
+
+template <class TrueType, class FalseType>
+struct conditional<false, TrueType, FalseType> {
+  using type = FalseType;
+};
+
+template <bool Condition, class TrueType, class FalseType>
+using conditional_t =
+    typename conditional<Condition, TrueType, FalseType>::type;
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/decay.hpp b/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/decay.hpp
new file mode 100644
index 0000000..558f827
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/decay.hpp
@@ -0,0 +1,33 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <stddef.h>  // size_t
+
+#include <ArduinoJson/Namespace.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <typename T>
+struct decay {
+  using type = T;
+};
+
+template <typename T>
+struct decay<T&> : decay<T> {};
+
+template <typename T>
+struct decay<T&&> : decay<T> {};
+
+template <typename T>
+struct decay<T[]> : decay<T*> {};
+
+template <typename T, size_t N>
+struct decay<T[N]> : decay<T*> {};
+
+template <typename T>
+using decay_t = typename decay<T>::type;
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/declval.hpp b/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/declval.hpp
new file mode 100644
index 0000000..2401d2c
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/declval.hpp
@@ -0,0 +1,14 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <typename T>
+T&& declval();
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/enable_if.hpp b/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/enable_if.hpp
new file mode 100644
index 0000000..4ffa38a
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/enable_if.hpp
@@ -0,0 +1,23 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+// A meta-function that return the type T if Condition is true.
+template <bool Condition, typename T = void>
+struct enable_if {};
+
+template <typename T>
+struct enable_if<true, T> {
+  using type = T;
+};
+
+template <bool Condition, typename T = void>
+using enable_if_t = typename enable_if<Condition, T>::type;
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/function_traits.hpp b/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/function_traits.hpp
new file mode 100644
index 0000000..1ea18f2
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/function_traits.hpp
@@ -0,0 +1,27 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <typename Sig>
+struct function_traits;
+
+template <typename ReturnType, typename Arg1>
+struct function_traits<ReturnType (*)(Arg1)> {
+  using return_type = ReturnType;
+  using arg1_type = Arg1;
+};
+
+template <typename ReturnType, typename Arg1, typename Arg2>
+struct function_traits<ReturnType (*)(Arg1, Arg2)> {
+  using return_type = ReturnType;
+  using arg1_type = Arg1;
+  using arg2_type = Arg2;
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/integral_constant.hpp b/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/integral_constant.hpp
new file mode 100644
index 0000000..4122257
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/integral_constant.hpp
@@ -0,0 +1,22 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <typename T, T v>
+struct integral_constant {
+  static const T value = v;
+};
+
+template <bool B>
+using bool_constant = integral_constant<bool, B>;
+
+using true_type = bool_constant<true>;
+using false_type = bool_constant<false>;
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/is_array.hpp b/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/is_array.hpp
new file mode 100644
index 0000000..520feb2
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/is_array.hpp
@@ -0,0 +1,22 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+
+#include <stddef.h>  // size_t
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <typename T>
+struct is_array : false_type {};
+
+template <typename T>
+struct is_array<T[]> : true_type {};
+
+template <typename T, size_t N>
+struct is_array<T[N]> : true_type {};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/is_base_of.hpp b/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/is_base_of.hpp
new file mode 100644
index 0000000..a68f0ae
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/is_base_of.hpp
@@ -0,0 +1,27 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+
+#include "remove_reference.hpp"
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+// A meta-function that returns true if Derived inherits from TBase is an
+// integral type.
+template <typename TBase, typename TDerived>
+class is_base_of {
+ protected:  // <- to avoid GCC's "all member functions in class are private"
+  static int probe(const TBase*);
+  static char probe(...);
+
+ public:
+  static const bool value =
+      sizeof(probe(reinterpret_cast<remove_reference_t<TDerived>*>(0))) ==
+      sizeof(int);
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/is_class.hpp b/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/is_class.hpp
new file mode 100644
index 0000000..0873f3c
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/is_class.hpp
@@ -0,0 +1,23 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include "declval.hpp"
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <typename T>
+struct is_class {
+ protected:  // <- to avoid GCC's "all member functions in class are private"
+  template <typename U>
+  static int probe(void (U::*)(void));
+  template <typename>
+  static char probe(...);
+
+ public:
+  static const bool value = sizeof(probe<T>(0)) == sizeof(int);
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/is_const.hpp b/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/is_const.hpp
new file mode 100644
index 0000000..08c5a6f
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/is_const.hpp
@@ -0,0 +1,18 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include "integral_constant.hpp"
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+// A meta-function that return the type T without the const modifier
+template <typename T>
+struct is_const : false_type {};
+
+template <typename T>
+struct is_const<const T> : true_type {};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/is_convertible.hpp b/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/is_convertible.hpp
new file mode 100644
index 0000000..51a063a
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/is_convertible.hpp
@@ -0,0 +1,46 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include "declval.hpp"
+
+#ifdef _MSC_VER
+#  pragma warning(push)
+// conversion from 'T' to 'To', possible loss of data
+#  pragma warning(disable : 4244)
+#endif
+
+// clang-format off
+#ifdef __ICCARM__
+// Suppress IAR Compiler Warning[Pa093]: implicit conversion from floating point to integer
+#pragma diag_suppress=Pa093
+#endif
+// clang-format on
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <typename From, typename To>
+struct is_convertible {
+ protected:  // <- to avoid GCC's "all member functions in class are private"
+  static int probe(To);
+  static char probe(...);
+
+  static const From& from_;
+
+ public:
+  static const bool value = sizeof(probe(from_)) == sizeof(int);
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
+
+#ifdef _MSC_VER
+#  pragma warning(pop)
+#endif
+
+// clang-format off
+#ifdef __ICCARM__
+#pragma diag_default=Pa093
+#endif
+// clang-format on
diff --git a/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/is_enum.hpp b/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/is_enum.hpp
new file mode 100644
index 0000000..ad79045
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/is_enum.hpp
@@ -0,0 +1,22 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include "is_class.hpp"
+#include "is_convertible.hpp"
+#include "is_floating_point.hpp"
+#include "is_integral.hpp"
+#include "is_same.hpp"
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <typename T>
+struct is_enum {
+  static const bool value = is_convertible<T, long long>::value &&
+                            !is_class<T>::value && !is_integral<T>::value &&
+                            !is_floating_point<T>::value;
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/is_floating_point.hpp b/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/is_floating_point.hpp
new file mode 100644
index 0000000..1a0e7f0
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/is_floating_point.hpp
@@ -0,0 +1,19 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include "integral_constant.hpp"
+#include "is_same.hpp"
+#include "remove_cv.hpp"
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <class T>
+struct is_floating_point
+    : integral_constant<bool,  //
+                        is_same<float, remove_cv_t<T>>::value ||
+                            is_same<double, remove_cv_t<T>>::value> {};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/is_integral.hpp b/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/is_integral.hpp
new file mode 100644
index 0000000..80faf4d
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/is_integral.hpp
@@ -0,0 +1,32 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Configuration.hpp>
+
+#include "integral_constant.hpp"
+#include "is_same.hpp"
+#include "remove_cv.hpp"
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+// clang-format off
+template <typename T>
+struct is_integral : integral_constant<bool,
+    is_same<remove_cv_t<T>, signed char>::value ||
+    is_same<remove_cv_t<T>, unsigned char>::value ||
+    is_same<remove_cv_t<T>, signed short>::value ||
+    is_same<remove_cv_t<T>, unsigned short>::value ||
+    is_same<remove_cv_t<T>, signed int>::value ||
+    is_same<remove_cv_t<T>, unsigned int>::value ||
+    is_same<remove_cv_t<T>, signed long>::value ||
+    is_same<remove_cv_t<T>, unsigned long>::value ||
+    is_same<remove_cv_t<T>, signed long long>::value ||
+    is_same<remove_cv_t<T>, unsigned long long>::value ||
+    is_same<remove_cv_t<T>, char>::value ||
+    is_same<remove_cv_t<T>, bool>::value> {};
+// clang-format on
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/is_pointer.hpp b/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/is_pointer.hpp
new file mode 100644
index 0000000..40dd5c4
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/is_pointer.hpp
@@ -0,0 +1,17 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include "integral_constant.hpp"
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <typename T>
+struct is_pointer : false_type {};
+
+template <typename T>
+struct is_pointer<T*> : true_type {};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/is_same.hpp b/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/is_same.hpp
new file mode 100644
index 0000000..97b1c62
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/is_same.hpp
@@ -0,0 +1,18 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include "integral_constant.hpp"
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+// A meta-function that returns true if types T and U are the same.
+template <typename T, typename U>
+struct is_same : false_type {};
+
+template <typename T>
+struct is_same<T, T> : true_type {};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/is_signed.hpp b/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/is_signed.hpp
new file mode 100644
index 0000000..48bc6e4
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/is_signed.hpp
@@ -0,0 +1,26 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include "integral_constant.hpp"
+#include "is_same.hpp"
+#include "remove_cv.hpp"
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+// clang-format off
+template <typename T>
+struct is_signed : integral_constant<bool,
+    is_same<remove_cv_t<T>, char>::value ||
+    is_same<remove_cv_t<T>, signed char>::value ||
+    is_same<remove_cv_t<T>, signed short>::value ||
+    is_same<remove_cv_t<T>, signed int>::value ||
+    is_same<remove_cv_t<T>, signed long>::value ||
+    is_same<remove_cv_t<T>, signed long long>::value ||
+    is_same<remove_cv_t<T>, float>::value ||
+    is_same<remove_cv_t<T>, double>::value> {};
+// clang-format on
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/is_unsigned.hpp b/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/is_unsigned.hpp
new file mode 100644
index 0000000..0c60108
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/is_unsigned.hpp
@@ -0,0 +1,24 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include "integral_constant.hpp"
+#include "is_same.hpp"
+#include "remove_cv.hpp"
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+// clang-format off
+template <typename T>
+struct is_unsigned : integral_constant<bool,
+    is_same<remove_cv_t<T>, unsigned char>::value ||
+    is_same<remove_cv_t<T>, unsigned short>::value ||
+    is_same<remove_cv_t<T>, unsigned int>::value ||
+    is_same<remove_cv_t<T>, unsigned long>::value ||
+    is_same<remove_cv_t<T>, unsigned long long>::value ||
+    is_same<remove_cv_t<T>, bool>::value> {};
+// clang-format on
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/make_unsigned.hpp b/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/make_unsigned.hpp
new file mode 100644
index 0000000..cd4b284
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/make_unsigned.hpp
@@ -0,0 +1,44 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include "type_identity.hpp"
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <typename T>
+struct make_unsigned;
+
+template <>
+struct make_unsigned<char> : type_identity<unsigned char> {};
+
+template <>
+struct make_unsigned<signed char> : type_identity<unsigned char> {};
+template <>
+struct make_unsigned<unsigned char> : type_identity<unsigned char> {};
+
+template <>
+struct make_unsigned<signed short> : type_identity<unsigned short> {};
+template <>
+struct make_unsigned<unsigned short> : type_identity<unsigned short> {};
+
+template <>
+struct make_unsigned<signed int> : type_identity<unsigned int> {};
+template <>
+struct make_unsigned<unsigned int> : type_identity<unsigned int> {};
+
+template <>
+struct make_unsigned<signed long> : type_identity<unsigned long> {};
+template <>
+struct make_unsigned<unsigned long> : type_identity<unsigned long> {};
+
+template <>
+struct make_unsigned<signed long long> : type_identity<unsigned long long> {};
+template <>
+struct make_unsigned<unsigned long long> : type_identity<unsigned long long> {};
+
+template <typename T>
+using make_unsigned_t = typename make_unsigned<T>::type;
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/remove_const.hpp b/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/remove_const.hpp
new file mode 100644
index 0000000..11d68de
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/remove_const.hpp
@@ -0,0 +1,24 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+// A meta-function that return the type T without the const modifier
+template <typename T>
+struct remove_const {
+  using type = T;
+};
+template <typename T>
+struct remove_const<const T> {
+  using type = T;
+};
+
+template <typename T>
+using remove_const_t = typename remove_const<T>::type;
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/remove_cv.hpp b/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/remove_cv.hpp
new file mode 100644
index 0000000..75878a5
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/remove_cv.hpp
@@ -0,0 +1,31 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <typename T>
+struct remove_cv {
+  using type = T;
+};
+template <typename T>
+struct remove_cv<const T> {
+  using type = T;
+};
+template <typename T>
+struct remove_cv<volatile T> {
+  using type = T;
+};
+template <typename T>
+struct remove_cv<const volatile T> {
+  using type = T;
+};
+
+template <typename T>
+using remove_cv_t = typename remove_cv<T>::type;
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/remove_reference.hpp b/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/remove_reference.hpp
new file mode 100644
index 0000000..cff5e96
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/remove_reference.hpp
@@ -0,0 +1,24 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+// A meta-function that return the type T without the reference modifier.
+template <typename T>
+struct remove_reference {
+  using type = T;
+};
+template <typename T>
+struct remove_reference<T&> {
+  using type = T;
+};
+
+template <typename T>
+using remove_reference_t = typename remove_reference<T>::type;
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/type_identity.hpp b/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/type_identity.hpp
new file mode 100644
index 0000000..1690dd9
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/type_identity.hpp
@@ -0,0 +1,16 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include "integral_constant.hpp"
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <typename T>
+struct type_identity {
+  using type = T;
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/void_t.hpp b/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/void_t.hpp
new file mode 100644
index 0000000..d4512cb
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Polyfills/type_traits/void_t.hpp
@@ -0,0 +1,20 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <typename...>
+struct make_void {
+  using type = void;
+};
+
+template <typename... Args>
+using void_t = typename make_void<Args...>::type;
+// NOTE: using void_t = void; doesn't work on GCC 4.8
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Polyfills/utility.hpp b/lib/ArduinoJson/ArduinoJson/Polyfills/utility.hpp
new file mode 100644
index 0000000..ee12e64
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Polyfills/utility.hpp
@@ -0,0 +1,33 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include "type_traits.hpp"
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+using nullptr_t = decltype(nullptr);
+
+template <class T>
+T&& forward(remove_reference_t<T>& t) noexcept {
+  return static_cast<T&&>(t);
+}
+
+template <class T>
+remove_reference_t<T>&& move(T&& t) {
+  return static_cast<remove_reference_t<T>&&>(t);
+}
+
+// Polyfull for std::swap
+// Don't use the name "swap" because it makes calls ambiguous for types in the
+// detail namespace
+template <class T>
+void swap_(T& a, T& b) {
+  T tmp = move(a);
+  a = move(b);
+  b = move(tmp);
+}
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Serialization/CountingDecorator.hpp b/lib/ArduinoJson/ArduinoJson/Serialization/CountingDecorator.hpp
new file mode 100644
index 0000000..c54f548
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Serialization/CountingDecorator.hpp
@@ -0,0 +1,33 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <typename TWriter>
+class CountingDecorator {
+ public:
+  explicit CountingDecorator(TWriter& writer) : writer_(writer), count_(0) {}
+
+  void write(uint8_t c) {
+    count_ += writer_.write(c);
+  }
+
+  void write(const uint8_t* s, size_t n) {
+    count_ += writer_.write(s, n);
+  }
+
+  size_t count() const {
+    return count_;
+  }
+
+ private:
+  TWriter writer_;
+  size_t count_;
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Serialization/Writer.hpp b/lib/ArduinoJson/ArduinoJson/Serialization/Writer.hpp
new file mode 100644
index 0000000..5685aa9
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Serialization/Writer.hpp
@@ -0,0 +1,47 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+// The default writer is a simple wrapper for Writers that are not copyable
+template <typename TDestination, typename Enable = void>
+class Writer {
+ public:
+  explicit Writer(TDestination& dest) : dest_(&dest) {}
+
+  size_t write(uint8_t c) {
+    return dest_->write(c);
+  }
+
+  size_t write(const uint8_t* s, size_t n) {
+    return dest_->write(s, n);
+  }
+
+ private:
+  TDestination* dest_;
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
+
+#include <ArduinoJson/Serialization/Writers/StaticStringWriter.hpp>
+
+#if ARDUINOJSON_ENABLE_STD_STRING
+#  include <ArduinoJson/Serialization/Writers/StdStringWriter.hpp>
+#endif
+
+#if ARDUINOJSON_ENABLE_ARDUINO_STRING
+#  include <ArduinoJson/Serialization/Writers/ArduinoStringWriter.hpp>
+#endif
+
+#if ARDUINOJSON_ENABLE_STD_STREAM
+#  include <ArduinoJson/Serialization/Writers/StdStreamWriter.hpp>
+#endif
+
+#if ARDUINOJSON_ENABLE_ARDUINO_PRINT
+#  include <ArduinoJson/Serialization/Writers/PrintWriter.hpp>
+#endif
diff --git a/lib/ArduinoJson/ArduinoJson/Serialization/Writers/ArduinoStringWriter.hpp b/lib/ArduinoJson/ArduinoJson/Serialization/Writers/ArduinoStringWriter.hpp
new file mode 100644
index 0000000..f0806ac
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Serialization/Writers/ArduinoStringWriter.hpp
@@ -0,0 +1,55 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <Arduino.h>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <>
+class Writer<::String, void> {
+  static const size_t bufferCapacity = ARDUINOJSON_STRING_BUFFER_SIZE;
+
+ public:
+  explicit Writer(::String& str) : destination_(&str), size_(0) {
+    // clear the string but don't use "" to avoid useless allocation
+    // https://cpp4arduino.com/2018/11/21/eight-tips-to-use-the-string-class-efficiently.html
+    str = static_cast<const char*>(0);
+  }
+
+  ~Writer() {
+    flush();
+  }
+
+  size_t write(uint8_t c) {
+    if (size_ + 1 >= bufferCapacity)
+      if (flush() != 0)
+        return 0;
+    buffer_[size_++] = static_cast<char>(c);
+    return 1;
+  }
+
+  size_t write(const uint8_t* s, size_t n) {
+    for (size_t i = 0; i < n; i++) {
+      write(s[i]);
+    }
+    return n;
+  }
+
+  size_t flush() {
+    ARDUINOJSON_ASSERT(size_ < bufferCapacity);
+    buffer_[size_] = 0;
+    if (destination_->concat(buffer_))
+      size_ = 0;
+    return size_;
+  }
+
+ private:
+  ::String* destination_;
+  char buffer_[bufferCapacity];
+  size_t size_;
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Serialization/Writers/DummyWriter.hpp b/lib/ArduinoJson/ArduinoJson/Serialization/Writers/DummyWriter.hpp
new file mode 100644
index 0000000..d8e47dc
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Serialization/Writers/DummyWriter.hpp
@@ -0,0 +1,22 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+class DummyWriter {
+ public:
+  size_t write(uint8_t) {
+    return 1;
+  }
+
+  size_t write(const uint8_t*, size_t n) {
+    return n;
+  }
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Serialization/Writers/PrintWriter.hpp b/lib/ArduinoJson/ArduinoJson/Serialization/Writers/PrintWriter.hpp
new file mode 100644
index 0000000..77f257b
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Serialization/Writers/PrintWriter.hpp
@@ -0,0 +1,29 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <Arduino.h>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <typename TDestination>
+class Writer<TDestination,
+             enable_if_t<is_base_of<::Print, TDestination>::value>> {
+ public:
+  explicit Writer(::Print& print) : print_(&print) {}
+
+  size_t write(uint8_t c) {
+    return print_->write(c);
+  }
+
+  size_t write(const uint8_t* s, size_t n) {
+    return print_->write(s, n);
+  }
+
+ private:
+  ::Print* print_;
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Serialization/Writers/StaticStringWriter.hpp b/lib/ArduinoJson/ArduinoJson/Serialization/Writers/StaticStringWriter.hpp
new file mode 100644
index 0000000..70d3fdf
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Serialization/Writers/StaticStringWriter.hpp
@@ -0,0 +1,36 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+class StaticStringWriter {
+ public:
+  StaticStringWriter(char* buf, size_t size) : end(buf + size), p(buf) {}
+
+  size_t write(uint8_t c) {
+    if (p >= end)
+      return 0;
+    *p++ = static_cast<char>(c);
+    return 1;
+  }
+
+  size_t write(const uint8_t* s, size_t n) {
+    char* begin = p;
+    while (p < end && n > 0) {
+      *p++ = static_cast<char>(*s++);
+      n--;
+    }
+    return size_t(p - begin);
+  }
+
+ private:
+  char* end;
+  char* p;
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Serialization/Writers/StdStreamWriter.hpp b/lib/ArduinoJson/ArduinoJson/Serialization/Writers/StdStreamWriter.hpp
new file mode 100644
index 0000000..abe7d23
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Serialization/Writers/StdStreamWriter.hpp
@@ -0,0 +1,32 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ostream>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <typename TDestination>
+class Writer<TDestination,
+             enable_if_t<is_base_of<std::ostream, TDestination>::value>> {
+ public:
+  explicit Writer(std::ostream& os) : os_(&os) {}
+
+  size_t write(uint8_t c) {
+    os_->put(static_cast<char>(c));
+    return 1;
+  }
+
+  size_t write(const uint8_t* s, size_t n) {
+    os_->write(reinterpret_cast<const char*>(s),
+               static_cast<std::streamsize>(n));
+    return n;
+  }
+
+ private:
+  std::ostream* os_;
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Serialization/Writers/StdStringWriter.hpp b/lib/ArduinoJson/ArduinoJson/Serialization/Writers/StdStringWriter.hpp
new file mode 100644
index 0000000..0ea4872
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Serialization/Writers/StdStringWriter.hpp
@@ -0,0 +1,42 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+#include <ArduinoJson/Polyfills/type_traits.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <class T, typename = void>
+struct is_std_string : false_type {};
+
+template <class T>
+struct is_std_string<
+    T, enable_if_t<is_same<void, decltype(T().push_back('a'))>::value &&
+                   is_same<T&, decltype(T().append(""))>::value>> : true_type {
+};
+
+template <typename TDestination>
+class Writer<TDestination, enable_if_t<is_std_string<TDestination>::value>> {
+ public:
+  Writer(TDestination& str) : str_(&str) {
+    str.clear();
+  }
+
+  size_t write(uint8_t c) {
+    str_->push_back(static_cast<char>(c));
+    return 1;
+  }
+
+  size_t write(const uint8_t* s, size_t n) {
+    str_->append(reinterpret_cast<const char*>(s), n);
+    return n;
+  }
+
+ private:
+  TDestination* str_;
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Serialization/measure.hpp b/lib/ArduinoJson/ArduinoJson/Serialization/measure.hpp
new file mode 100644
index 0000000..2a2b404
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Serialization/measure.hpp
@@ -0,0 +1,20 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Serialization/Writers/DummyWriter.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <template <typename> class TSerializer>
+size_t measure(ArduinoJson::JsonVariantConst source) {
+  DummyWriter dp;
+  auto data = VariantAttorney::getData(source);
+  auto resources = VariantAttorney::getResourceManager(source);
+  TSerializer<DummyWriter> serializer(dp, resources);
+  return VariantData::accept(data, resources, serializer);
+}
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Serialization/serialize.hpp b/lib/ArduinoJson/ArduinoJson/Serialization/serialize.hpp
new file mode 100644
index 0000000..a1c4e4d
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Serialization/serialize.hpp
@@ -0,0 +1,50 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Serialization/Writer.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <template <typename> class TSerializer, typename TWriter>
+size_t doSerialize(ArduinoJson::JsonVariantConst source, TWriter writer) {
+  auto data = VariantAttorney::getData(source);
+  auto resources = VariantAttorney::getResourceManager(source);
+  TSerializer<TWriter> serializer(writer, resources);
+  return VariantData::accept(data, resources, serializer);
+}
+
+template <template <typename> class TSerializer, typename TDestination>
+size_t serialize(ArduinoJson::JsonVariantConst source,
+                 TDestination& destination) {
+  Writer<TDestination> writer(destination);
+  return doSerialize<TSerializer>(source, writer);
+}
+
+template <template <typename> class TSerializer>
+enable_if_t<!TSerializer<StaticStringWriter>::producesText, size_t> serialize(
+    ArduinoJson::JsonVariantConst source, void* buffer, size_t bufferSize) {
+  StaticStringWriter writer(reinterpret_cast<char*>(buffer), bufferSize);
+  return doSerialize<TSerializer>(source, writer);
+}
+
+template <template <typename> class TSerializer>
+enable_if_t<TSerializer<StaticStringWriter>::producesText, size_t> serialize(
+    ArduinoJson::JsonVariantConst source, void* buffer, size_t bufferSize) {
+  StaticStringWriter writer(reinterpret_cast<char*>(buffer), bufferSize);
+  size_t n = doSerialize<TSerializer>(source, writer);
+  // add null-terminator for text output (not counted in the size)
+  if (n < bufferSize)
+    reinterpret_cast<char*>(buffer)[n] = 0;
+  return n;
+}
+
+template <template <typename> class TSerializer, typename TChar, size_t N>
+enable_if_t<IsChar<TChar>::value, size_t> serialize(
+    ArduinoJson::JsonVariantConst source, TChar (&buffer)[N]) {
+  return serialize<TSerializer>(source, buffer, N);
+}
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Strings/Adapters/FlashString.hpp b/lib/ArduinoJson/ArduinoJson/Strings/Adapters/FlashString.hpp
new file mode 100644
index 0000000..1e3c217
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Strings/Adapters/FlashString.hpp
@@ -0,0 +1,93 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Polyfills/pgmspace.hpp>
+#include <ArduinoJson/Strings/StringAdapter.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+class FlashString {
+ public:
+  static const size_t typeSortKey = 1;
+
+  FlashString(const __FlashStringHelper* str, size_t sz)
+      : str_(reinterpret_cast<const char*>(str)), size_(sz) {}
+
+  bool isNull() const {
+    return !str_;
+  }
+
+  char operator[](size_t i) const {
+    ARDUINOJSON_ASSERT(str_ != 0);
+    ARDUINOJSON_ASSERT(i <= size_);
+    return static_cast<char>(pgm_read_byte(str_ + i));
+  }
+
+  const char* data() const {
+    return nullptr;
+  }
+
+  size_t size() const {
+    return size_;
+  }
+
+  friend bool stringEquals(FlashString a, RamString b) {
+    ARDUINOJSON_ASSERT(a.typeSortKey < b.typeSortKey);
+    ARDUINOJSON_ASSERT(!a.isNull());
+    ARDUINOJSON_ASSERT(!b.isNull());
+    if (a.size() != b.size())
+      return false;
+    return ::memcmp_P(b.data(), a.str_, a.size_) == 0;
+  }
+
+  friend int stringCompare(FlashString a, RamString b) {
+    ARDUINOJSON_ASSERT(a.typeSortKey < b.typeSortKey);
+    ARDUINOJSON_ASSERT(!a.isNull());
+    ARDUINOJSON_ASSERT(!b.isNull());
+    size_t minsize = a.size() < b.size() ? a.size() : b.size();
+    int res = ::memcmp_P(b.data(), a.str_, minsize);
+    if (res)
+      return -res;
+    if (a.size() < b.size())
+      return -1;
+    if (a.size() > b.size())
+      return 1;
+    return 0;
+  }
+
+  friend void stringGetChars(FlashString s, char* p, size_t n) {
+    ARDUINOJSON_ASSERT(s.size() <= n);
+    ::memcpy_P(p, s.str_, n);
+  }
+
+  bool isStatic() const {
+    return false;
+  }
+
+ private:
+  const char* str_;
+  size_t size_;
+};
+
+template <>
+struct StringAdapter<const __FlashStringHelper*, void> {
+  using AdaptedString = FlashString;
+
+  static AdaptedString adapt(const __FlashStringHelper* s) {
+    return AdaptedString(s, s ? strlen_P(reinterpret_cast<const char*>(s)) : 0);
+  }
+};
+
+template <>
+struct SizedStringAdapter<const __FlashStringHelper*, void> {
+  using AdaptedString = FlashString;
+
+  static AdaptedString adapt(const __FlashStringHelper* s, size_t n) {
+    return AdaptedString(s, n);
+  }
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Strings/Adapters/RamString.hpp b/lib/ArduinoJson/ArduinoJson/Strings/Adapters/RamString.hpp
new file mode 100644
index 0000000..1234a92
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Strings/Adapters/RamString.hpp
@@ -0,0 +1,118 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <stddef.h>  // size_t
+#include <string.h>  // strcmp
+
+#include <ArduinoJson/Polyfills/assert.hpp>
+#include <ArduinoJson/Polyfills/attributes.hpp>
+#include <ArduinoJson/Strings/StringAdapter.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <typename T>
+struct IsChar
+    : integral_constant<bool, is_integral<T>::value && sizeof(T) == 1> {};
+
+class RamString {
+ public:
+  static const size_t typeSortKey = 2;
+#if ARDUINOJSON_SIZEOF_POINTER <= 2
+  static constexpr size_t sizeMask = size_t(-1) >> 1;
+#else
+  static constexpr size_t sizeMask = size_t(-1);
+#endif
+
+  RamString(const char* str, size_t sz, bool isStatic = false)
+      : str_(str), size_(sz & sizeMask), static_(isStatic) {
+    ARDUINOJSON_ASSERT(size_ == sz);
+  }
+
+  bool isNull() const {
+    return !str_;
+  }
+
+  size_t size() const {
+    return size_;
+  }
+
+  char operator[](size_t i) const {
+    ARDUINOJSON_ASSERT(str_ != 0);
+    ARDUINOJSON_ASSERT(i <= size());
+    return str_[i];
+  }
+
+  const char* data() const {
+    return str_;
+  }
+
+  bool isStatic() const {
+    return static_;
+  }
+
+ protected:
+  const char* str_;
+
+#if ARDUINOJSON_SIZEOF_POINTER <= 2
+  // Use a bitfield only on 8-bit microcontrollers
+  size_t size_ : sizeof(size_t) * 8 - 1;
+  bool static_ : 1;
+#else
+  size_t size_;
+  bool static_;
+#endif
+};
+
+template <typename TChar>
+struct StringAdapter<TChar*, enable_if_t<IsChar<TChar>::value>> {
+  using AdaptedString = RamString;
+
+  static AdaptedString adapt(const TChar* p) {
+    auto str = reinterpret_cast<const char*>(p);
+    return AdaptedString(str, str ? ::strlen(str) : 0);
+  }
+};
+
+template <typename TChar>
+struct StringAdapter<TChar[], enable_if_t<IsChar<TChar>::value>> {
+  using AdaptedString = RamString;
+
+  static AdaptedString adapt(const TChar* p) {
+    auto str = reinterpret_cast<const char*>(p);
+    return AdaptedString(str, str ? ::strlen(str) : 0);
+  }
+};
+
+template <size_t N>
+struct StringAdapter<const char (&)[N]> {
+  using AdaptedString = RamString;
+
+  static AdaptedString adapt(const char (&p)[N]) {
+    return RamString(p, N - 1, true);
+  }
+};
+
+template <typename TChar, size_t N>
+struct StringAdapter<TChar[N], enable_if_t<IsChar<TChar>::value>> {
+  using AdaptedString = RamString;
+
+  static AdaptedString adapt(const TChar* p) {
+    ARDUINOJSON_ASSERT(p);
+    auto str = reinterpret_cast<const char*>(p);
+    return AdaptedString(str, ::strlen(str));
+  }
+};
+
+template <typename TChar>
+struct SizedStringAdapter<TChar*, enable_if_t<IsChar<TChar>::value>> {
+  using AdaptedString = RamString;
+
+  static AdaptedString adapt(const TChar* p, size_t n) {
+    return AdaptedString(reinterpret_cast<const char*>(p), n);
+  }
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Strings/Adapters/StringObject.hpp b/lib/ArduinoJson/ArduinoJson/Strings/Adapters/StringObject.hpp
new file mode 100644
index 0000000..7a322b2
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Strings/Adapters/StringObject.hpp
@@ -0,0 +1,48 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Strings/Adapters/RamString.hpp>
+#include <ArduinoJson/Strings/StringAdapter.hpp>
+#include <ArduinoJson/Strings/StringTraits.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <typename T>
+struct StringAdapter<
+    T,
+    enable_if_t<(string_traits<T>::has_cstr || string_traits<T>::has_data) &&
+                (string_traits<T>::has_length || string_traits<T>::has_size)>> {
+  using AdaptedString = RamString;
+
+  static AdaptedString adapt(const T& s) {
+    return AdaptedString(get_data(s), get_size(s));
+  }
+
+ private:
+  template <typename U>
+  static enable_if_t<string_traits<U>::has_size, size_t> get_size(const U& s) {
+    return s.size();
+  }
+
+  template <typename U>
+  static enable_if_t<!string_traits<U>::has_size, size_t> get_size(const U& s) {
+    return s.length();
+  }
+
+  template <typename U>
+  static enable_if_t<string_traits<U>::has_data, const char*> get_data(
+      const U& s) {
+    return s.data();
+  }
+
+  template <typename U>
+  static enable_if_t<!string_traits<U>::has_data, const char*> get_data(
+      const U& s) {
+    return s.c_str();
+  }
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Strings/IsString.hpp b/lib/ArduinoJson/ArduinoJson/Strings/IsString.hpp
new file mode 100644
index 0000000..81f8c81
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Strings/IsString.hpp
@@ -0,0 +1,19 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Polyfills/type_traits.hpp>
+#include <ArduinoJson/Strings/StringAdapter.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <typename T, typename Enable = void>
+struct IsString : false_type {};
+
+template <typename T>
+struct IsString<T, void_t<typename StringAdapterFor<T>::AdaptedString>>
+    : true_type {};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Strings/JsonString.hpp b/lib/ArduinoJson/ArduinoJson/Strings/JsonString.hpp
new file mode 100644
index 0000000..9d79f64
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Strings/JsonString.hpp
@@ -0,0 +1,100 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Polyfills/type_traits.hpp>
+#include <ArduinoJson/Strings/Adapters/RamString.hpp>
+
+#if ARDUINOJSON_ENABLE_STD_STREAM
+#  include <ostream>
+#endif
+
+ARDUINOJSON_BEGIN_PUBLIC_NAMESPACE
+
+// A string.
+// https://arduinojson.org/v7/api/jsonstring/
+class JsonString {
+  friend struct detail::StringAdapter<JsonString>;
+
+ public:
+  JsonString() : str_(nullptr, 0, true) {}
+
+  JsonString(const char* data, bool isStatic = false)
+      : str_(data, data ? ::strlen(data) : 0, isStatic) {}
+
+  template <typename TSize,
+            detail::enable_if_t<detail::is_integral<TSize>::value &&
+                                    !detail::is_same<TSize, bool>::value,
+                                int> = 0>
+  JsonString(const char* data, TSize sz, bool isStatic = false)
+      : str_(data, size_t(sz), isStatic) {}
+
+  // Returns a pointer to the characters.
+  const char* c_str() const {
+    return str_.data();
+  }
+
+  // Returns true if the string is null.
+  bool isNull() const {
+    return str_.isNull();
+  }
+
+  // Returns true if the string is stored by address.
+  // Returns false if the string is stored by copy.
+  bool isStatic() const {
+    return str_.isStatic();
+  }
+
+  // Returns length of the string.
+  size_t size() const {
+    return str_.size();
+  }
+
+  // Returns true if the string is non-null
+  explicit operator bool() const {
+    return str_.data() != 0;
+  }
+
+  // Returns true if strings are equal.
+  friend bool operator==(JsonString lhs, JsonString rhs) {
+    if (lhs.size() != rhs.size())
+      return false;
+    if (lhs.c_str() == rhs.c_str())
+      return true;
+    if (!lhs.c_str())
+      return false;
+    if (!rhs.c_str())
+      return false;
+    return memcmp(lhs.c_str(), rhs.c_str(), lhs.size()) == 0;
+  }
+
+  // Returns true if strings differs.
+  friend bool operator!=(JsonString lhs, JsonString rhs) {
+    return !(lhs == rhs);
+  }
+
+#if ARDUINOJSON_ENABLE_STD_STREAM
+  friend std::ostream& operator<<(std::ostream& lhs, const JsonString& rhs) {
+    lhs.write(rhs.c_str(), static_cast<std::streamsize>(rhs.size()));
+    return lhs;
+  }
+#endif
+
+ private:
+  detail::RamString str_;
+};
+
+namespace detail {
+template <>
+struct StringAdapter<JsonString> {
+  using AdaptedString = RamString;
+
+  static const AdaptedString& adapt(const JsonString& s) {
+    return s.str_;
+  }
+};
+}  // namespace detail
+
+ARDUINOJSON_END_PUBLIC_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Strings/StringAdapter.hpp b/lib/ArduinoJson/ArduinoJson/Strings/StringAdapter.hpp
new file mode 100644
index 0000000..ebe7d8f
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Strings/StringAdapter.hpp
@@ -0,0 +1,47 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Polyfills/utility.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+// a meta function that tells if the type is a string literal (const char[N])
+template <typename T>
+struct IsStringLiteral : false_type {};
+
+template <size_t N>
+struct IsStringLiteral<const char (&)[N]> : true_type {};
+
+template <typename TString, typename Enable = void>
+struct StringAdapter;
+
+template <typename TString, typename Enable = void>
+struct SizedStringAdapter;
+
+template <typename TString>
+using StringAdapterFor =
+    StringAdapter<conditional_t<IsStringLiteral<TString>::value, TString,
+                                remove_cv_t<remove_reference_t<TString>>>>;
+
+template <typename T>
+using AdaptedString = typename StringAdapterFor<T>::AdaptedString;
+
+template <typename TString>
+AdaptedString<TString> adaptString(TString&& s) {
+  return StringAdapterFor<TString>::adapt(detail::forward<TString>(s));
+}
+
+template <typename TChar, enable_if_t<!is_const<TChar>::value, int> = 0>
+AdaptedString<TChar*> adaptString(TChar* p) {
+  return StringAdapter<TChar*>::adapt(p);
+}
+
+template <typename TChar>
+AdaptedString<TChar*> adaptString(TChar* p, size_t n) {
+  return SizedStringAdapter<TChar*>::adapt(p, n);
+}
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Strings/StringAdapters.hpp b/lib/ArduinoJson/ArduinoJson/Strings/StringAdapters.hpp
new file mode 100644
index 0000000..01529fc
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Strings/StringAdapters.hpp
@@ -0,0 +1,72 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Polyfills/type_traits.hpp>
+#include <ArduinoJson/Strings/Adapters/RamString.hpp>
+#include <ArduinoJson/Strings/Adapters/StringObject.hpp>
+
+#if ARDUINOJSON_ENABLE_PROGMEM
+#  include <ArduinoJson/Strings/Adapters/FlashString.hpp>
+#endif
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <typename TAdaptedString1, typename TAdaptedString2>
+enable_if_t<TAdaptedString1::typeSortKey <= TAdaptedString2::typeSortKey, int>
+stringCompare(TAdaptedString1 s1, TAdaptedString2 s2) {
+  ARDUINOJSON_ASSERT(!s1.isNull());
+  ARDUINOJSON_ASSERT(!s2.isNull());
+  size_t size1 = s1.size();
+  size_t size2 = s2.size();
+  size_t n = size1 < size2 ? size1 : size2;
+  for (size_t i = 0; i < n; i++) {
+    if (s1[i] != s2[i])
+      return s1[i] - s2[i];
+  }
+  if (size1 < size2)
+    return -1;
+  if (size1 > size2)
+    return 1;
+  return 0;
+}
+
+template <typename TAdaptedString1, typename TAdaptedString2>
+enable_if_t<(TAdaptedString1::typeSortKey > TAdaptedString2::typeSortKey), int>
+stringCompare(TAdaptedString1 s1, TAdaptedString2 s2) {
+  return -stringCompare(s2, s1);
+}
+
+template <typename TAdaptedString1, typename TAdaptedString2>
+enable_if_t<TAdaptedString1::typeSortKey <= TAdaptedString2::typeSortKey, bool>
+stringEquals(TAdaptedString1 s1, TAdaptedString2 s2) {
+  ARDUINOJSON_ASSERT(!s1.isNull());
+  ARDUINOJSON_ASSERT(!s2.isNull());
+  size_t size1 = s1.size();
+  size_t size2 = s2.size();
+  if (size1 != size2)
+    return false;
+  for (size_t i = 0; i < size1; i++) {
+    if (s1[i] != s2[i])
+      return false;
+  }
+  return true;
+}
+
+template <typename TAdaptedString1, typename TAdaptedString2>
+enable_if_t<(TAdaptedString1::typeSortKey > TAdaptedString2::typeSortKey), bool>
+stringEquals(TAdaptedString1 s1, TAdaptedString2 s2) {
+  return stringEquals(s2, s1);
+}
+
+template <typename TAdaptedString>
+static void stringGetChars(TAdaptedString s, char* p, size_t n) {
+  ARDUINOJSON_ASSERT(s.size() <= n);
+  for (size_t i = 0; i < n; i++) {
+    p[i] = s[i];
+  }
+}
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Strings/StringTraits.hpp b/lib/ArduinoJson/ArduinoJson/Strings/StringTraits.hpp
new file mode 100644
index 0000000..9d12ad1
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Strings/StringTraits.hpp
@@ -0,0 +1,73 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Strings/Adapters/RamString.hpp>
+#include <ArduinoJson/Strings/StringAdapter.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+namespace string_traits_impl {
+
+// const char* c_str() const
+// - String
+// - std::string
+
+template <class T, class = void>
+struct has_cstr : false_type {};
+
+template <class T>
+struct has_cstr<T, enable_if_t<is_same<decltype(declval<const T>().c_str()),
+                                       const char*>::value>> : true_type {};
+
+// const char* data() const
+// - std::string
+// - std::string_view
+// - etl::string
+
+template <class T, class = void>
+struct has_data : false_type {};
+
+template <class T>
+struct has_data<T, enable_if_t<is_same<decltype(declval<const T>().data()),
+                                       const char*>::value>> : true_type {};
+
+// unsigned int length() const
+// - String
+
+template <class T, class = void>
+struct has_length : false_type {};
+
+template <class T>
+struct has_length<
+    T, enable_if_t<is_unsigned<decltype(declval<const T>().length())>::value>>
+    : true_type {};
+
+// size_t size() const
+// - std::string
+// - std::string_view
+// - etl::string
+
+template <class T, class = void>
+struct has_size : false_type {};
+
+template <class T>
+struct has_size<
+    T, enable_if_t<is_same<decltype(declval<const T>().size()), size_t>::value>>
+    : true_type {};
+
+}  // namespace string_traits_impl
+
+template <typename T>
+struct string_traits {
+  enum {
+    has_cstr = string_traits_impl::has_cstr<T>::value,
+    has_length = string_traits_impl::has_length<T>::value,
+    has_data = string_traits_impl::has_data<T>::value,
+    has_size = string_traits_impl::has_size<T>::value
+  };
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Variant/Converter.hpp b/lib/ArduinoJson/ArduinoJson/Variant/Converter.hpp
new file mode 100644
index 0000000..08d9852
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Variant/Converter.hpp
@@ -0,0 +1,23 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+
+ARDUINOJSON_BEGIN_PUBLIC_NAMESPACE
+
+template <typename T, typename Enable = void>
+struct Converter;
+
+ARDUINOJSON_END_PUBLIC_NAMESPACE
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+// clang-format off
+template <typename T1, typename T2>
+class InvalidConversion;  // Error here? See https://arduinojson.org/v7/invalid-conversion/
+// clang-format on
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Variant/ConverterImpl.hpp b/lib/ArduinoJson/ArduinoJson/Variant/ConverterImpl.hpp
new file mode 100644
index 0000000..f783de2
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Variant/ConverterImpl.hpp
@@ -0,0 +1,406 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Json/JsonSerializer.hpp>
+#include <ArduinoJson/Memory/StringBuilder.hpp>
+#include <ArduinoJson/Polyfills/utility.hpp>
+#include <ArduinoJson/Variant/JsonVariantConst.hpp>
+
+#if ARDUINOJSON_ENABLE_STD_STRING
+#  include <string>
+#endif
+
+#if ARDUINOJSON_ENABLE_STRING_VIEW
+#  include <string_view>
+#endif
+
+ARDUINOJSON_BEGIN_PUBLIC_NAMESPACE
+
+template <typename T, typename Enable>
+struct Converter {
+  static_assert(!detail::is_same<T, char>::value,
+                "type 'char' is not supported, use 'signed char', 'unsigned "
+                "char' or another integer type instead");
+
+  static void toJson(const T& src, JsonVariant dst) {
+    // clang-format off
+    convertToJson(src, dst); // Error here? See https://arduinojson.org/v7/unsupported-set/
+    // clang-format on
+  }
+
+  static detail::decay_t<T> fromJson(JsonVariantConst src) {
+    static_assert(!detail::is_same<T, char*>::value,
+                  "type 'char*' is not supported, use 'const char*' instead");
+
+    // clang-format off
+    T result; // Error here? See https://arduinojson.org/v7/non-default-constructible/
+    convertFromJson(src, result);  // Error here? See https://arduinojson.org/v7/unsupported-as/
+    // clang-format on
+    return result;
+  }
+
+  static bool checkJson(JsonVariantConst src) {
+    static_assert(!detail::is_same<T, char*>::value,
+                  "type 'char*' is not supported, use 'const char*' instead");
+
+    T dummy = T();
+    // clang-format off
+    return canConvertFromJson(src, dummy);  // Error here? See https://arduinojson.org/v7/unsupported-is/
+    // clang-format on
+  }
+};
+
+template <typename T>
+struct Converter<T, detail::enable_if_t<detail::is_integral<T>::value &&
+                                        !detail::is_same<bool, T>::value &&
+                                        !detail::is_same<char, T>::value>>
+    : private detail::VariantAttorney {
+  static bool toJson(T src, JsonVariant dst) {
+    ARDUINOJSON_ASSERT_INTEGER_TYPE_IS_SUPPORTED(T);
+    auto data = getData(dst);
+    if (!data)
+      return false;
+    auto resources = getResourceManager(dst);
+    data->clear(resources);
+    return data->setInteger(src, resources);
+  }
+
+  static T fromJson(JsonVariantConst src) {
+    ARDUINOJSON_ASSERT_INTEGER_TYPE_IS_SUPPORTED(T);
+    auto data = getData(src);
+    auto resources = getResourceManager(src);
+    return data ? data->template asIntegral<T>(resources) : T();
+  }
+
+  static bool checkJson(JsonVariantConst src) {
+    auto data = getData(src);
+    auto resources = getResourceManager(src);
+    return data && data->template isInteger<T>(resources);
+  }
+};
+
+template <typename T>
+struct Converter<T, detail::enable_if_t<detail::is_enum<T>::value>>
+    : private detail::VariantAttorney {
+  static bool toJson(T src, JsonVariant dst) {
+    return dst.set(static_cast<JsonInteger>(src));
+  }
+
+  static T fromJson(JsonVariantConst src) {
+    auto data = getData(src);
+    auto resources = getResourceManager(src);
+    return data ? static_cast<T>(data->template asIntegral<int>(resources))
+                : T();
+  }
+
+  static bool checkJson(JsonVariantConst src) {
+    auto data = getData(src);
+    auto resources = getResourceManager(src);
+    return data && data->template isInteger<int>(resources);
+  }
+};
+
+template <>
+struct Converter<bool> : private detail::VariantAttorney {
+  static bool toJson(bool src, JsonVariant dst) {
+    auto data = getData(dst);
+    if (!data)
+      return false;
+    auto resources = getResourceManager(dst);
+    data->clear(resources);
+    data->setBoolean(src);
+    return true;
+  }
+
+  static bool fromJson(JsonVariantConst src) {
+    auto data = getData(src);
+    auto resources = getResourceManager(src);
+    return data ? data->asBoolean(resources) : false;
+  }
+
+  static bool checkJson(JsonVariantConst src) {
+    auto data = getData(src);
+    return data && data->isBoolean();
+  }
+};
+
+template <typename T>
+struct Converter<T, detail::enable_if_t<detail::is_floating_point<T>::value>>
+    : private detail::VariantAttorney {
+  static bool toJson(T src, JsonVariant dst) {
+    auto data = getData(dst);
+    if (!data)
+      return false;
+    auto resources = getResourceManager(dst);
+    data->clear(resources);
+    return data->setFloat(src, resources);
+  }
+
+  static T fromJson(JsonVariantConst src) {
+    auto data = getData(src);
+    auto resources = getResourceManager(src);
+    return data ? data->template asFloat<T>(resources) : 0;
+  }
+
+  static bool checkJson(JsonVariantConst src) {
+    auto data = getData(src);
+    return data && data->isFloat();
+  }
+};
+
+template <>
+struct Converter<const char*> : private detail::VariantAttorney {
+  static void toJson(const char* src, JsonVariant dst) {
+    detail::VariantData::setString(getData(dst), detail::adaptString(src),
+                                   getResourceManager(dst));
+  }
+
+  static const char* fromJson(JsonVariantConst src) {
+    auto data = getData(src);
+    return data ? data->asString().c_str() : 0;
+  }
+
+  static bool checkJson(JsonVariantConst src) {
+    auto data = getData(src);
+    return data && data->isString();
+  }
+};
+
+template <>
+struct Converter<JsonString> : private detail::VariantAttorney {
+  static void toJson(JsonString src, JsonVariant dst) {
+    detail::VariantData::setString(getData(dst), detail::adaptString(src),
+                                   getResourceManager(dst));
+  }
+
+  static JsonString fromJson(JsonVariantConst src) {
+    auto data = getData(src);
+    return data ? data->asString() : JsonString();
+  }
+
+  static bool checkJson(JsonVariantConst src) {
+    auto data = getData(src);
+    return data && data->isString();
+  }
+};
+
+template <typename T>
+inline detail::enable_if_t<detail::IsString<T>::value> convertToJson(
+    const T& src, JsonVariant dst) {
+  using namespace detail;
+  auto data = VariantAttorney::getData(dst);
+  auto resources = VariantAttorney::getResourceManager(dst);
+  detail::VariantData::setString(data, adaptString(src), resources);
+}
+
+// SerializedValue<std::string>
+// SerializedValue<String>
+// SerializedValue<const __FlashStringHelper*>
+template <typename T>
+struct Converter<SerializedValue<T>> : private detail::VariantAttorney {
+  static void toJson(SerializedValue<T> src, JsonVariant dst) {
+    detail::VariantData::setRawString(getData(dst), src,
+                                      getResourceManager(dst));
+  }
+};
+
+template <>
+struct Converter<detail::nullptr_t> : private detail::VariantAttorney {
+  static void toJson(detail::nullptr_t, JsonVariant dst) {
+    detail::VariantData::clear(getData(dst), getResourceManager(dst));
+  }
+  static detail::nullptr_t fromJson(JsonVariantConst) {
+    return nullptr;
+  }
+  static bool checkJson(JsonVariantConst src) {
+    auto data = getData(src);
+    return data == 0 || data->isNull();
+  }
+};
+
+#if ARDUINOJSON_ENABLE_ARDUINO_STREAM
+
+namespace detail {
+class StringBuilderPrint : public Print {
+ public:
+  StringBuilderPrint(ResourceManager* resources) : copier_(resources) {
+    copier_.startString();
+  }
+
+  void save(VariantData* data) {
+    ARDUINOJSON_ASSERT(!overflowed());
+    copier_.save(data);
+  }
+
+  size_t write(uint8_t c) {
+    copier_.append(char(c));
+    return copier_.isValid() ? 1 : 0;
+  }
+
+  size_t write(const uint8_t* buffer, size_t size) {
+    for (size_t i = 0; i < size; i++) {
+      copier_.append(char(buffer[i]));
+      if (!copier_.isValid())
+        return i;
+    }
+    return size;
+  }
+
+  bool overflowed() const {
+    return !copier_.isValid();
+  }
+
+ private:
+  StringBuilder copier_;
+};
+}  // namespace detail
+
+inline void convertToJson(const ::Printable& src, JsonVariant dst) {
+  auto resources = detail::VariantAttorney::getResourceManager(dst);
+  auto data = detail::VariantAttorney::getData(dst);
+  if (!resources || !data)
+    return;
+  data->clear(resources);
+  detail::StringBuilderPrint print(resources);
+  src.printTo(print);
+  if (print.overflowed())
+    return;
+  print.save(data);
+}
+
+#endif
+
+#if ARDUINOJSON_ENABLE_ARDUINO_STRING
+
+inline void convertFromJson(JsonVariantConst src, ::String& dst) {
+  JsonString str = src.as<JsonString>();
+  if (str)
+    dst = str.c_str();
+  else
+    serializeJson(src, dst);
+}
+
+inline bool canConvertFromJson(JsonVariantConst src, const ::String&) {
+  return src.is<JsonString>();
+}
+
+#endif
+
+#if ARDUINOJSON_ENABLE_STD_STRING
+
+inline void convertFromJson(JsonVariantConst src, std::string& dst) {
+  JsonString str = src.as<JsonString>();
+  if (str)
+    dst.assign(str.c_str(), str.size());
+  else
+    serializeJson(src, dst);
+}
+
+inline bool canConvertFromJson(JsonVariantConst src, const std::string&) {
+  return src.is<JsonString>();
+}
+
+#endif
+
+#if ARDUINOJSON_ENABLE_STRING_VIEW
+
+inline void convertFromJson(JsonVariantConst src, std::string_view& dst) {
+  JsonString str = src.as<JsonString>();
+  if (str)  // the standard doesn't allow passing null to the constructor
+    dst = std::string_view(str.c_str(), str.size());
+}
+
+inline bool canConvertFromJson(JsonVariantConst src, const std::string_view&) {
+  return src.is<JsonString>();
+}
+
+#endif
+
+template <>
+struct Converter<JsonArrayConst> : private detail::VariantAttorney {
+  static void toJson(JsonArrayConst src, JsonVariant dst) {
+    if (src.isNull())
+      dst.set(nullptr);
+    else
+      dst.to<JsonArray>().set(src);
+  }
+
+  static JsonArrayConst fromJson(JsonVariantConst src) {
+    auto data = getData(src);
+    auto array = data ? data->asArray() : nullptr;
+    return JsonArrayConst(array, getResourceManager(src));
+  }
+
+  static bool checkJson(JsonVariantConst src) {
+    auto data = getData(src);
+    return data && data->isArray();
+  }
+};
+
+template <>
+struct Converter<JsonArray> : private detail::VariantAttorney {
+  static void toJson(JsonVariantConst src, JsonVariant dst) {
+    if (src.isNull())
+      dst.set(nullptr);
+    else
+      dst.to<JsonArray>().set(src);
+  }
+
+  static JsonArray fromJson(JsonVariant src) {
+    auto data = getData(src);
+    auto resources = getResourceManager(src);
+    return JsonArray(data != 0 ? data->asArray() : 0, resources);
+  }
+
+  static bool checkJson(JsonVariant src) {
+    auto data = getData(src);
+    return data && data->isArray();
+  }
+};
+
+template <>
+struct Converter<JsonObjectConst> : private detail::VariantAttorney {
+  static void toJson(JsonVariantConst src, JsonVariant dst) {
+    if (src.isNull())
+      dst.set(nullptr);
+    else
+      dst.to<JsonObject>().set(src);
+  }
+
+  static JsonObjectConst fromJson(JsonVariantConst src) {
+    auto data = getData(src);
+    auto object = data != 0 ? data->asObject() : nullptr;
+    return JsonObjectConst(object, getResourceManager(src));
+  }
+
+  static bool checkJson(JsonVariantConst src) {
+    auto data = getData(src);
+    return data && data->isObject();
+  }
+};
+
+template <>
+struct Converter<JsonObject> : private detail::VariantAttorney {
+  static void toJson(JsonVariantConst src, JsonVariant dst) {
+    if (src.isNull())
+      dst.set(nullptr);
+    else
+      dst.to<JsonObject>().set(src);
+  }
+
+  static JsonObject fromJson(JsonVariant src) {
+    auto data = getData(src);
+    auto resources = getResourceManager(src);
+    return JsonObject(data != 0 ? data->asObject() : 0, resources);
+  }
+
+  static bool checkJson(JsonVariant src) {
+    auto data = getData(src);
+    return data && data->isObject();
+  }
+};
+
+ARDUINOJSON_END_PUBLIC_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Variant/JsonVariant.hpp b/lib/ArduinoJson/ArduinoJson/Variant/JsonVariant.hpp
new file mode 100644
index 0000000..7dcf689
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Variant/JsonVariant.hpp
@@ -0,0 +1,78 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Variant/VariantRefBase.hpp>
+
+ARDUINOJSON_BEGIN_PUBLIC_NAMESPACE
+
+// A reference to a value in a JsonDocument.
+// https://arduinojson.org/v7/api/jsonvariant/
+class JsonVariant : public detail::VariantRefBase<JsonVariant>,
+                    public detail::VariantOperators<JsonVariant> {
+  friend class detail::VariantAttorney;
+
+ public:
+  // Creates an unbound reference.
+  JsonVariant() : data_(0), resources_(0) {}
+
+  // INTERNAL USE ONLY
+  JsonVariant(detail::VariantData* data, detail::ResourceManager* resources)
+      : data_(data), resources_(resources) {}
+
+ private:
+  detail::ResourceManager* getResourceManager() const {
+    return resources_;
+  }
+
+  detail::VariantData* getData() const {
+    return data_;
+  }
+
+  detail::VariantData* getOrCreateData() const {
+    return data_;
+  }
+
+  detail::VariantData* data_;
+  detail::ResourceManager* resources_;
+};
+
+namespace detail {
+bool copyVariant(JsonVariant dst, JsonVariantConst src);
+}
+
+template <>
+struct Converter<JsonVariant> : private detail::VariantAttorney {
+  static void toJson(JsonVariantConst src, JsonVariant dst) {
+    copyVariant(dst, src);
+  }
+
+  static JsonVariant fromJson(JsonVariant src) {
+    return src;
+  }
+
+  static bool checkJson(JsonVariant src) {
+    auto data = getData(src);
+    return !!data;
+  }
+};
+
+template <>
+struct Converter<JsonVariantConst> : private detail::VariantAttorney {
+  static void toJson(JsonVariantConst src, JsonVariant dst) {
+    copyVariant(dst, src);
+  }
+
+  static JsonVariantConst fromJson(JsonVariantConst src) {
+    return JsonVariantConst(getData(src), getResourceManager(src));
+  }
+
+  static bool checkJson(JsonVariantConst src) {
+    auto data = getData(src);
+    return !!data;
+  }
+};
+
+ARDUINOJSON_END_PUBLIC_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Variant/JsonVariantConst.hpp b/lib/ArduinoJson/ArduinoJson/Variant/JsonVariantConst.hpp
new file mode 100644
index 0000000..dda71d6
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Variant/JsonVariantConst.hpp
@@ -0,0 +1,197 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <stddef.h>
+#include <stdint.h>  // for uint8_t
+
+#include <ArduinoJson/Memory/ResourceManager.hpp>
+#include <ArduinoJson/Polyfills/type_traits.hpp>
+#include <ArduinoJson/Strings/IsString.hpp>
+#include <ArduinoJson/Strings/StringAdapters.hpp>
+#include <ArduinoJson/Variant/VariantAttorney.hpp>
+#include <ArduinoJson/Variant/VariantOperators.hpp>
+#include <ArduinoJson/Variant/VariantTag.hpp>
+
+ARDUINOJSON_BEGIN_PUBLIC_NAMESPACE
+
+// Forward declarations.
+class JsonArray;
+class JsonObject;
+
+// A read-only reference to a value in a JsonDocument
+// https://arduinojson.org/v7/api/jsonarrayconst/
+class JsonVariantConst : public detail::VariantTag,
+                         public detail::VariantOperators<JsonVariantConst> {
+  friend class detail::VariantAttorney;
+
+  template <typename T>
+  using ConversionSupported =
+      detail::is_same<typename detail::function_traits<
+                          decltype(&Converter<T>::fromJson)>::arg1_type,
+                      JsonVariantConst>;
+
+ public:
+  // Creates an unbound reference.
+  JsonVariantConst() : data_(nullptr), resources_(nullptr) {}
+
+  // INTERNAL USE ONLY
+  explicit JsonVariantConst(const detail::VariantData* data,
+                            const detail::ResourceManager* resources)
+      : data_(data), resources_(resources) {}
+
+  // Returns true if the value is null or the reference is unbound.
+  // https://arduinojson.org/v7/api/jsonvariantconst/isnull/
+  bool isNull() const {
+    return detail::VariantData::isNull(data_);
+  }
+
+  // Returns true if the reference is unbound.
+  bool isUnbound() const {
+    return !data_;
+  }
+
+  // Returns the depth (nesting level) of the value.
+  // https://arduinojson.org/v7/api/jsonvariantconst/nesting/
+  size_t nesting() const {
+    return detail::VariantData::nesting(data_, resources_);
+  }
+
+  // Returns the size of the array or object.
+  // https://arduinojson.org/v7/api/jsonvariantconst/size/
+  size_t size() const {
+    return detail::VariantData::size(data_, resources_);
+  }
+
+  // Casts the value to the specified type.
+  // https://arduinojson.org/v7/api/jsonvariantconst/as/
+  template <typename T,
+            detail::enable_if_t<ConversionSupported<T>::value, int> = 0>
+  T as() const {
+    return Converter<T>::fromJson(*this);
+  }
+
+  // Invalid conversion. Will not compile.
+  template <typename T,
+            detail::enable_if_t<!ConversionSupported<T>::value, int> = 0>
+  detail::InvalidConversion<JsonVariantConst, T> as() const;
+
+  // Returns true if the value is of the specified type.
+  // https://arduinojson.org/v7/api/jsonvariantconst/is/
+  template <typename T,
+            detail::enable_if_t<ConversionSupported<T>::value, int> = 0>
+  bool is() const {
+    return Converter<T>::checkJson(*this);
+  }
+
+  // Always returns false for the unsupported types.
+  // https://arduinojson.org/v7/api/jsonvariantconst/is/
+  template <typename T,
+            detail::enable_if_t<!ConversionSupported<T>::value, int> = 0>
+  bool is() const {
+    return false;
+  }
+
+  template <typename T>
+  operator T() const {
+    return as<T>();
+  }
+
+  // Gets array's element at specified index.
+  // https://arduinojson.org/v7/api/jsonvariantconst/subscript/
+  template <typename T,
+            detail::enable_if_t<detail::is_integral<T>::value, int> = 0>
+  JsonVariantConst operator[](T index) const {
+    return JsonVariantConst(
+        detail::VariantData::getElement(data_, size_t(index), resources_),
+        resources_);
+  }
+
+  // Gets object's member with specified key.
+  // https://arduinojson.org/v7/api/jsonvariantconst/subscript/
+  template <typename TString,
+            detail::enable_if_t<detail::IsString<TString>::value, int> = 0>
+  JsonVariantConst operator[](const TString& key) const {
+    return JsonVariantConst(detail::VariantData::getMember(
+                                data_, detail::adaptString(key), resources_),
+                            resources_);
+  }
+
+  // Gets object's member with specified key.
+  // https://arduinojson.org/v7/api/jsonvariantconst/subscript/
+  template <typename TChar,
+            detail::enable_if_t<detail::IsString<TChar*>::value &&
+                                    !detail::is_const<TChar>::value,
+                                int> = 0>
+  JsonVariantConst operator[](TChar* key) const {
+    return JsonVariantConst(detail::VariantData::getMember(
+                                data_, detail::adaptString(key), resources_),
+                            resources_);
+  }
+
+  // Gets object's member with specified key or the array's element at the
+  // specified index.
+  // https://arduinojson.org/v7/api/jsonvariantconst/subscript/
+  template <typename TVariant,
+            detail::enable_if_t<detail::IsVariant<TVariant>::value, int> = 0>
+  JsonVariantConst operator[](const TVariant& key) const {
+    if (key.template is<size_t>())
+      return operator[](key.template as<size_t>());
+    else
+      return operator[](key.template as<JsonString>());
+  }
+
+  // DEPRECATED: use obj[key].is<T>() instead
+  // https://arduinojson.org/v7/api/jsonvariantconst/containskey/
+  template <typename TString,
+            detail::enable_if_t<detail::IsString<TString>::value, int> = 0>
+  ARDUINOJSON_DEPRECATED("use var[key].is<T>() instead")
+  bool containsKey(const TString& key) const {
+    return detail::VariantData::getMember(getData(), detail::adaptString(key),
+                                          resources_) != 0;
+  }
+
+  // DEPRECATED: use obj["key"].is<T>() instead
+  // https://arduinojson.org/v7/api/jsonvariantconst/containskey/
+  template <typename TChar,
+            detail::enable_if_t<detail::IsString<TChar*>::value &&
+                                    !detail::is_const<TChar>::value,
+                                int> = 0>
+  ARDUINOJSON_DEPRECATED("use obj[\"key\"].is<T>() instead")
+  bool containsKey(TChar* key) const {
+    return detail::VariantData::getMember(getData(), detail::adaptString(key),
+                                          resources_) != 0;
+  }
+
+  // DEPRECATED: use obj[key].is<T>() instead
+  // https://arduinojson.org/v7/api/jsonvariantconst/containskey/
+  template <typename TVariant,
+            detail::enable_if_t<detail::IsVariant<TVariant>::value, int> = 0>
+  ARDUINOJSON_DEPRECATED("use var[key].is<T>() instead")
+  bool containsKey(const TVariant& key) const {
+    return containsKey(key.template as<const char*>());
+  }
+
+  // DEPRECATED: always returns zero
+  ARDUINOJSON_DEPRECATED("always returns zero")
+  size_t memoryUsage() const {
+    return 0;
+  }
+
+ protected:
+  const detail::VariantData* getData() const {
+    return data_;
+  }
+
+  const detail::ResourceManager* getResourceManager() const {
+    return resources_;
+  }
+
+ private:
+  const detail::VariantData* data_;
+  const detail::ResourceManager* resources_;
+};
+
+ARDUINOJSON_END_PUBLIC_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Variant/JsonVariantCopier.hpp b/lib/ArduinoJson/ArduinoJson/Variant/JsonVariantCopier.hpp
new file mode 100644
index 0000000..a54686a
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Variant/JsonVariantCopier.hpp
@@ -0,0 +1,34 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Variant/JsonVariant.hpp>
+#include <ArduinoJson/Variant/JsonVariantVisitor.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+class JsonVariantCopier {
+ public:
+  using result_type = bool;
+
+  JsonVariantCopier(JsonVariant dst) : dst_(dst) {}
+
+  template <typename T>
+  bool visit(T src) {
+    return dst_.set(src);
+  }
+
+ private:
+  JsonVariant dst_;
+};
+
+inline bool copyVariant(JsonVariant dst, JsonVariantConst src) {
+  if (dst.isUnbound())
+    return false;
+  JsonVariantCopier copier(dst);
+  return accept(src, copier);
+}
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Variant/JsonVariantVisitor.hpp b/lib/ArduinoJson/ArduinoJson/Variant/JsonVariantVisitor.hpp
new file mode 100644
index 0000000..730d0ae
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Variant/JsonVariantVisitor.hpp
@@ -0,0 +1,61 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Array/JsonArray.hpp>
+#include <ArduinoJson/Object/JsonObject.hpp>
+#include <ArduinoJson/Variant/JsonVariant.hpp>
+#include <ArduinoJson/Variant/VariantDataVisitor.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <typename TResult>
+struct JsonVariantVisitor {
+  using result_type = TResult;
+
+  template <typename T>
+  TResult visit(const T&) {
+    return TResult();
+  }
+};
+
+template <typename TVisitor>
+class VisitorAdapter {
+ public:
+  using result_type = typename TVisitor::result_type;
+
+  VisitorAdapter(TVisitor& visitor, const ResourceManager* resources)
+      : visitor_(&visitor), resources_(resources) {}
+
+  result_type visit(const ArrayData& value) {
+    return visitor_->visit(JsonArrayConst(&value, resources_));
+  }
+
+  result_type visit(const ObjectData& value) {
+    return visitor_->visit(JsonObjectConst(&value, resources_));
+  }
+
+  template <typename T>
+  result_type visit(const T& value) {
+    return visitor_->visit(value);
+  }
+
+ private:
+  TVisitor* visitor_;
+  const ResourceManager* resources_;
+};
+
+template <typename TVisitor>
+typename TVisitor::result_type accept(JsonVariantConst variant,
+                                      TVisitor& visit) {
+  auto data = VariantAttorney::getData(variant);
+  if (!data)
+    return visit.visit(nullptr);
+  auto resources = VariantAttorney::getResourceManager(variant);
+  VisitorAdapter<TVisitor> adapter(visit, resources);
+  return data->accept(adapter, resources);
+}
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Variant/VariantAttorney.hpp b/lib/ArduinoJson/ArduinoJson/Variant/VariantAttorney.hpp
new file mode 100644
index 0000000..4c3e449
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Variant/VariantAttorney.hpp
@@ -0,0 +1,35 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Polyfills/attributes.hpp>
+#include <ArduinoJson/Polyfills/type_traits.hpp>
+#include <ArduinoJson/Variant/VariantData.hpp>
+#include <ArduinoJson/Variant/VariantTo.hpp>
+#include "JsonVariantConst.hpp"
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+// Grants access to the internal variant API
+class VariantAttorney {
+ public:
+  template <typename TClient>
+  static auto getResourceManager(TClient& client)
+      -> decltype(client.getResourceManager()) {
+    return client.getResourceManager();
+  }
+
+  template <typename TClient>
+  static auto getData(TClient& client) -> decltype(client.getData()) {
+    return client.getData();
+  }
+
+  template <typename TClient>
+  static VariantData* getOrCreateData(TClient& client) {
+    return client.getOrCreateData();
+  }
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Variant/VariantCompare.hpp b/lib/ArduinoJson/ArduinoJson/Variant/VariantCompare.hpp
new file mode 100644
index 0000000..854d090
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Variant/VariantCompare.hpp
@@ -0,0 +1,211 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Configuration.hpp>
+#include <ArduinoJson/Numbers/arithmeticCompare.hpp>
+#include <ArduinoJson/Polyfills/type_traits.hpp>
+#include <ArduinoJson/Polyfills/utility.hpp>
+#include <ArduinoJson/Strings/StringAdapters.hpp>
+#include <ArduinoJson/Variant/JsonVariantVisitor.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+struct ComparerBase : JsonVariantVisitor<CompareResult> {};
+
+template <typename T, typename Enable = void>
+struct Comparer;
+
+template <typename T>
+struct Comparer<T, enable_if_t<IsString<T>::value>> : ComparerBase {
+  T rhs;  // TODO: store adapted string?
+
+  explicit Comparer(T value) : rhs(value) {}
+
+  CompareResult visit(JsonString lhs) {
+    int i = stringCompare(adaptString(rhs), adaptString(lhs));
+    if (i < 0)
+      return COMPARE_RESULT_GREATER;
+    else if (i > 0)
+      return COMPARE_RESULT_LESS;
+    else
+      return COMPARE_RESULT_EQUAL;
+  }
+
+  CompareResult visit(nullptr_t) {
+    if (adaptString(rhs).isNull())
+      return COMPARE_RESULT_EQUAL;
+    else
+      return COMPARE_RESULT_DIFFER;
+  }
+
+  using ComparerBase::visit;
+};
+
+template <typename T>
+struct Comparer<
+    T, enable_if_t<is_integral<T>::value || is_floating_point<T>::value>>
+    : ComparerBase {
+  T rhs;
+
+  explicit Comparer(T value) : rhs(value) {}
+
+  template <typename U>
+  enable_if_t<is_floating_point<U>::value || is_integral<U>::value,
+              CompareResult>
+  visit(const U& lhs) {
+    return arithmeticCompare(lhs, rhs);
+  }
+
+  template <typename U>
+  enable_if_t<!is_floating_point<U>::value && !is_integral<U>::value,
+              CompareResult>
+  visit(const U& lhs) {
+    return ComparerBase::visit(lhs);
+  }
+};
+
+struct NullComparer : ComparerBase {
+  CompareResult visit(nullptr_t) {
+    return COMPARE_RESULT_EQUAL;
+  }
+
+  using ComparerBase::visit;
+};
+
+template <>
+struct Comparer<nullptr_t, void> : NullComparer {
+  explicit Comparer(nullptr_t) : NullComparer() {}
+};
+
+struct ArrayComparer : ComparerBase {
+  JsonArrayConst rhs_;
+
+  explicit ArrayComparer(JsonArrayConst rhs) : rhs_(rhs) {}
+
+  CompareResult visit(JsonArrayConst lhs) {
+    if (rhs_ == lhs)
+      return COMPARE_RESULT_EQUAL;
+    else
+      return COMPARE_RESULT_DIFFER;
+  }
+
+  using ComparerBase::visit;
+};
+
+struct ObjectComparer : ComparerBase {
+  JsonObjectConst rhs_;
+
+  explicit ObjectComparer(JsonObjectConst rhs) : rhs_(rhs) {}
+
+  CompareResult visit(JsonObjectConst lhs) {
+    if (lhs == rhs_)
+      return COMPARE_RESULT_EQUAL;
+    else
+      return COMPARE_RESULT_DIFFER;
+  }
+
+  using ComparerBase::visit;
+};
+
+struct RawComparer : ComparerBase {
+  RawString rhs_;
+
+  explicit RawComparer(RawString rhs) : rhs_(rhs) {}
+
+  CompareResult visit(RawString lhs) {
+    size_t size = rhs_.size() < lhs.size() ? rhs_.size() : lhs.size();
+    int n = memcmp(lhs.data(), rhs_.data(), size);
+    if (n < 0)
+      return COMPARE_RESULT_LESS;
+    else if (n > 0)
+      return COMPARE_RESULT_GREATER;
+    else
+      return COMPARE_RESULT_EQUAL;
+  }
+
+  using ComparerBase::visit;
+};
+
+struct VariantComparer : ComparerBase {
+  JsonVariantConst rhs;
+
+  explicit VariantComparer(JsonVariantConst value) : rhs(value) {}
+
+  CompareResult visit(JsonArrayConst lhs) {
+    ArrayComparer comparer(lhs);
+    return reverseResult(comparer);
+  }
+
+  CompareResult visit(JsonObjectConst lhs) {
+    ObjectComparer comparer(lhs);
+    return reverseResult(comparer);
+  }
+
+  CompareResult visit(JsonFloat lhs) {
+    Comparer<JsonFloat> comparer(lhs);
+    return reverseResult(comparer);
+  }
+
+  CompareResult visit(JsonString lhs) {
+    Comparer<JsonString> comparer(lhs);
+    return reverseResult(comparer);
+  }
+
+  CompareResult visit(RawString value) {
+    RawComparer comparer(value);
+    return reverseResult(comparer);
+  }
+
+  CompareResult visit(JsonInteger lhs) {
+    Comparer<JsonInteger> comparer(lhs);
+    return reverseResult(comparer);
+  }
+
+  CompareResult visit(JsonUInt lhs) {
+    Comparer<JsonUInt> comparer(lhs);
+    return reverseResult(comparer);
+  }
+
+  CompareResult visit(bool lhs) {
+    Comparer<bool> comparer(lhs);
+    return reverseResult(comparer);
+  }
+
+  CompareResult visit(nullptr_t) {
+    NullComparer comparer;
+    return reverseResult(comparer);
+  }
+
+ private:
+  template <typename TComparer>
+  CompareResult reverseResult(TComparer& comparer) {
+    CompareResult reversedResult = accept(rhs, comparer);
+    switch (reversedResult) {
+      case COMPARE_RESULT_GREATER:
+        return COMPARE_RESULT_LESS;
+      case COMPARE_RESULT_LESS:
+        return COMPARE_RESULT_GREATER;
+      default:
+        return reversedResult;
+    }
+  }
+};
+
+template <typename T>
+struct Comparer<
+    T, enable_if_t<is_convertible<T, ArduinoJson::JsonVariantConst>::value>>
+    : VariantComparer {
+  explicit Comparer(const T& value)
+      : VariantComparer(static_cast<JsonVariantConst>(value)) {}
+};
+
+template <typename T>
+CompareResult compare(ArduinoJson::JsonVariantConst lhs, const T& rhs) {
+  Comparer<T> comparer(rhs);
+  return accept(lhs, comparer);
+}
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Variant/VariantContent.hpp b/lib/ArduinoJson/ArduinoJson/Variant/VariantContent.hpp
new file mode 100644
index 0000000..7862d07
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Variant/VariantContent.hpp
@@ -0,0 +1,82 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <stddef.h>  // size_t
+
+#include <ArduinoJson/Array/ArrayData.hpp>
+#include <ArduinoJson/Numbers/JsonFloat.hpp>
+#include <ArduinoJson/Numbers/JsonInteger.hpp>
+#include <ArduinoJson/Object/ObjectData.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+enum class VariantTypeBits : uint8_t {
+  OwnedStringBit = 0x01,  // 0000 0001
+  NumberBit = 0x08,       // 0000 1000
+#if ARDUINOJSON_USE_EXTENSIONS
+  ExtensionBit = 0x10,  // 0001 0000
+#endif
+  CollectionMask = 0x60,
+};
+
+enum class VariantType : uint8_t {
+  Null = 0,             // 0000 0000
+  TinyString = 0x02,    // 0000 0010
+  RawString = 0x03,     // 0000 0011
+  LinkedString = 0x04,  // 0000 0100
+  OwnedString = 0x05,   // 0000 0101
+  Boolean = 0x06,       // 0000 0110
+  Uint32 = 0x0A,        // 0000 1010
+  Int32 = 0x0C,         // 0000 1100
+  Float = 0x0E,         // 0000 1110
+#if ARDUINOJSON_USE_LONG_LONG
+  Uint64 = 0x1A,  // 0001 1010
+  Int64 = 0x1C,   // 0001 1100
+#endif
+#if ARDUINOJSON_USE_DOUBLE
+  Double = 0x1E,  // 0001 1110
+#endif
+  Object = 0x20,
+  Array = 0x40,
+};
+
+inline bool operator&(VariantType type, VariantTypeBits bit) {
+  return (uint8_t(type) & uint8_t(bit)) != 0;
+}
+
+const size_t tinyStringMaxLength = 3;
+
+union VariantContent {
+  VariantContent() {}
+
+  float asFloat;
+  bool asBoolean;
+  uint32_t asUint32;
+  int32_t asInt32;
+#if ARDUINOJSON_USE_EXTENSIONS
+  SlotId asSlotId;
+#endif
+  ArrayData asArray;
+  ObjectData asObject;
+  CollectionData asCollection;
+  const char* asLinkedString;
+  struct StringNode* asOwnedString;
+  char asTinyString[tinyStringMaxLength + 1];
+};
+
+#if ARDUINOJSON_USE_EXTENSIONS
+union VariantExtension {
+#  if ARDUINOJSON_USE_LONG_LONG
+  uint64_t asUint64;
+  int64_t asInt64;
+#  endif
+#  if ARDUINOJSON_USE_DOUBLE
+  double asDouble;
+#  endif
+};
+#endif
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Variant/VariantData.hpp b/lib/ArduinoJson/ArduinoJson/Variant/VariantData.hpp
new file mode 100644
index 0000000..9c9c794
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Variant/VariantData.hpp
@@ -0,0 +1,609 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Memory/MemoryPool.hpp>
+#include <ArduinoJson/Memory/StringNode.hpp>
+#include <ArduinoJson/Misc/SerializedValue.hpp>
+#include <ArduinoJson/Numbers/convertNumber.hpp>
+#include <ArduinoJson/Strings/JsonString.hpp>
+#include <ArduinoJson/Strings/StringAdapters.hpp>
+#include <ArduinoJson/Variant/VariantContent.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <typename T>
+T parseNumber(const char* s);
+
+template <typename T>
+static bool isTinyString(const T& s, size_t n) {
+  if (n > tinyStringMaxLength)
+    return false;
+  bool containsNul = false;
+  for (uint8_t i = 0; i < uint8_t(n); i++)
+    containsNul |= !s[i];
+  return !containsNul;
+}
+
+class VariantData {
+  VariantContent content_;  // must be first to allow cast from array to variant
+  VariantType type_;
+  SlotId next_;
+
+ public:
+  // Placement new
+  static void* operator new(size_t, void* p) noexcept {
+    return p;
+  }
+
+  static void operator delete(void*, void*) noexcept {}
+
+  VariantData() : type_(VariantType::Null), next_(NULL_SLOT) {}
+
+  SlotId next() const {
+    return next_;
+  }
+
+  void setNext(SlotId slot) {
+    next_ = slot;
+  }
+
+  template <typename TVisitor>
+  typename TVisitor::result_type accept(
+      TVisitor& visit, const ResourceManager* resources) const {
+#if ARDUINOJSON_USE_EXTENSIONS
+    auto extension = getExtension(resources);
+#else
+    (void)resources;  // silence warning
+#endif
+    switch (type_) {
+      case VariantType::Float:
+        return visit.visit(content_.asFloat);
+
+#if ARDUINOJSON_USE_DOUBLE
+      case VariantType::Double:
+        return visit.visit(extension->asDouble);
+#endif
+
+      case VariantType::Array:
+        return visit.visit(content_.asArray);
+
+      case VariantType::Object:
+        return visit.visit(content_.asObject);
+
+      case VariantType::TinyString:
+        return visit.visit(JsonString(content_.asTinyString));
+
+      case VariantType::LinkedString:
+        return visit.visit(JsonString(content_.asLinkedString, true));
+
+      case VariantType::OwnedString:
+        return visit.visit(JsonString(content_.asOwnedString->data,
+                                      content_.asOwnedString->length));
+
+      case VariantType::RawString:
+        return visit.visit(RawString(content_.asOwnedString->data,
+                                     content_.asOwnedString->length));
+
+      case VariantType::Int32:
+        return visit.visit(static_cast<JsonInteger>(content_.asInt32));
+
+      case VariantType::Uint32:
+        return visit.visit(static_cast<JsonUInt>(content_.asUint32));
+
+#if ARDUINOJSON_USE_LONG_LONG
+      case VariantType::Int64:
+        return visit.visit(extension->asInt64);
+
+      case VariantType::Uint64:
+        return visit.visit(extension->asUint64);
+#endif
+
+      case VariantType::Boolean:
+        return visit.visit(content_.asBoolean != 0);
+
+      default:
+        return visit.visit(nullptr);
+    }
+  }
+
+  template <typename TVisitor>
+  static typename TVisitor::result_type accept(const VariantData* var,
+                                               const ResourceManager* resources,
+                                               TVisitor& visit) {
+    if (var != 0)
+      return var->accept(visit, resources);
+    else
+      return visit.visit(nullptr);
+  }
+
+  VariantData* addElement(ResourceManager* resources) {
+    auto array = isNull() ? &toArray() : asArray();
+    return detail::ArrayData::addElement(array, resources);
+  }
+
+  static VariantData* addElement(VariantData* var, ResourceManager* resources) {
+    if (!var)
+      return nullptr;
+    return var->addElement(resources);
+  }
+
+  template <typename T>
+  bool addValue(const T& value, ResourceManager* resources) {
+    auto array = isNull() ? &toArray() : asArray();
+    return detail::ArrayData::addValue(array, value, resources);
+  }
+
+  template <typename T>
+  static bool addValue(VariantData* var, const T& value,
+                       ResourceManager* resources) {
+    if (!var)
+      return false;
+    return var->addValue(value, resources);
+  }
+
+  bool asBoolean(const ResourceManager* resources) const {
+#if ARDUINOJSON_USE_EXTENSIONS
+    auto extension = getExtension(resources);
+#else
+    (void)resources;  // silence warning
+#endif
+    switch (type_) {
+      case VariantType::Boolean:
+        return content_.asBoolean;
+      case VariantType::Uint32:
+      case VariantType::Int32:
+        return content_.asUint32 != 0;
+      case VariantType::Float:
+        return content_.asFloat != 0;
+#if ARDUINOJSON_USE_DOUBLE
+      case VariantType::Double:
+        return extension->asDouble != 0;
+#endif
+      case VariantType::Null:
+        return false;
+#if ARDUINOJSON_USE_LONG_LONG
+      case VariantType::Uint64:
+      case VariantType::Int64:
+        return extension->asUint64 != 0;
+#endif
+      default:
+        return true;
+    }
+  }
+
+  ArrayData* asArray() {
+    return isArray() ? &content_.asArray : 0;
+  }
+
+  const ArrayData* asArray() const {
+    return const_cast<VariantData*>(this)->asArray();
+  }
+
+  CollectionData* asCollection() {
+    return isCollection() ? &content_.asCollection : 0;
+  }
+
+  const CollectionData* asCollection() const {
+    return const_cast<VariantData*>(this)->asCollection();
+  }
+
+  template <typename T>
+  T asFloat(const ResourceManager* resources) const {
+    static_assert(is_floating_point<T>::value, "T must be a floating point");
+#if ARDUINOJSON_USE_EXTENSIONS
+    auto extension = getExtension(resources);
+#else
+    (void)resources;  // silence warning
+#endif
+    const char* str = nullptr;
+    switch (type_) {
+      case VariantType::Boolean:
+        return static_cast<T>(content_.asBoolean);
+      case VariantType::Uint32:
+        return static_cast<T>(content_.asUint32);
+      case VariantType::Int32:
+        return static_cast<T>(content_.asInt32);
+#if ARDUINOJSON_USE_LONG_LONG
+      case VariantType::Uint64:
+        return static_cast<T>(extension->asUint64);
+      case VariantType::Int64:
+        return static_cast<T>(extension->asInt64);
+#endif
+      case VariantType::TinyString:
+        str = content_.asTinyString;
+        break;
+      case VariantType::LinkedString:
+        str = content_.asLinkedString;
+        break;
+      case VariantType::OwnedString:
+        str = content_.asOwnedString->data;
+        break;
+      case VariantType::Float:
+        return static_cast<T>(content_.asFloat);
+#if ARDUINOJSON_USE_DOUBLE
+      case VariantType::Double:
+        return static_cast<T>(extension->asDouble);
+#endif
+      default:
+        return 0.0;
+    }
+
+    ARDUINOJSON_ASSERT(str != nullptr);
+    return parseNumber<T>(str);
+  }
+
+  template <typename T>
+  T asIntegral(const ResourceManager* resources) const {
+    static_assert(is_integral<T>::value, "T must be an integral type");
+#if ARDUINOJSON_USE_EXTENSIONS
+    auto extension = getExtension(resources);
+#else
+    (void)resources;  // silence warning
+#endif
+    const char* str = nullptr;
+    switch (type_) {
+      case VariantType::Boolean:
+        return content_.asBoolean;
+      case VariantType::Uint32:
+        return convertNumber<T>(content_.asUint32);
+      case VariantType::Int32:
+        return convertNumber<T>(content_.asInt32);
+#if ARDUINOJSON_USE_LONG_LONG
+      case VariantType::Uint64:
+        return convertNumber<T>(extension->asUint64);
+      case VariantType::Int64:
+        return convertNumber<T>(extension->asInt64);
+#endif
+      case VariantType::TinyString:
+        str = content_.asTinyString;
+        break;
+      case VariantType::LinkedString:
+        str = content_.asLinkedString;
+        break;
+      case VariantType::OwnedString:
+        str = content_.asOwnedString->data;
+        break;
+      case VariantType::Float:
+        return convertNumber<T>(content_.asFloat);
+#if ARDUINOJSON_USE_DOUBLE
+      case VariantType::Double:
+        return convertNumber<T>(extension->asDouble);
+#endif
+      default:
+        return 0;
+    }
+
+    ARDUINOJSON_ASSERT(str != nullptr);
+    return parseNumber<T>(str);
+  }
+
+  ObjectData* asObject() {
+    return isObject() ? &content_.asObject : 0;
+  }
+
+  const ObjectData* asObject() const {
+    return const_cast<VariantData*>(this)->asObject();
+  }
+
+  JsonString asRawString() const {
+    switch (type_) {
+      case VariantType::RawString:
+        return JsonString(content_.asOwnedString->data,
+                          content_.asOwnedString->length);
+      default:
+        return JsonString();
+    }
+  }
+
+  JsonString asString() const {
+    switch (type_) {
+      case VariantType::TinyString:
+        return JsonString(content_.asTinyString);
+      case VariantType::LinkedString:
+        return JsonString(content_.asLinkedString, true);
+      case VariantType::OwnedString:
+        return JsonString(content_.asOwnedString->data,
+                          content_.asOwnedString->length);
+      default:
+        return JsonString();
+    }
+  }
+
+#if ARDUINOJSON_USE_EXTENSIONS
+  const VariantExtension* getExtension(const ResourceManager* resources) const;
+#endif
+
+  VariantData* getElement(size_t index,
+                          const ResourceManager* resources) const {
+    return ArrayData::getElement(asArray(), index, resources);
+  }
+
+  static VariantData* getElement(const VariantData* var, size_t index,
+                                 const ResourceManager* resources) {
+    return var != 0 ? var->getElement(index, resources) : 0;
+  }
+
+  template <typename TAdaptedString>
+  VariantData* getMember(TAdaptedString key,
+                         const ResourceManager* resources) const {
+    return ObjectData::getMember(asObject(), key, resources);
+  }
+
+  template <typename TAdaptedString>
+  static VariantData* getMember(const VariantData* var, TAdaptedString key,
+                                const ResourceManager* resources) {
+    if (!var)
+      return 0;
+    return var->getMember(key, resources);
+  }
+
+  VariantData* getOrAddElement(size_t index, ResourceManager* resources) {
+    auto array = isNull() ? &toArray() : asArray();
+    if (!array)
+      return nullptr;
+    return array->getOrAddElement(index, resources);
+  }
+
+  template <typename TAdaptedString>
+  VariantData* getOrAddMember(TAdaptedString key, ResourceManager* resources) {
+    if (key.isNull())
+      return nullptr;
+    auto obj = isNull() ? &toObject() : asObject();
+    if (!obj)
+      return nullptr;
+    return obj->getOrAddMember(key, resources);
+  }
+
+  bool isArray() const {
+    return type_ == VariantType::Array;
+  }
+
+  bool isBoolean() const {
+    return type_ == VariantType::Boolean;
+  }
+
+  bool isCollection() const {
+    return type_ & VariantTypeBits::CollectionMask;
+  }
+
+  bool isFloat() const {
+    return type_ & VariantTypeBits::NumberBit;
+  }
+
+  template <typename T>
+  bool isInteger(const ResourceManager* resources) const {
+#if ARDUINOJSON_USE_LONG_LONG
+    auto extension = getExtension(resources);
+#else
+    (void)resources;  // silence warning
+#endif
+    switch (type_) {
+      case VariantType::Uint32:
+        return canConvertNumber<T>(content_.asUint32);
+
+      case VariantType::Int32:
+        return canConvertNumber<T>(content_.asInt32);
+
+#if ARDUINOJSON_USE_LONG_LONG
+      case VariantType::Uint64:
+        return canConvertNumber<T>(extension->asUint64);
+
+      case VariantType::Int64:
+        return canConvertNumber<T>(extension->asInt64);
+#endif
+
+      default:
+        return false;
+    }
+  }
+
+  bool isNull() const {
+    return type_ == VariantType::Null;
+  }
+
+  static bool isNull(const VariantData* var) {
+    if (!var)
+      return true;
+    return var->isNull();
+  }
+
+  bool isObject() const {
+    return type_ == VariantType::Object;
+  }
+
+  bool isString() const {
+    return type_ == VariantType::LinkedString ||
+           type_ == VariantType::OwnedString ||
+           type_ == VariantType::TinyString;
+  }
+
+  size_t nesting(const ResourceManager* resources) const {
+    auto collection = asCollection();
+    if (collection)
+      return collection->nesting(resources);
+    else
+      return 0;
+  }
+
+  static size_t nesting(const VariantData* var,
+                        const ResourceManager* resources) {
+    if (!var)
+      return 0;
+    return var->nesting(resources);
+  }
+
+  void removeElement(size_t index, ResourceManager* resources) {
+    ArrayData::removeElement(asArray(), index, resources);
+  }
+
+  static void removeElement(VariantData* var, size_t index,
+                            ResourceManager* resources) {
+    if (!var)
+      return;
+    var->removeElement(index, resources);
+  }
+
+  template <typename TAdaptedString>
+  void removeMember(TAdaptedString key, ResourceManager* resources) {
+    ObjectData::removeMember(asObject(), key, resources);
+  }
+
+  template <typename TAdaptedString>
+  static void removeMember(VariantData* var, TAdaptedString key,
+                           ResourceManager* resources) {
+    if (!var)
+      return;
+    var->removeMember(key, resources);
+  }
+
+  void reset() {  // TODO: remove
+    type_ = VariantType::Null;
+  }
+
+  void setBoolean(bool value) {
+    ARDUINOJSON_ASSERT(type_ == VariantType::Null);  // must call clear() first
+    type_ = VariantType::Boolean;
+    content_.asBoolean = value;
+  }
+
+  template <typename T>
+  enable_if_t<sizeof(T) == 4, bool> setFloat(T value, ResourceManager*) {
+    ARDUINOJSON_ASSERT(type_ == VariantType::Null);  // must call clear() first
+    type_ = VariantType::Float;
+    content_.asFloat = value;
+    return true;
+  }
+
+  template <typename T>
+  enable_if_t<sizeof(T) == 8, bool> setFloat(T value, ResourceManager*);
+
+  template <typename T>
+  enable_if_t<is_signed<T>::value, bool> setInteger(T value,
+                                                    ResourceManager* resources);
+
+  template <typename T>
+  enable_if_t<is_unsigned<T>::value, bool> setInteger(
+      T value, ResourceManager* resources);
+
+  void setRawString(StringNode* s) {
+    ARDUINOJSON_ASSERT(type_ == VariantType::Null);  // must call clear() first
+    ARDUINOJSON_ASSERT(s);
+    type_ = VariantType::RawString;
+    content_.asOwnedString = s;
+  }
+
+  template <typename T>
+  void setRawString(SerializedValue<T> value, ResourceManager* resources);
+
+  template <typename T>
+  static void setRawString(VariantData* var, SerializedValue<T> value,
+                           ResourceManager* resources) {
+    if (!var)
+      return;
+    var->clear(resources);
+    var->setRawString(value, resources);
+  }
+
+  template <typename TAdaptedString>
+  bool setString(TAdaptedString value, ResourceManager* resources);
+
+  template <typename TAdaptedString>
+  static void setString(VariantData* var, TAdaptedString value,
+                        ResourceManager* resources) {
+    if (!var)
+      return;
+    var->clear(resources);
+    var->setString(value, resources);
+  }
+
+  void setLinkedString(const char* s) {
+    ARDUINOJSON_ASSERT(type_ == VariantType::Null);  // must call clear() first
+    ARDUINOJSON_ASSERT(s);
+    type_ = VariantType::LinkedString;
+    content_.asLinkedString = s;
+  }
+
+  template <typename TAdaptedString>
+  void setTinyString(const TAdaptedString& s) {
+    ARDUINOJSON_ASSERT(type_ == VariantType::Null);  // must call clear() first
+    ARDUINOJSON_ASSERT(s.size() <= tinyStringMaxLength);
+
+    type_ = VariantType::TinyString;
+
+    auto n = uint8_t(s.size());
+    for (uint8_t i = 0; i < n; i++) {
+      char c = s[i];
+      ARDUINOJSON_ASSERT(c != 0);  // no NUL in tiny string
+      content_.asTinyString[i] = c;
+    }
+
+    content_.asTinyString[n] = 0;
+  }
+
+  void setOwnedString(StringNode* s) {
+    ARDUINOJSON_ASSERT(type_ == VariantType::Null);  // must call clear() first
+    ARDUINOJSON_ASSERT(s);
+    type_ = VariantType::OwnedString;
+    content_.asOwnedString = s;
+  }
+
+  size_t size(const ResourceManager* resources) const {
+    if (isObject())
+      return content_.asObject.size(resources);
+
+    if (isArray())
+      return content_.asArray.size(resources);
+
+    return 0;
+  }
+
+  static size_t size(const VariantData* var, const ResourceManager* resources) {
+    return var != 0 ? var->size(resources) : 0;
+  }
+
+  ArrayData& toArray() {
+    ARDUINOJSON_ASSERT(type_ == VariantType::Null);  // must call clear() first
+    type_ = VariantType::Array;
+    new (&content_.asArray) ArrayData();
+    return content_.asArray;
+  }
+
+  static ArrayData* toArray(VariantData* var, ResourceManager* resources) {
+    if (!var)
+      return 0;
+    var->clear(resources);
+    return &var->toArray();
+  }
+
+  ObjectData& toObject() {
+    ARDUINOJSON_ASSERT(type_ == VariantType::Null);  // must call clear() first
+    type_ = VariantType::Object;
+    new (&content_.asObject) ObjectData();
+    return content_.asObject;
+  }
+
+  static ObjectData* toObject(VariantData* var, ResourceManager* resources) {
+    if (!var)
+      return 0;
+    var->clear(resources);
+    return &var->toObject();
+  }
+
+  VariantType type() const {
+    return type_;
+  }
+
+  // Release the resources used by this variant and set it to null.
+  void clear(ResourceManager* resources);
+
+  static void clear(VariantData* var, ResourceManager* resources) {
+    if (!var)
+      return;
+    var->clear(resources);
+  }
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Variant/VariantDataVisitor.hpp b/lib/ArduinoJson/ArduinoJson/Variant/VariantDataVisitor.hpp
new file mode 100644
index 0000000..bd38ce9
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Variant/VariantDataVisitor.hpp
@@ -0,0 +1,24 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Array/ArrayData.hpp>
+#include <ArduinoJson/Numbers/JsonFloat.hpp>
+#include <ArduinoJson/Numbers/JsonInteger.hpp>
+#include <ArduinoJson/Object/ObjectData.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <typename TResult>
+struct VariantDataVisitor {
+  using result_type = TResult;
+
+  template <typename T>
+  TResult visit(const T&) {
+    return TResult();
+  }
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Variant/VariantImpl.hpp b/lib/ArduinoJson/ArduinoJson/Variant/VariantImpl.hpp
new file mode 100644
index 0000000..86e7be2
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Variant/VariantImpl.hpp
@@ -0,0 +1,146 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Memory/ResourceManager.hpp>
+#include <ArduinoJson/Variant/VariantData.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <typename T>
+inline void VariantData::setRawString(SerializedValue<T> value,
+                                      ResourceManager* resources) {
+  ARDUINOJSON_ASSERT(type_ == VariantType::Null);  // must call clear() first
+  auto dup = resources->saveString(adaptString(value.data(), value.size()));
+  if (dup)
+    setRawString(dup);
+}
+
+template <typename TAdaptedString>
+inline bool VariantData::setString(TAdaptedString value,
+                                   ResourceManager* resources) {
+  ARDUINOJSON_ASSERT(type_ == VariantType::Null);  // must call clear() first
+
+  if (value.isNull())
+    return false;
+
+  if (value.isStatic()) {
+    setLinkedString(value.data());
+    return true;
+  }
+
+  if (isTinyString(value, value.size())) {
+    setTinyString(value);
+    return true;
+  }
+
+  auto dup = resources->saveString(value);
+  if (dup) {
+    setOwnedString(dup);
+    return true;
+  }
+
+  return false;
+}
+
+inline void VariantData::clear(ResourceManager* resources) {
+  if (type_ & VariantTypeBits::OwnedStringBit)
+    resources->dereferenceString(content_.asOwnedString->data);
+
+#if ARDUINOJSON_USE_EXTENSIONS
+  if (type_ & VariantTypeBits::ExtensionBit)
+    resources->freeExtension(content_.asSlotId);
+#endif
+
+  auto collection = asCollection();
+  if (collection)
+    collection->clear(resources);
+
+  type_ = VariantType::Null;
+}
+
+#if ARDUINOJSON_USE_EXTENSIONS
+inline const VariantExtension* VariantData::getExtension(
+    const ResourceManager* resources) const {
+  return type_ & VariantTypeBits::ExtensionBit
+             ? resources->getExtension(content_.asSlotId)
+             : nullptr;
+}
+#endif
+
+template <typename T>
+enable_if_t<sizeof(T) == 8, bool> VariantData::setFloat(
+    T value, ResourceManager* resources) {
+  ARDUINOJSON_ASSERT(type_ == VariantType::Null);  // must call clear() first
+  (void)resources;                                 // silence warning
+
+  float valueAsFloat = static_cast<float>(value);
+
+#if ARDUINOJSON_USE_DOUBLE
+  if (value == valueAsFloat) {
+    type_ = VariantType::Float;
+    content_.asFloat = valueAsFloat;
+  } else {
+    auto extension = resources->allocExtension();
+    if (!extension)
+      return false;
+    type_ = VariantType::Double;
+    content_.asSlotId = extension.id();
+    extension->asDouble = value;
+  }
+#else
+  type_ = VariantType::Float;
+  content_.asFloat = valueAsFloat;
+#endif
+  return true;
+}
+
+template <typename T>
+enable_if_t<is_signed<T>::value, bool> VariantData::setInteger(
+    T value, ResourceManager* resources) {
+  ARDUINOJSON_ASSERT(type_ == VariantType::Null);  // must call clear() first
+  (void)resources;                                 // silence warning
+
+  if (canConvertNumber<int32_t>(value)) {
+    type_ = VariantType::Int32;
+    content_.asInt32 = static_cast<int32_t>(value);
+  }
+#if ARDUINOJSON_USE_LONG_LONG
+  else {
+    auto extension = resources->allocExtension();
+    if (!extension)
+      return false;
+    type_ = VariantType::Int64;
+    content_.asSlotId = extension.id();
+    extension->asInt64 = value;
+  }
+#endif
+  return true;
+}
+
+template <typename T>
+enable_if_t<is_unsigned<T>::value, bool> VariantData::setInteger(
+    T value, ResourceManager* resources) {
+  ARDUINOJSON_ASSERT(type_ == VariantType::Null);  // must call clear() first
+  (void)resources;                                 // silence warning
+
+  if (canConvertNumber<uint32_t>(value)) {
+    type_ = VariantType::Uint32;
+    content_.asUint32 = static_cast<uint32_t>(value);
+  }
+#if ARDUINOJSON_USE_LONG_LONG
+  else {
+    auto extension = resources->allocExtension();
+    if (!extension)
+      return false;
+    type_ = VariantType::Uint64;
+    content_.asSlotId = extension.id();
+    extension->asUint64 = value;
+  }
+#endif
+  return true;
+}
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Variant/VariantOperators.hpp b/lib/ArduinoJson/ArduinoJson/Variant/VariantOperators.hpp
new file mode 100644
index 0000000..74b21f2
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Variant/VariantOperators.hpp
@@ -0,0 +1,188 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Numbers/arithmeticCompare.hpp>
+#include <ArduinoJson/Polyfills/attributes.hpp>
+#include <ArduinoJson/Polyfills/type_traits.hpp>
+#include <ArduinoJson/Variant/VariantTag.hpp>
+
+ARDUINOJSON_BEGIN_PUBLIC_NAMESPACE
+
+class JsonVariantConst;
+
+ARDUINOJSON_END_PUBLIC_NAMESPACE
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <typename T>
+CompareResult compare(JsonVariantConst lhs,
+                      const T& rhs);  // VariantCompare.cpp
+
+struct VariantOperatorTag {};
+
+template <typename TVariant>
+struct VariantOperators : VariantOperatorTag {
+  // Returns the default value if the JsonVariant is unbound or incompatible
+  //
+  // int operator|(JsonVariant, int)
+  // float operator|(JsonVariant, float)
+  // bool operator|(JsonVariant, bool)
+  template <typename T,
+            enable_if_t<!IsVariant<T>::value && !is_array<T>::value, int> = 0>
+  friend T operator|(const TVariant& variant, const T& defaultValue) {
+    if (variant.template is<T>())
+      return variant.template as<T>();
+    else
+      return defaultValue;
+  }
+  //
+  // const char* operator|(JsonVariant, const char*)
+  friend const char* operator|(const TVariant& variant,
+                               const char* defaultValue) {
+    if (variant.template is<const char*>())
+      return variant.template as<const char*>();
+    else
+      return defaultValue;
+  }
+  //
+  // JsonVariant operator|(JsonVariant, JsonVariant)
+  template <typename T>
+  friend enable_if_t<IsVariant<T>::value, JsonVariantConst> operator|(
+      const TVariant& variant, const T& defaultValue) {
+    if (variant)
+      return variant;
+    else
+      return defaultValue;
+  }
+
+  // value == TVariant
+  template <typename T>
+  friend bool operator==(T* lhs, const TVariant& rhs) {
+    return compare(rhs, lhs) == COMPARE_RESULT_EQUAL;
+  }
+  template <typename T>
+  friend bool operator==(const T& lhs, const TVariant& rhs) {
+    return compare(rhs, lhs) == COMPARE_RESULT_EQUAL;
+  }
+
+  // TVariant == value
+  template <typename T>
+  friend bool operator==(const TVariant& lhs, T* rhs) {
+    return compare(lhs, rhs) == COMPARE_RESULT_EQUAL;
+  }
+  template <typename T,
+            enable_if_t<!is_base_of<VariantOperatorTag, T>::value, int> = 0>
+  friend bool operator==(const TVariant& lhs, const T& rhs) {
+    return compare(lhs, rhs) == COMPARE_RESULT_EQUAL;
+  }
+
+  // value != TVariant
+  template <typename T>
+  friend bool operator!=(T* lhs, const TVariant& rhs) {
+    return compare(rhs, lhs) != COMPARE_RESULT_EQUAL;
+  }
+  template <typename T>
+  friend bool operator!=(const T& lhs, const TVariant& rhs) {
+    return compare(rhs, lhs) != COMPARE_RESULT_EQUAL;
+  }
+
+  // TVariant != value
+  template <typename T>
+  friend bool operator!=(const TVariant& lhs, T* rhs) {
+    return compare(lhs, rhs) != COMPARE_RESULT_EQUAL;
+  }
+  template <typename T,
+            enable_if_t<!is_base_of<VariantOperatorTag, T>::value, int> = 0>
+  friend bool operator!=(TVariant lhs, const T& rhs) {
+    return compare(lhs, rhs) != COMPARE_RESULT_EQUAL;
+  }
+
+  // value < TVariant
+  template <typename T>
+  friend bool operator<(T* lhs, const TVariant& rhs) {
+    return compare(rhs, lhs) == COMPARE_RESULT_GREATER;
+  }
+  template <typename T>
+  friend bool operator<(const T& lhs, const TVariant& rhs) {
+    return compare(rhs, lhs) == COMPARE_RESULT_GREATER;
+  }
+
+  // TVariant < value
+  template <typename T>
+  friend bool operator<(const TVariant& lhs, T* rhs) {
+    return compare(lhs, rhs) == COMPARE_RESULT_LESS;
+  }
+  template <typename T,
+            enable_if_t<!is_base_of<VariantOperatorTag, T>::value, int> = 0>
+  friend bool operator<(TVariant lhs, const T& rhs) {
+    return compare(lhs, rhs) == COMPARE_RESULT_LESS;
+  }
+
+  // value <= TVariant
+  template <typename T>
+  friend bool operator<=(T* lhs, const TVariant& rhs) {
+    return (compare(rhs, lhs) & COMPARE_RESULT_GREATER_OR_EQUAL) != 0;
+  }
+  template <typename T>
+  friend bool operator<=(const T& lhs, const TVariant& rhs) {
+    return (compare(rhs, lhs) & COMPARE_RESULT_GREATER_OR_EQUAL) != 0;
+  }
+
+  // TVariant <= value
+  template <typename T>
+  friend bool operator<=(const TVariant& lhs, T* rhs) {
+    return (compare(lhs, rhs) & COMPARE_RESULT_LESS_OR_EQUAL) != 0;
+  }
+  template <typename T,
+            enable_if_t<!is_base_of<VariantOperatorTag, T>::value, int> = 0>
+  friend bool operator<=(TVariant lhs, const T& rhs) {
+    return (compare(lhs, rhs) & COMPARE_RESULT_LESS_OR_EQUAL) != 0;
+  }
+
+  // value > TVariant
+  template <typename T>
+  friend bool operator>(T* lhs, const TVariant& rhs) {
+    return compare(rhs, lhs) == COMPARE_RESULT_LESS;
+  }
+  template <typename T>
+  friend bool operator>(const T& lhs, const TVariant& rhs) {
+    return compare(rhs, lhs) == COMPARE_RESULT_LESS;
+  }
+
+  // TVariant > value
+  template <typename T>
+  friend bool operator>(const TVariant& lhs, T* rhs) {
+    return compare(lhs, rhs) == COMPARE_RESULT_GREATER;
+  }
+  template <typename T,
+            enable_if_t<!is_base_of<VariantOperatorTag, T>::value, int> = 0>
+  friend bool operator>(TVariant lhs, const T& rhs) {
+    return compare(lhs, rhs) == COMPARE_RESULT_GREATER;
+  }
+
+  // value >= TVariant
+  template <typename T>
+  friend bool operator>=(T* lhs, const TVariant& rhs) {
+    return (compare(rhs, lhs) & COMPARE_RESULT_LESS_OR_EQUAL) != 0;
+  }
+  template <typename T>
+  friend bool operator>=(const T& lhs, const TVariant& rhs) {
+    return (compare(rhs, lhs) & COMPARE_RESULT_LESS_OR_EQUAL) != 0;
+  }
+
+  // TVariant >= value
+  template <typename T>
+  friend bool operator>=(const TVariant& lhs, T* rhs) {
+    return (compare(lhs, rhs) & COMPARE_RESULT_GREATER_OR_EQUAL) != 0;
+  }
+  template <typename T,
+            enable_if_t<!is_base_of<VariantOperatorTag, T>::value, int> = 0>
+  friend bool operator>=(const TVariant& lhs, const T& rhs) {
+    return (compare(lhs, rhs) & COMPARE_RESULT_GREATER_OR_EQUAL) != 0;
+  }
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Variant/VariantRefBase.hpp b/lib/ArduinoJson/ArduinoJson/Variant/VariantRefBase.hpp
new file mode 100644
index 0000000..c959bf6
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Variant/VariantRefBase.hpp
@@ -0,0 +1,313 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Configuration.hpp>
+#include <ArduinoJson/Variant/Converter.hpp>
+#include <ArduinoJson/Variant/JsonVariantConst.hpp>
+#include <ArduinoJson/Variant/VariantOperators.hpp>
+#include <ArduinoJson/Variant/VariantTo.hpp>
+
+ARDUINOJSON_BEGIN_PUBLIC_NAMESPACE
+class JsonVariant;
+ARDUINOJSON_END_PUBLIC_NAMESPACE
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+template <typename>
+class ElementProxy;
+
+template <typename, typename>
+class MemberProxy;
+
+template <typename TDerived>
+class VariantRefBase : public VariantTag {
+  friend class VariantAttorney;
+
+ public:
+  // Sets the value to null.
+  // https://arduinojson.org/v7/api/jsonvariant/clear/
+  void clear() const {
+    VariantData::clear(getOrCreateData(), getResourceManager());
+  }
+
+  // Returns true if the value is null or the reference is unbound.
+  // https://arduinojson.org/v7/api/jsonvariant/isnull/
+  bool isNull() const {
+    return VariantData::isNull(getData());
+  }
+
+  // Returns true if the reference is unbound.
+  bool isUnbound() const {
+    return !getData();
+  }
+
+  // Casts the value to the specified type.
+  // https://arduinojson.org/v7/api/jsonvariant/as/
+  template <typename T>
+  T as() const;
+
+  template <typename T, enable_if_t<!is_same<T, TDerived>::value, int> = 0>
+  operator T() const {
+    return as<T>();
+  }
+
+  // Sets the value to an empty array.
+  // https://arduinojson.org/v7/api/jsonvariant/to/
+  template <typename T, enable_if_t<is_same<T, JsonArray>::value, int> = 0>
+  JsonArray to() const;
+
+  // Sets the value to an empty object.
+  // https://arduinojson.org/v7/api/jsonvariant/to/
+  template <typename T, enable_if_t<is_same<T, JsonObject>::value, int> = 0>
+  JsonObject to() const;
+
+  // Sets the value to null.
+  // https://arduinojson.org/v7/api/jsonvariant/to/
+  template <typename T, enable_if_t<is_same<T, JsonVariant>::value, int> = 0>
+  JsonVariant to() const;
+
+  // Returns true if the value is of the specified type.
+  // https://arduinojson.org/v7/api/jsonvariant/is/
+  template <typename T>
+  FORCE_INLINE bool is() const;
+
+  // Copies the specified value.
+  // https://arduinojson.org/v7/api/jsonvariant/set/
+  template <typename T>
+  bool set(const T& value) const {
+    using TypeForConverter = conditional_t<IsStringLiteral<T>::value, T,
+                                           remove_cv_t<remove_reference_t<T>>>;
+    return doSet<Converter<TypeForConverter>>(value);
+  }
+
+  // Copies the specified value.
+  // https://arduinojson.org/v7/api/jsonvariant/set/
+  template <typename T,
+            detail::enable_if_t<!detail::is_const<T>::value, int> = 0>
+  bool set(T* value) const {
+    return doSet<Converter<T*>>(value);
+  }
+
+  // Returns the size of the array or object.
+  // https://arduinojson.org/v7/api/jsonvariant/size/
+  size_t size() const {
+    return VariantData::size(getData(), getResourceManager());
+  }
+
+  // Returns the depth (nesting level) of the value.
+  // https://arduinojson.org/v7/api/jsonvariant/nesting/
+  size_t nesting() const {
+    return VariantData::nesting(getData(), getResourceManager());
+  }
+
+  // Appends a new (empty) element to the array.
+  // Returns a reference to the new element.
+  // https://arduinojson.org/v7/api/jsonvariant/add/
+  template <typename T, enable_if_t<!is_same<T, JsonVariant>::value, int> = 0>
+  T add() const {
+    return add<JsonVariant>().template to<T>();
+  }
+
+  // Appends a new (null) element to the array.
+  // Returns a reference to the new element.
+  // https://arduinojson.org/v7/api/jsonvariant/add/
+  template <typename T, enable_if_t<is_same<T, JsonVariant>::value, int> = 0>
+  T add() const;
+
+  // Appends a value to the array.
+  // https://arduinojson.org/v7/api/jsonvariant/add/
+  template <typename T>
+  bool add(const T& value) const {
+    return detail::VariantData::addValue(getOrCreateData(), value,
+                                         getResourceManager());
+  }
+
+  // Appends a value to the array.
+  // https://arduinojson.org/v7/api/jsonvariant/add/
+  template <typename T, enable_if_t<!is_const<T>::value, int> = 0>
+  bool add(T* value) const {
+    return detail::VariantData::addValue(getOrCreateData(), value,
+                                         getResourceManager());
+  }
+
+  // Removes an element of the array.
+  // https://arduinojson.org/v7/api/jsonvariant/remove/
+  void remove(size_t index) const {
+    VariantData::removeElement(getData(), index, getResourceManager());
+  }
+
+  // Removes a member of the object.
+  // https://arduinojson.org/v7/api/jsonvariant/remove/
+  template <typename TChar, enable_if_t<IsString<TChar*>::value, int> = 0>
+  void remove(TChar* key) const {
+    VariantData::removeMember(getData(), adaptString(key),
+                              getResourceManager());
+  }
+
+  // Removes a member of the object.
+  // https://arduinojson.org/v7/api/jsonvariant/remove/
+  template <typename TString, enable_if_t<IsString<TString>::value, int> = 0>
+  void remove(const TString& key) const {
+    VariantData::removeMember(getData(), adaptString(key),
+                              getResourceManager());
+  }
+
+  // Removes a member of the object or an element of the array.
+  // https://arduinojson.org/v7/api/jsonvariant/remove/
+  template <typename TVariant, enable_if_t<IsVariant<TVariant>::value, int> = 0>
+  void remove(const TVariant& key) const {
+    if (key.template is<size_t>())
+      remove(key.template as<size_t>());
+    else
+      remove(key.template as<const char*>());
+  }
+
+  // Gets or sets an array element.
+  // https://arduinojson.org/v7/api/jsonvariant/subscript/
+  ElementProxy<TDerived> operator[](size_t index) const;
+
+  // DEPRECATED: use obj[key].is<T>() instead
+  // https://arduinojson.org/v7/api/jsonvariant/containskey/
+  template <typename TString, enable_if_t<IsString<TString>::value, int> = 0>
+  ARDUINOJSON_DEPRECATED("use obj[key].is<T>() instead")
+  bool containsKey(const TString& key) const;
+
+  // DEPRECATED: use obj["key"].is<T>() instead
+  // https://arduinojson.org/v7/api/jsonvariant/containskey/
+  template <typename TChar, enable_if_t<IsString<TChar*>::value, int> = 0>
+  ARDUINOJSON_DEPRECATED("use obj[\"key\"].is<T>() instead")
+  bool containsKey(TChar* key) const;
+
+  // DEPRECATED: use obj[key].is<T>() instead
+  // https://arduinojson.org/v7/api/jsonvariant/containskey/
+  template <typename TVariant, enable_if_t<IsVariant<TVariant>::value, int> = 0>
+  ARDUINOJSON_DEPRECATED("use obj[key].is<T>() instead")
+  bool containsKey(const TVariant& key) const;
+
+  // Gets or sets an object member.
+  // https://arduinojson.org/v7/api/jsonvariant/subscript/
+  template <typename TString, enable_if_t<IsString<TString>::value, int> = 0>
+  FORCE_INLINE MemberProxy<TDerived, AdaptedString<TString>> operator[](
+      const TString& key) const;
+
+  // Gets or sets an object member.
+  // https://arduinojson.org/v7/api/jsonvariant/subscript/
+  template <
+      typename TChar,
+      enable_if_t<IsString<TChar*>::value && !is_const<TChar>::value, int> = 0>
+  FORCE_INLINE MemberProxy<TDerived, AdaptedString<TChar*>> operator[](
+      TChar* key) const;
+
+  // Gets an object member or an array element.
+  // https://arduinojson.org/v7/api/jsonvariant/subscript/
+  template <typename TVariant, enable_if_t<IsVariant<TVariant>::value, int> = 0>
+  JsonVariantConst operator[](const TVariant& key) const {
+    if (key.template is<size_t>())
+      return operator[](key.template as<size_t>());
+    else
+      return operator[](key.template as<JsonString>());
+  }
+
+  // DEPRECATED: use add<JsonVariant>() instead
+  ARDUINOJSON_DEPRECATED("use add<JsonVariant>() instead")
+  JsonVariant add() const;
+
+  // DEPRECATED: use add<JsonArray>() instead
+  ARDUINOJSON_DEPRECATED("use add<JsonArray>() instead")
+  JsonArray createNestedArray() const;
+
+  // DEPRECATED: use var[key].to<JsonArray>() instead
+  template <typename TChar>
+  ARDUINOJSON_DEPRECATED("use var[key].to<JsonArray>() instead")
+  JsonArray createNestedArray(TChar* key) const;
+
+  // DEPRECATED: use var[key].to<JsonArray>() instead
+  template <typename TString>
+  ARDUINOJSON_DEPRECATED("use var[key].to<JsonArray>() instead")
+  JsonArray createNestedArray(const TString& key) const;
+
+  // DEPRECATED: use add<JsonObject>() instead
+  ARDUINOJSON_DEPRECATED("use add<JsonObject>() instead")
+  JsonObject createNestedObject() const;
+
+  // DEPRECATED: use var[key].to<JsonObject>() instead
+  template <typename TChar>
+  ARDUINOJSON_DEPRECATED("use var[key].to<JsonObject>() instead")
+  JsonObject createNestedObject(TChar* key) const;
+
+  // DEPRECATED: use var[key].to<JsonObject>() instead
+  template <typename TString>
+  ARDUINOJSON_DEPRECATED("use var[key].to<JsonObject>() instead")
+  JsonObject createNestedObject(const TString& key) const;
+
+  // DEPRECATED: always returns zero
+  ARDUINOJSON_DEPRECATED("always returns zero")
+  size_t memoryUsage() const {
+    return 0;
+  }
+
+  // DEPRECATED: performs a deep copy
+  ARDUINOJSON_DEPRECATED("performs a deep copy")
+  void shallowCopy(JsonVariantConst src) const {
+    set(src);
+  }
+
+ private:
+  TDerived& derived() {
+    return static_cast<TDerived&>(*this);
+  }
+
+  const TDerived& derived() const {
+    return static_cast<const TDerived&>(*this);
+  }
+
+  ResourceManager* getResourceManager() const {
+    return VariantAttorney::getResourceManager(derived());
+  }
+
+  VariantData* getData() const {
+    return VariantAttorney::getData(derived());
+  }
+
+  VariantData* getOrCreateData() const {
+    return VariantAttorney::getOrCreateData(derived());
+  }
+
+  FORCE_INLINE ArduinoJson::JsonVariant getVariant() const;
+
+  FORCE_INLINE ArduinoJson::JsonVariantConst getVariantConst() const {
+    return ArduinoJson::JsonVariantConst(getData(), getResourceManager());
+  }
+
+  template <typename T>
+  FORCE_INLINE enable_if_t<is_same<T, JsonVariantConst>::value, T> getVariant()
+      const {
+    return getVariantConst();
+  }
+
+  template <typename T>
+  FORCE_INLINE enable_if_t<is_same<T, JsonVariant>::value, T> getVariant()
+      const {
+    return getVariant();
+  }
+
+  template <typename TConverter, typename T>
+  bool doSet(const T& value) const {
+    return doSet<TConverter>(
+        value, is_same<typename function_traits<
+                           decltype(&TConverter::toJson)>::return_type,
+                       bool>{});
+  }
+
+  template <typename TConverter, typename T>
+  bool doSet(const T& value, false_type) const;
+
+  template <typename TConverter, typename T>
+  bool doSet(const T& value, true_type) const;
+
+  ArduinoJson::JsonVariant getOrCreateVariant() const;
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Variant/VariantRefBaseImpl.hpp b/lib/ArduinoJson/ArduinoJson/Variant/VariantRefBaseImpl.hpp
new file mode 100644
index 0000000..7685daa
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Variant/VariantRefBaseImpl.hpp
@@ -0,0 +1,175 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Array/JsonArray.hpp>
+#include <ArduinoJson/Object/JsonObject.hpp>
+#include <ArduinoJson/Variant/VariantRefBase.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+template <typename TDerived>
+inline JsonVariant VariantRefBase<TDerived>::add() const {
+  return add<JsonVariant>();
+}
+
+template <typename TDerived>
+template <typename T>
+inline T VariantRefBase<TDerived>::as() const {
+  using variant_type =  // JsonVariantConst or JsonVariant?
+      typename function_traits<decltype(&Converter<T>::fromJson)>::arg1_type;
+  return Converter<T>::fromJson(getVariant<variant_type>());
+}
+
+template <typename TDerived>
+inline JsonArray VariantRefBase<TDerived>::createNestedArray() const {
+  return add<JsonArray>();
+}
+
+template <typename TDerived>
+template <typename TChar>
+inline JsonArray VariantRefBase<TDerived>::createNestedArray(TChar* key) const {
+  return operator[](key).template to<JsonArray>();
+}
+
+template <typename TDerived>
+template <typename TString>
+inline JsonArray VariantRefBase<TDerived>::createNestedArray(
+    const TString& key) const {
+  return operator[](key).template to<JsonArray>();
+}
+
+template <typename TDerived>
+inline JsonObject VariantRefBase<TDerived>::createNestedObject() const {
+  return add<JsonObject>();
+}
+
+template <typename TDerived>
+template <typename TChar>
+inline JsonObject VariantRefBase<TDerived>::createNestedObject(
+    TChar* key) const {
+  return operator[](key).template to<JsonObject>();
+}
+
+template <typename TDerived>
+template <typename TString>
+inline JsonObject VariantRefBase<TDerived>::createNestedObject(
+    const TString& key) const {
+  return operator[](key).template to<JsonObject>();
+}
+
+template <typename TDerived>
+inline void convertToJson(const VariantRefBase<TDerived>& src,
+                          JsonVariant dst) {
+  dst.set(src.template as<JsonVariantConst>());
+}
+
+template <typename TDerived>
+template <typename T, enable_if_t<is_same<T, JsonVariant>::value, int>>
+inline T VariantRefBase<TDerived>::add() const {
+  return JsonVariant(
+      detail::VariantData::addElement(getOrCreateData(), getResourceManager()),
+      getResourceManager());
+}
+
+template <typename TDerived>
+template <typename TString, enable_if_t<IsString<TString>::value, int>>
+inline bool VariantRefBase<TDerived>::containsKey(const TString& key) const {
+  return VariantData::getMember(getData(), adaptString(key),
+                                getResourceManager()) != 0;
+}
+
+template <typename TDerived>
+template <typename TChar, enable_if_t<IsString<TChar*>::value, int>>
+inline bool VariantRefBase<TDerived>::containsKey(TChar* key) const {
+  return VariantData::getMember(getData(), adaptString(key),
+                                getResourceManager()) != 0;
+}
+
+template <typename TDerived>
+template <typename TVariant, enable_if_t<IsVariant<TVariant>::value, int>>
+inline bool VariantRefBase<TDerived>::containsKey(const TVariant& key) const {
+  return containsKey(key.template as<const char*>());
+}
+
+template <typename TDerived>
+inline JsonVariant VariantRefBase<TDerived>::getVariant() const {
+  return JsonVariant(getData(), getResourceManager());
+}
+
+template <typename TDerived>
+inline JsonVariant VariantRefBase<TDerived>::getOrCreateVariant() const {
+  return JsonVariant(getOrCreateData(), getResourceManager());
+}
+
+template <typename TDerived>
+template <typename T>
+inline bool VariantRefBase<TDerived>::is() const {
+  using variant_type =  // JsonVariantConst or JsonVariant?
+      typename function_traits<decltype(&Converter<T>::checkJson)>::arg1_type;
+  return Converter<T>::checkJson(getVariant<variant_type>());
+}
+
+template <typename TDerived>
+inline ElementProxy<TDerived> VariantRefBase<TDerived>::operator[](
+    size_t index) const {
+  return {derived(), index};
+}
+
+template <typename TDerived>
+template <typename TChar,
+          enable_if_t<IsString<TChar*>::value && !is_const<TChar>::value, int>>
+inline MemberProxy<TDerived, AdaptedString<TChar*>>
+VariantRefBase<TDerived>::operator[](TChar* key) const {
+  return {derived(), adaptString(key)};
+}
+
+template <typename TDerived>
+template <typename TString, enable_if_t<IsString<TString>::value, int>>
+inline MemberProxy<TDerived, AdaptedString<TString>>
+VariantRefBase<TDerived>::operator[](const TString& key) const {
+  return {derived(), adaptString(key)};
+}
+
+template <typename TDerived>
+template <typename TConverter, typename T>
+inline bool VariantRefBase<TDerived>::doSet(const T& value, false_type) const {
+  TConverter::toJson(value, getOrCreateVariant());
+  auto resources = getResourceManager();
+  return resources && !resources->overflowed();
+}
+
+template <typename TDerived>
+template <typename TConverter, typename T>
+inline bool VariantRefBase<TDerived>::doSet(const T& value, true_type) const {
+  return TConverter::toJson(value, getOrCreateVariant());
+}
+
+template <typename TDerived>
+template <typename T, enable_if_t<is_same<T, JsonArray>::value, int>>
+inline JsonArray VariantRefBase<TDerived>::to() const {
+  return JsonArray(
+      VariantData::toArray(getOrCreateData(), getResourceManager()),
+      getResourceManager());
+}
+
+template <typename TDerived>
+template <typename T, enable_if_t<is_same<T, JsonObject>::value, int>>
+JsonObject VariantRefBase<TDerived>::to() const {
+  return JsonObject(
+      VariantData::toObject(getOrCreateData(), getResourceManager()),
+      getResourceManager());
+}
+
+template <typename TDerived>
+template <typename T, enable_if_t<is_same<T, JsonVariant>::value, int>>
+JsonVariant VariantRefBase<TDerived>::to() const {
+  auto data = getOrCreateData();
+  auto resources = getResourceManager();
+  detail::VariantData::clear(data, resources);
+  return JsonVariant(data, resources);
+}
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Variant/VariantTag.hpp b/lib/ArduinoJson/ArduinoJson/Variant/VariantTag.hpp
new file mode 100644
index 0000000..69a4cc0
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Variant/VariantTag.hpp
@@ -0,0 +1,16 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+struct VariantTag {};
+
+template <typename T>
+struct IsVariant : is_base_of<VariantTag, T> {};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/Variant/VariantTo.hpp b/lib/ArduinoJson/ArduinoJson/Variant/VariantTo.hpp
new file mode 100644
index 0000000..8e9a08d
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/Variant/VariantTo.hpp
@@ -0,0 +1,34 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+
+ARDUINOJSON_BEGIN_PUBLIC_NAMESPACE
+class JsonArray;
+class JsonObject;
+class JsonVariant;
+ARDUINOJSON_END_PUBLIC_NAMESPACE
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+// A metafunction that returns the type of the value returned by
+// JsonVariant::to<T>()
+template <typename T>
+struct VariantTo {};
+
+template <>
+struct VariantTo<JsonArray> {
+  using type = JsonArray;
+};
+template <>
+struct VariantTo<JsonObject> {
+  using type = JsonObject;
+};
+template <>
+struct VariantTo<JsonVariant> {
+  using type = JsonVariant;
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/compatibility.hpp b/lib/ArduinoJson/ArduinoJson/compatibility.hpp
new file mode 100644
index 0000000..989cc4d
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/compatibility.hpp
@@ -0,0 +1,144 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+//
+// clang-format off
+
+#include <ArduinoJson/Namespace.hpp>
+
+#ifdef ARDUINOJSON_SLOT_OFFSET_SIZE
+#error ARDUINOJSON_SLOT_OFFSET_SIZE has been removed, use ARDUINOJSON_SLOT_ID_SIZE instead
+#endif
+
+#ifdef ARDUINOJSON_ENABLE_STRING_DEDUPLICATION
+#warning "ARDUINOJSON_ENABLE_STRING_DEDUPLICATION has been removed, string deduplication is now always enabled"
+#endif
+
+#ifdef __GNUC__
+
+#define ARDUINOJSON_PRAGMA(x) _Pragma(#x)
+
+#define ARDUINOJSON_COMPILE_ERROR(msg) ARDUINOJSON_PRAGMA(GCC error msg)
+
+#define ARDUINOJSON_STRINGIFY(S) #S
+
+#define ARDUINOJSON_DEPRECATION_ERROR(X, Y) \
+  ARDUINOJSON_COMPILE_ERROR(ARDUINOJSON_STRINGIFY(X is a Y from ArduinoJson 5. Please see https:/\/arduinojson.org/v7/upgrade-from-v5/ to learn how to upgrade to ArduinoJson 7))
+
+#define StaticJsonBuffer ARDUINOJSON_DEPRECATION_ERROR(StaticJsonBuffer, class)
+#define DynamicJsonBuffer ARDUINOJSON_DEPRECATION_ERROR(DynamicJsonBuffer, class)
+#define JsonBuffer ARDUINOJSON_DEPRECATION_ERROR(JsonBuffer, class)
+#define RawJson ARDUINOJSON_DEPRECATION_ERROR(RawJson, function)
+
+#define ARDUINOJSON_NAMESPACE _Pragma ("GCC warning \"ARDUINOJSON_NAMESPACE is deprecated, use ArduinoJson instead\"") ArduinoJson
+
+// DEPRECATED: you don't need to compute the size anymore
+#define JSON_ARRAY_SIZE(N) _Pragma ("GCC warning \"JSON_ARRAY_SIZE is deprecated, you don't need to compute the size anymore\"") (ArduinoJson::detail::sizeofArray(N))
+
+// DEPRECATED: you don't need to compute the size anymore
+#define JSON_OBJECT_SIZE(N) _Pragma ("GCC warning \"JSON_OBJECT_SIZE is deprecated, you don't need to compute the size anymore\"") (ArduinoJson::detail::sizeofObject(N))
+
+// DEPRECATED: you don't need to compute the size anymore
+#define JSON_STRING_SIZE(N) _Pragma ("GCC warning \"JSON_STRING_SIZE is deprecated, you don't need to compute the size anymore\"") (N+1)
+
+#else
+
+// DEPRECATED: you don't need to compute the size anymore
+#define JSON_ARRAY_SIZE(N) (ArduinoJson::detail::sizeofArray(N))
+
+// DEPRECATED: you don't need to compute the size anymore
+#define JSON_OBJECT_SIZE(N) (ArduinoJson::detail::sizeofObject(N))
+
+// DEPRECATED: you don't need to compute the size anymore
+#define JSON_STRING_SIZE(N) (N+1)
+
+#endif
+
+// clang-format on
+
+ARDUINOJSON_BEGIN_PUBLIC_NAMESPACE
+
+// DEPRECATED: use JsonDocument instead
+template <size_t N>
+class ARDUINOJSON_DEPRECATED("use JsonDocument instead") StaticJsonDocument
+    : public JsonDocument {
+ public:
+  using JsonDocument::JsonDocument;
+
+  size_t capacity() const {
+    return N;
+  }
+};
+
+namespace detail {
+template <typename TAllocator>
+class AllocatorAdapter : public Allocator {
+ public:
+  AllocatorAdapter(const AllocatorAdapter&) = delete;
+  AllocatorAdapter& operator=(const AllocatorAdapter&) = delete;
+
+  void* allocate(size_t size) override {
+    return _allocator.allocate(size);
+  }
+
+  void deallocate(void* ptr) override {
+    _allocator.deallocate(ptr);
+  }
+
+  void* reallocate(void* ptr, size_t new_size) override {
+    return _allocator.reallocate(ptr, new_size);
+  }
+
+  static Allocator* instance() {
+    static AllocatorAdapter instance;
+    return &instance;
+  }
+
+ private:
+  AllocatorAdapter() = default;
+  ~AllocatorAdapter() = default;
+
+  TAllocator _allocator;
+};
+}  // namespace detail
+
+// DEPRECATED: use JsonDocument instead
+template <typename TAllocator>
+class ARDUINOJSON_DEPRECATED("use JsonDocument instead") BasicJsonDocument
+    : public JsonDocument {
+ public:
+  BasicJsonDocument(size_t capacity)
+      : JsonDocument(detail::AllocatorAdapter<TAllocator>::instance()),
+        _capacity(capacity) {}
+
+  size_t capacity() const {
+    return _capacity;
+  }
+
+  void garbageCollect() {}
+
+ private:
+  size_t _capacity;
+};
+
+// DEPRECATED: use JsonDocument instead
+class ARDUINOJSON_DEPRECATED("use JsonDocument instead") DynamicJsonDocument
+    : public JsonDocument {
+ public:
+  DynamicJsonDocument(size_t capacity) : _capacity(capacity) {}
+
+  size_t capacity() const {
+    return _capacity;
+  }
+
+  void garbageCollect() {}
+
+ private:
+  size_t _capacity;
+};
+
+inline JsonObject JsonArray::createNestedObject() const {
+  return add<JsonObject>();
+}
+
+ARDUINOJSON_END_PUBLIC_NAMESPACE
diff --git a/lib/ArduinoJson/ArduinoJson/version.hpp b/lib/ArduinoJson/ArduinoJson/version.hpp
new file mode 100644
index 0000000..8743d83
--- /dev/null
+++ b/lib/ArduinoJson/ArduinoJson/version.hpp
@@ -0,0 +1,11 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2026, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#define ARDUINOJSON_VERSION "7.4.3"
+#define ARDUINOJSON_VERSION_MAJOR 7
+#define ARDUINOJSON_VERSION_MINOR 4
+#define ARDUINOJSON_VERSION_REVISION 3
+#define ARDUINOJSON_VERSION_MACRO V743
diff --git a/lib/ArduinoJson/CMakeLists.txt b/lib/ArduinoJson/CMakeLists.txt
new file mode 100644
index 0000000..32d5b0e
--- /dev/null
+++ b/lib/ArduinoJson/CMakeLists.txt
@@ -0,0 +1,91 @@
+# ArduinoJson - https://arduinojson.org
+# Copyright © 2014-2026, Benoit BLANCHON
+# MIT License
+
+# I have no idea what this is about, I simply followed the instructions from:
+# https://dominikberner.ch/cmake-interface-lib/
+
+add_library(ArduinoJson INTERFACE)
+
+include(GNUInstallDirs)
+
+# Adding the install interface generator expression makes sure that the include
+# files are installed to the proper location (provided by GNUInstallDirs)
+target_include_directories(ArduinoJson
+	INTERFACE
+		$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
+		$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
+)
+
+target_compile_definitions(ArduinoJson
+	INTERFACE
+		ARDUINOJSON_DEBUG=$<CONFIG:Debug>
+)
+
+# locations are provided by GNUInstallDirs
+install(
+	TARGETS
+		ArduinoJson
+	EXPORT
+		ArduinoJson_Targets
+	ARCHIVE DESTINATION
+		${CMAKE_INSTALL_LIBDIR}
+	LIBRARY DESTINATION
+		${CMAKE_INSTALL_LIBDIR}
+	RUNTIME DESTINATION
+		${CMAKE_INSTALL_BINDIR}
+)
+
+include(CMakePackageConfigHelpers)
+
+if(${CMAKE_VERSION} VERSION_GREATER "3.14.0")
+	set(ARCH_INDEPENDENT "ARCH_INDEPENDENT")
+endif()
+
+write_basic_package_version_file(
+		"${PROJECT_BINARY_DIR}/ArduinoJsonConfigVersion.cmake"
+	VERSION
+		${PROJECT_VERSION}
+	COMPATIBILITY
+		SameMajorVersion
+	${ARCH_INDEPENDENT}
+)
+
+configure_package_config_file(
+		"${PROJECT_SOURCE_DIR}/extras/ArduinoJsonConfig.cmake.in"
+		"${PROJECT_BINARY_DIR}/ArduinoJsonConfig.cmake"
+	INSTALL_DESTINATION
+		${CMAKE_INSTALL_DATAROOTDIR}/ArduinoJson/cmake
+)
+
+install(
+	EXPORT
+		ArduinoJson_Targets
+	FILE
+		ArduinoJsonTargets.cmake
+	DESTINATION
+		${CMAKE_INSTALL_DATAROOTDIR}/ArduinoJson/cmake
+)
+
+install(
+	FILES
+		"${PROJECT_BINARY_DIR}/ArduinoJsonConfig.cmake"
+		"${PROJECT_BINARY_DIR}/ArduinoJsonConfigVersion.cmake"
+	DESTINATION
+		"${CMAKE_INSTALL_DATAROOTDIR}/ArduinoJson/cmake"
+)
+
+install(
+	FILES
+		ArduinoJson.h
+		ArduinoJson.hpp
+	DESTINATION
+		include
+)
+
+install(
+	DIRECTORY
+		"${CMAKE_CURRENT_SOURCE_DIR}/ArduinoJson"
+	DESTINATION
+		include
+)
diff --git a/lib/Core/ConfigParser.h b/lib/Core/ConfigParser.h
new file mode 100644
index 0000000..5d9b758
--- /dev/null
+++ b/lib/Core/ConfigParser.h
@@ -0,0 +1,156 @@
+#ifndef CONFIG_PARSER_H
+#define CONFIG_PARSER_H
+#include <Arduino.h>
+#include <WiFi.h>
+#include <ArduinoJson.h>
+#include <ModbusIP_ESP8266.h>
+#include <ModbusRTU.h>
+// Core inclusion 
+#include "Equipment/Equipment.h"
+#include "ModbusPoints/Modbus_Point.h"
+#include "ModbusPoints/Modbus_PointFactory.h"
+#include "Storage.h"
+
+// Current Strategies inclusions
+#include "Strategies/Strategy_Behavior.h"
+#include "Strategies/Strategy_Ramp.h"
+#include "Strategies/Strategy_Random.h"
+#include "Strategies/Strategy_Saw.h"
+#include "Strategies/Strategy_Square.h"
+#include "Strategies/Strategy_SingleValue.h"
+
+class ConfigParser {
+private:
+    // Create the Equipment generic instance using ModbusIP as default
+    // Note: The original Equipment code use templates, it is possible to instantiate with ModbusIP
+    static Equipment<ModbusIP>* _equipmentInstance;
+    static WiFiServer* _pythonServer;
+    static int _pythonPort;
+    static int _modeIsTCP;
+public:
+
+    static Equipment<ModbusIP>* getEquipmentInstance() {
+        if (_equipmentInstance == nullptr) {
+            _equipmentInstance = new Equipment<ModbusIP>();
+        }
+        return _equipmentInstance;
+    }
+    /**
+     * @brief Start the TCP socket server to listen Python though WiFi
+     */
+    static void initPythonTCPServer(int port = 8888){
+        _pythonPort = port;
+        _pythonServer = new WiFiServer(_pythonPort);
+        _pythonServer->begin();
+        Serial.print(F("[ConfigParser] Python server started on port: "));
+        Serial.println(_pythonPort);
+    }
+    /**
+     * @brief Check if Python send Json through Wi-Fi and apply
+     */
+    static void checkPythonTCPClient(ModbusIP& mbIP, ModbusRTU& mbRTU, bool* modeIsTCP){
+        if (_pythonServer==nullptr) return;
+        WiFiClient client = _pythonServer->available();
+        if (client) {
+            Serial.println(F("[ConfigParser] Python connected over Wi-Fi..."));
+            String jsonConfig = client.readString();
+            // Apply configuration if it is a valid JSON
+            apply(jsonConfig, mbIP, mbRTU, modeIsTCP);
+            // Store backup configuration in LittleFS
+            Storage::saveConfigFile(jsonConfig);
+            client.println("OK");
+            client.stop();
+        }
+    
+    }
+
+    /**
+     * @brief Main fucntion: Deserialize the Json and configure Modbus and strategies
+     */
+    static void apply(const String& jsonConfig, ModbusIP& mbIP,  ModbusRTU& mbRTU, bool* modeIsTCP) {
+        Serial.println(F("[ConfigParser] Apply new configuration..."));
+        JsonDocument doc;
+        DeserializationError error = deserializeJson(doc, jsonConfig);
+        if (error) {
+            Serial.print(F("[ConfigParser] Deserialize Json Error: "));
+            Serial.println(error.f_str());
+            return;
+        }
+        // 1. Clean Hardware and RAM: Clear all Modbus points and strategies in the Equipment instance
+        Equipment<ModbusIP>* eq = getEquipmentInstance();
+        eq->clearEquipment();
+        // 2. Network and Modbus protocol configuration.
+        if (doc.containsKey("connection")){
+            JsonObject connection = doc["connection"];
+            String type = connection["type"] | "TCP";
+            if (type.equalsIgnoreCase("TCP")){
+                *modeIsTCP = true;
+                int port = connection["port"] | 502;
+                mbIP.server(port);
+                Serial.print(F("[ConfigParser] Modbus TCP server started in port: "));
+                Serial.println(port);
+            } else {
+                *modeIsTCP = false;
+                int slaveId = connection["slave_id"] | 1;
+                mbRTU.server(slaveId);
+                Serial.print(F("[ConfigParser] Modbus RTU server started in slave ID: "));
+                Serial.println(slaveId);
+            }
+        }
+
+        // 2. Rebuild the tags and strategies. 
+        if (doc.containsKey("points")){
+            JsonArray pointsArray = doc["points"];
+            Serial.print(F("[ConfigParser] Mapping requester registers: "));
+            Serial.println(pointsArray.size());
+
+            for(JsonObject p : pointsArray){
+                int address = p["address"];
+                int category = p["cateogry"];
+                int initVal = p["init_val"] | 0;
+                const char* desc = p["desc"] | "Empty_Desc";
+
+                Modbus_Point<ModbusIP>* newPoint = nullptr;
+
+                if (*modeIsTCP) { 
+                    newPoint = createModbus_Point(&mbIP, category, address, initVal, desc);
+                } else {
+                    newPoint = createModbus_Point((ModbusIP*)&mbRTU, category, address, initVal, desc);
+                }
+                if (newPoint != nullptr) {
+                    newPoint->addToModbusServer();
+
+                    if (p.containsKey("strategy")){
+                        const char* stratType = p["strategy"];
+                        unsigned long interval = p["interval"] | 1000;
+
+                        Strategy_Behavior* strategy = nullptr;
+                        if (strcmp(stratType, "ramp") == 0) {
+                            strategy = new RampStrategy((float)(p["target"] | 0.0f), (float)(p["step"] | 100.0f), (int)(p["interval"] | 1000));
+                        } 
+                        else if (strcmp(stratType, "random") == 0) {
+                            strategy = new RandomStrategy(interval);
+                        } 
+                        else if (strcmp(stratType, "saw") == 0) {
+                            strategy = new SawStrategy((float)(p["min"] | 0.0f), (float)(p["max"] | 100.0f), (float)(p["step"] | 5.0f), (int)(p["interval"] | 1000));
+                        } 
+                        else if (strcmp(stratType, "square") == 0) {
+                            strategy = new SquareStrategy((float)(p["lower"] | 0.0f), (float)(p["upper"] | 100.0f), (int)(p["interval"] | 1000));
+                        } 
+                        else if (strcmp(stratType, "single") == 0 || strcmp(stratType, "none") == 0) {
+                            strategy = new SingleValueStrategy((float)(p["setpoint"] | 50.0f), (float)(p["noise"] | 0.5f), (int)(p["interval"] | 1000));
+                        }
+                    }
+                    eq->addModbus_Point(desc, newPoint);
+                }
+            }
+            Serial.println(F("[ConfigParser] Tag deployment completed successfully."));
+        }
+    }
+};
+
+inline Equipment<ModbusIP>* ConfigParser::_equipmentInstance = nullptr;
+inline WiFiServer* ConfigParser::_pythonServer = nullptr;
+inline int ConfigParser::_modeIsTCP = true;
+inline int ConfigParser::_pythonPort = 8888;
+#endif
\ No newline at end of file
diff --git a/lib/Core/Equipment/Equipment.h b/lib/Core/Equipment/Equipment.h
index b2cdecc..aa8d3cf 100644
--- a/lib/Core/Equipment/Equipment.h
+++ b/lib/Core/Equipment/Equipment.h
@@ -14,6 +14,7 @@
 #include <map>
 #include <string>
 #include <vector>
+#include "ModbusPoints/Modbus_Point.h"
 #include "States/State_Standby.h"
 
 // Forward Declarations
@@ -36,6 +37,7 @@ public:
      * Initializes the device in the default initial state (Standby).
      */
     Equipment();
+    ~Equipment();
 
     Equipment(T* server);
     /** @brief The main update loop for the equipment, called repeatedly. Delegates to the current state. */
@@ -80,6 +82,9 @@ public:
      */
     void setModbus_Point(const std::string& description, float value);
 
+    void updateAllPoints();
+    void clearEquipment();
+
 private:
     State<T>* _state;                              /**< @brief Pointer to the current state object. */
     std::map<std::string, Modbus_Point<T>*> _points;/**< @brief Map of all Modbus points, keyed by description. */
@@ -89,20 +94,22 @@ private:
 
 template<typename T>
 Equipment<T>::Equipment() : _server(nullptr) {
-  this->_state = new StandbyState<T>();
-  this->_state->enterState(this);
+
 }
 
+template<typename T>
+Equipment<T>::~Equipment() {
+  clearEquipment();}
+
+
 /**
  * @brief Constructs a new Equipment object with a server instance.
  * @param server Pointer to the Modbus server instance (e.g., ModbusIP, ModbusRTU).
  */
 template<typename T>
 Equipment<T>::Equipment(T* server)
-  : _server(server)
+  : _server(server), _state(nullptr), _stateId(0)
 {
-  this->_state = new StandbyState<T>();
-  this->_state->enterState(this);
 }
 
 /**
@@ -162,6 +169,28 @@ Modbus_Point<T>* Equipment<T>::getModbus_Point(const std::string& description) {
   return nullptr;
 }
 
+template<typename T>
+void Equipment<T>::updateAllPoints() {
+  unsigned long currentMillis = millis();
+  // Iterate safely though the map of points and call updateStrategy on each one
+  for (auto const& [description, point] : _points) {
+    if (point != nullptr) {
+      point->updateStrategy(currentMillis); //Each point execute its own strategy update
+    }
+  }
+}
+template<typename T>
+void Equipment<T>::clearEquipment() {
+  // Delete all Modbus points
+  for (auto const& [description, point] : _points) {
+    if (point != nullptr) {
+      delete point;
+    }
+  }
+  _points.clear();
+  Serial.println(F("[Equipment] Modbus memory map successfully cleared."));
+}
+
 /**
  * @brief Sets the value of a specific Modbus point.
  * Finds the point by its description and calls its `setValue` method.
diff --git a/lib/Core/ModbusPoints/Modbus_Point.h b/lib/Core/ModbusPoints/Modbus_Point.h
index 04a52b4..6e5c1ee 100644
--- a/lib/Core/ModbusPoints/Modbus_Point.h
+++ b/lib/Core/ModbusPoints/Modbus_Point.h
@@ -11,6 +11,7 @@
 #ifndef Modbus_Point_h
 #define Modbus_Point_h
 #include <string.h>
+#include "Strategies/Strategy_Behavior.h"
 /**
  * @enum PointType
  * @brief Identifies the logical type of a Modbus point.
@@ -68,7 +69,18 @@ public:
     virtual int getValue() const = 0;
 
     // --- Dirty Flag ---
+    void setStrategy(Strategy_Behavior* strategy) {
+        if (_strategy != nullptr) delete _strategy;
+        _strategy = strategy;
+    }
 
+    void updateStrategy(unsigned long currentMillis) {
+        if (_strategy != nullptr && _strategy->isReady(currentMillis)) {
+            float currentVal = this->getValue();
+            float newVal = _strategy->execute(currentVal);
+            this->setValue(newVal);
+        }
+    }
     /**
      * @brief Checks if the point's value has changed since the last write.
      * @return True if the value is dirty, false otherwise.
@@ -88,7 +100,8 @@ protected:
   int _address;             /**< @brief The Modbus address of this point. */
   int _value;               /**< @brief The current internal value of this point. */
   char _description[35];    /**< @brief A descriptive name for this point. */
-  bool _dirty = false;      /**< @brief Flag to track if the value has changed and needs to be written. */
+  bool _dirty = false;
+  Strategy_Behavior* _strategy = nullptr;      /**< @brief Flag to track if the value has changed and needs to be written. */
 };
 
 template<typename T>
diff --git a/lib/Core/ModbusPoints/Modbus_PointFactory.h b/lib/Core/ModbusPoints/Modbus_PointFactory.h
index 26c8e3d..07d6959 100644
--- a/lib/Core/ModbusPoints/Modbus_PointFactory.h
+++ b/lib/Core/ModbusPoints/Modbus_PointFactory.h
@@ -19,8 +19,20 @@
 #include "Modbus_LongDecorator.h"
 #include "Modbus_FloatDecorator.h"
 #include <Arduino.h>
+#include <ModbusIP_ESP8266.h>
 
-
+enum ModbusCategory {
+  COIL = 1,
+  DI = 2,
+  IR = 3,
+  IR_10x = 31,
+  IR_LONG = 32,
+  IR_FLOAT = 33,
+  HR = 4,
+  HR_10x = 41,
+  HR_LONG = 42,
+  HR_FLOAT = 43
+};
 /**
  * @brief Creates and decorates a Modbus_Point object based on its type.
  *
@@ -55,56 +67,57 @@ Modbus_Point<T>* createModbus_Point(T* server, int category, int address, int va
  */
 template<typename T>
 Modbus_Point<T>* createModbus_Point(T* server, int category, int address, int value, const char* description) {
+  ModbusCategory mc = static_cast<ModbusCategory>(category);
   switch (category) {
-    case COIL:
+    case 1:
       Serial.printf("Creating Coil: %s\n", description);
       return new Modbus_Coil<T>(server, address, value, description);
 
-    case DI:
+    case 2:
       Serial.printf("Creating Digital Input: %s\n", description);
       return new Modbus_Ists<T>(server, address, value, description);
       
-    case IR:
+    case 3:
       Serial.printf("Creating Input Register: %s\n", description);
       return new Modbus_Ireg<T>(server, address, value, description);
 
-    case IR_10x: {
+    case 31: {
       Serial.printf("Creating Scaled Input Register (10x): %s\n", description);
       Modbus_Point<T>* point = new Modbus_Ireg<T>(server, address, value, description);
       return new Modbus_ScaleDecorator<T>(point);
     }
-    case IR_LONG: {
+    case 32: {
       Serial.printf("Creating Input Register Long: %s\n", description);
       // Create the low and high word registers for the 32-bit long
       Modbus_Point<T>* point = new Modbus_Ireg<T>(server, address, 0, description);
       Modbus_Point<T>* highOrderPoint = new Modbus_Ireg<T>(server, address + 1, 0, "");
       return new Modbus_LongDecorator<T>(point, highOrderPoint);
     }
-    case IR_FLOAT: {
+    case 33: {
       Serial.printf("Creating Input Register Float: %s\n", description);
       // Create the low and high word registers for the 32-bit float
       Modbus_Point<T>* point = new Modbus_Ireg<T>(server, address, 0, description);
       Modbus_Point<T>* highOrderPoint = new Modbus_Ireg<T>(server, address + 1, 0, "");
       return new Modbus_FloatDecorator<T>(point, highOrderPoint);
     }
-    case HR:
+    case 4:
       Serial.printf("Creating Holding Register: %s\n", description);
       return new Modbus_Hreg<T>(server, address, value, description);
 
-    case HR_10x: {
+    case 41: {
       Serial.printf("Creating Scaled Holding Register (10x): %s\n", description);
       // Create a base holding register and wrap it with the scaling decorator
       Modbus_Point<T>* point = new Modbus_Hreg<T>(server, address, value, description);
       return new Modbus_ScaleDecorator<T>(point);
     }
-    case HR_LONG: {
+    case 42: {
       Serial.printf("Creating Holding Register Long: %s\n", description);
       // Create the low and high word registers for the 32-bit long
       Modbus_Point<T>* point = new Modbus_Hreg<T>(server, address, 0, description);
       Modbus_Point<T>* highOrderPoint = new Modbus_Hreg<T>(server, address + 1 , 0, "");
       return new Modbus_LongDecorator<T>(point, highOrderPoint);
     }
-    case HR_FLOAT: {
+    case 43: {
       Serial.printf("Creating Holding Register Float: %s\n", description);
       // Create the low and high word registers for the 32-bit float
       Modbus_Point<T>* point = new Modbus_Hreg<T>(server, address, 0, description);
diff --git a/lib/Core/Storage.h b/lib/Core/Storage.h
new file mode 100644
index 0000000..c6a0122
--- /dev/null
+++ b/lib/Core/Storage.h
@@ -0,0 +1,41 @@
+#ifndef STORAGE_H
+#define STORAGE_H
+#include <Arduino.h>
+#include <LittleFS.h> //Built-in ESP32 library for file system management
+
+class Storage {
+public:
+  /**
+   * @brief Initialice LittleFS and read configuration file.
+   * @return String with the JSON content or an empty string if the file does not exist or cannot be read.
+   */
+  static String readConfigFile() {
+    if(!LittleFS.begin(true)) {
+        Serial.println("[Storage] Error to initialize LittleFS");
+        return "";
+    }
+    if (!LittleFS.exists("/config.json")) {
+        Serial.println("[Storage] Configuration file does not exist");
+        return "";
+    }
+    File file = LittleFS.open("/config.json", "r");
+    if (!file) {
+        Serial.println("[Storage] Error opening configuration file");
+        return "";
+    }
+    String content = file.readString();
+    file.close();
+    return content;
+  }
+  static void saveConfigFile(const String& jsonConfig) {
+    File file = LittleFS.open("/config.json", "w");
+    if (!file) {
+        Serial.println("[Storage] Error opening configuration file for writing");
+        return;
+    }
+    file.print(jsonConfig);
+    file.close();
+    Serial.println("[Storage] Configuration file saved");
+  }
+};
+#endif
\ No newline at end of file
diff --git a/platformio.ini b/platformio.ini
index c45635d..8e689c6 100644
--- a/platformio.ini
+++ b/platformio.ini
@@ -8,295 +8,22 @@
 ; https://docs.platformio.org/page/projectconf.html
 
 [platformio]
-
-
-default_envs = CH_York_YVA_RTU_PHXA7 ; Select here the name of the configuration you want to download
-
-[env]
-upload_port = COM15
-
-[common_env_options]
+default_envs = esp32_generic
+;---------------------------------------------------------------------------------------------------
+[env:esp32_generic]
+platform = espressif32
+board = dfrobot_firebeetle2_esp32e
 framework = arduino
+; Change COM port based on your computer system
+upload_port = COM15
 monitor_speed = 115200
+
+build_src_filter = +<*>
+
 lib_ldf_mode = chain+
 lib_compat_mode = soft
-;---------------------------------------------------------------------------------------------------
-; TEMPLATES
-;Base configuration for RTU equipment
-[env:Base_RTU]
-platform = espressif32
-board = dfrobot_firebeetle2_esp32e
-extends = common_env_options
-build_src_filter = -<*> +<Base_RTU> ;Add the specific folder path here
-;Base configuration for TCP equipment
-[env:Base_TCP]
-platform = espressif32
-board = dfrobot_firebeetle2_esp32e
-extends = common_env_options
-build_flags = -D USE_MODBUS_IP  ;Importat  configuration, this flags is used to configure the program
-build_src_filter = -<*> +<Base_TCP> ;Add the specific folder path here
+
+build_unflags = -std=gnu++11
+build_flags = 
+    -std=gnu++17
 ;----------------------------------------------------------------------------------------------------
-[env:CRAH_HTS_PLC_TCP]
-platform = espressif32
-board = dfrobot_firebeetle2_esp32e
-extends = common_env_options
-build_flags = -D USE_MODBUS_IP
-build_src_filter = -<*> +<BMS/CRAH/CRAH_HTS_PLC_TCP>
-
-[env:CRAH_PETRA_PAHHC_600_C6_TCP]
-platform = espressif32
-board = dfrobot_firebeetle2_esp32e
-extends = common_env_options
-build_flags = -D USE_MODBUS_IP
-build_src_filter = -<*> +<BMS/CRAH/CRAH_PETRA_PAHHC_600_C6_TCP>
-
-[env:POD_MBB_Power_Meter_TCP]
-platform = espressif32
-board = dfrobot_firebeetle2_esp32e
-extends = common_env_options
-build_flags = -D USE_MODBUS_IP
-build_src_filter = -<*> +<EPMS/POD/POD_MBB_Power_Meter_TCP>
-
-[env:STS_PowerSmiths_STATYS_UL_600A_TCP]
-platform = espressif32
-board = dfrobot_firebeetle2_esp32e
-extends = common_env_options
-build_flags = -D USE_MODBUS_IP
-build_src_filter = -<*> +<EPMS/STS/STS_PowerSmiths_STATYS_UL_600A_TCP>
-
-[env:PDU_Maverick_Power_TCP]
-platform = espressif32
-board = dfrobot_firebeetle2_esp32e
-extends = common_env_options
-build_flags = -D USE_MODBUS_IP
-build_src_filter = -<*> +<EPMS/PDU/PDU_Maverick_Power_TCP>
-
-[env:MVG_SEL2440_TCP]
-platform = espressif32
-board = dfrobot_firebeetle2_esp32e
-extends = common_env_options
-build_flags = -D USE_MODBUS_IP
-build_src_filter = -<*> +<EPMS/MVG/MVG_SEL2440_TCP>
-
-[env:GEN_CAT_EMCP4_TCP]
-platform = espressif32
-board = dfrobot_firebeetle2_esp32e
-extends = common_env_options
-build_flags = -D USE_MODBUS_IP
-build_src_filter = -<*> +<EPMS/GEN/GEN_CAT_EMCP4_TCP>
-
-[env:BKR_ABB_EMax2_TCP]
-platform = espressif32
-board = dfrobot_firebeetle2_esp32e
-extends = common_env_options
-build_flags = -D USE_MODBUS_IP
-build_src_filter = -<*> +<EPMS/Breaker/BKR_ABB_EMax2_TCP>
-
-[env:CRAC_Munters_SysCooll_TCP]
-platform = espressif32
-board = dfrobot_firebeetle2_esp32e
-extends = common_env_options
-build_flags = -D USE_MODBUS_IP
-build_src_filter = -<*> +<BMS/CRAC/CRAC_Munters_SysCooll_TCP>
-
-[env:SS_Daiken_TCP]
-platform = espressif32
-board = dfrobot_firebeetle2_esp32e
-extends = common_env_options
-build_flags = -D USE_MODBUS_IP
-build_src_filter = -<*> +<BMS/Split_System/SS_Daiken_TCP>
-
-[env:Testing_RTU]
-platform = espressif32
-board = dfrobot_firebeetle2_esp32e
-extends = common_env_options
-build_src_filter = -<*> +</Testing_RTU>
-
-[env:Testing_TCP]
-platform = espressif32
-board = dfrobot_firebeetle2_esp32e
-extends = common_env_options
-build_flags = -D USE_MODBUS_IP
-build_src_filter = -<*> +</Testing_TCP>
-
-[env:CH_Daikin_AWV026B_RTU]
-platform = espressif32
-board = dfrobot_firebeetle2_esp32e
-extends = common_env_options
-build_src_filter = -<*> +<BMS/CHILLER/CH_Daikin_AWV026B_RTU>
-
-[env:CRAH_PAHHC_600_C6_TCP]
-platform = espressif32
-board = dfrobot_firebeetle2_esp32e
-extends = common_env_options
-build_flags = -D USE_MODBUS_IP
-build_src_filter = -<*> +<BMS/CRAH/CRAH_PAHHC_600_C6_TCP>
-
-[env:VFD_ABB_ACH580_RTU]
-platform = espressif32
-board = dfrobot_firebeetle2_esp32e
-extends = common_env_options
-build_src_filter = -<*> +<BMS/VFD/VFD_ABB_ACH580_RTU>
-
-[env:ATS_800_RPD]
-platform = espressif32
-board = dfrobot_firebeetle2_esp32e
-extends = common_env_options
-build_flags = -D USE_MODBUS_IP
-build_src_filter = -<*> +<EPMS/ATS/ATS_800_RPD>
-
-[env:Susol_Smart_MCCB_TCP]
-platform = espressif32
-board = dfrobot_firebeetle2_esp32e
-extends = common_env_options
-build_flags = -D USE_MODBUS_IP
-build_src_filter = -<*> +<EPMS/Breaker/Susol_Smart_MCCB_TCP>
-
-[env:BKR_ABB_XT_TCP]
-platform = espressif32
-board = dfrobot_firebeetle2_esp32e
-extends = common_env_options
-build_flags = -D USE_MODBUS_IP
-build_src_filter = -<*> +<EPMS/Breaker/BKR_ABB_XT_TCP>
-
-[env:BKR_Susol_ACB_TCP]
-platform = espressif32
-board = dfrobot_firebeetle2_esp32e
-extends = common_env_options
-build_flags = -D USE_MODBUS_IP
-build_src_filter = -<*> +<EPMS/Breaker/BKR_Susol_ACB_TCP>
-
-[env:BKR_Eaton_PXR20_25]
-platform = espressif32
-board = dfrobot_firebeetle2_esp32e
-extends = common_env_options
-build_flags = -D USE_MODBUS_IP
-build_src_filter = -<*> +<EPMS/Breaker/BKR_Eaton_PXR20_25>
-
-[env:PQM_PM8000_TCP]
-platform = espressif32
-board = dfrobot_firebeetle2_esp32e
-extends = common_env_options
-build_flags = -D USE_MODBUS_IP
-build_src_filter = -<*> +<EPMS/PQM/PQM_PM8000_TCP>
-
-[env:PQM_PM9000_TCP]
-platform = espressif32
-board = dfrobot_firebeetle2_esp32e
-extends = common_env_options
-build_flags = -D USE_MODBUS_IP
-build_src_filter = -<*> +<EPMS/PQM/PQM_PM9000_TCP>
-
-[env:ATS_Eaton_ATC900_RPD_TCP]
-platform = espressif32
-board = dfrobot_firebeetle2_esp32e
-extends = common_env_options
-build_flags = -D USE_MODBUS_IP
-build_src_filter = -<*> +<EPMS/ATS/ATS_Eaton_ATC900_RPD_TCP>
-
-[env:ATS_Woodward_DTSC200A_TCP]
-platform = espressif32
-board = dfrobot_firebeetle2_esp32e
-extends = common_env_options
-build_flags = -D USE_MODBUS_IP
-build_src_filter = -<*> +<EPMS/ATS/ATS_Woodward_DTSC200A_TCP>
-
-[env:UPS_Vertiv_APM2_TCP]
-platform = espressif32
-board = dfrobot_firebeetle2_esp32e
-extends = common_env_options
-build_flags = -D USE_MODBUS_IP
-build_src_filter = -<*> +<EPMS/UPS/UPS_Vertiv_APM2_TCP>
-
-[env:CH_York_YVAA_RTU]
-platform = espressif32
-board = dfrobot_firebeetle2_esp32e
-extends = common_env_options
-build_src_filter = -<*> +<BMS/CHILLER/CH_York_YVAA_RTU>
-
-[env:CRAH_UMAS_TCP]
-platform = espressif32
-board = dfrobot_firebeetle2_esp32e
-extends = common_env_options
-build_flags = -D USE_MODBUS_IP 
-build_src_filter = -<*> +<BMS/CRAH/CRAH_UMAS_TCP>
-
-[env:GEN_HSE]
-platform = espressif32
-board = dfrobot_firebeetle2_esp32e
-extends = common_env_options
-build_flags = -D USE_MODBUS_IP 
-build_src_filter = -<*> +<EPMS/GEN/GEN_HSE>
-
-[env:SEL_2440_MVG]
-platform = espressif32
-board = dfrobot_firebeetle2_esp32e
-extends = common_env_options
-build_flags = -D USE_MODBUS_IP 
-build_src_filter = -<*> +<Base_TCP>
-
-[env:MVG_SC_EC_M505_TCP]
-platform = espressif32
-board = dfrobot_firebeetle2_esp32e
-extends = common_env_options
-build_flags = -D USE_MODBUS_IP,
-build_src_filter = -<*> +<EPMS/MVG/MVG_SC_EC_M505_TCP>
-
-[env:GEN_CAT_GCCP_TCP]
-platform = espressif32
-board = dfrobot_firebeetle2_esp32e
-extends = common_env_options
-build_flags = -D USE_MODBUS_IP,
-build_src_filter = -<*> +<EPMS/GEN/GEN_CAT_GCCP_TCP>
-
-[env:CDU_CoolIT_Oracle_TCP]
-platform = espressif32
-board = dfrobot_firebeetle2_esp32e
-extends = common_env_options
-build_flags = -D USE_MODBUS_IP
-build_src_filter = -<*> +<BMS/CDU/CDU_CoolIT_Oracle_TCP>
-
-[env:RPP_Cortex_TCP]
-platform = espressif32
-board = dfrobot_firebeetle2_esp32e
-extends = common_env_options
-build_flags = -D USE_MODBUS_IP
-build_src_filter = -<*> +<EPMS/RPP/RPP_Cortex_TCP>
-
-[env:CH_York_YVA_RTU_PHXA7]
-platform = espressif32
-board = dfrobot_firebeetle2_esp32e
-extends = common_env_options
-build_src_filter = -<*> +<BMS/CHILLER/CH_York_YVA_RTU_PHXA7>
-
-[env:STU_UMP_STU_2_0_CAH_IDR_60_TCP_PHXA7]
-platform = espressif32
-board = dfrobot_firebeetle2_esp32e
-extends = common_env_options
-build_flags = -D USE_MODBUS_IP
-build_src_filter = -<*> +<BMS/STU/STU_UMP_STU_2_0_CAH_IDR_60_TCP_PHXA7>
-
-[env:Harmonic_Guard_RTU_PHXA7]
-platform = espressif32
-board = dfrobot_firebeetle2_esp32e
-extends = common_env_options
-build_src_filter = -<*> +<EPMS/Harmonic_Filter/Harmonic_Guard_RTU_PHXA7>
-
-[env:GEN_Kohler_KD2500_RTU_PHXA7]
-platform = espressif32
-board = dfrobot_firebeetle2_esp32e
-extends = common_env_options
-build_src_filter = -<*> +<EPMS/GEN/GEN_Kohler_KD2500_RTU_PHXA7>
-
-[env:VFD_YASKAWA_HV600_RTU_PHXA7]
-platform = espressif32
-board = dfrobot_firebeetle2_esp32e
-extends = common_env_options
-build_src_filter = -<*> +<BMS/VFD/VFD_YASKAWA_HV600_RTU_PHXA7>
-
-[env:CRAH_TxAir_BASX_TCP_PHXA7]
-platform = espressif32
-board = dfrobot_firebeetle2_esp32e
-extends = common_env_options
-build_flags = -D USE_MODBUS_IP
-build_src_filter = -<*> +<BMS/CRAH/CRAH_TxAir_BASX_TCP_PHXA7>
\ No newline at end of file
diff --git a/src/BMS/CDU/CDU_CoolIT_Oracle_TCP/README.md b/src/BMS/CDU/CDU_CoolIT_Oracle_TCP/README.md
deleted file mode 100644
index 355156f..0000000
--- a/src/BMS/CDU/CDU_CoolIT_Oracle_TCP/README.md
+++ /dev/null
@@ -1,33 +0,0 @@
-# EQUIPMENT_TYPE MANUFACTURER MODEL TCP
-
-## Brief Introduction
-Equipment specifc details that make it different from other devices
-
-## List of Equipmentt
-This cofiguration has been used for these models:
-* **Model**: 09-15-22 
-* **Model**: 09-15-23 
-* **Model**: 09-15-25 
-
-## Hardware Prerequisites
-
-The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities.
-* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html) 
-
----
-
-## States and Strategies
-Provide a brief description of what variables and strategies were used in this configuraiton
-
-### Standby State
-* **Equipment running**: set to 0
-* **Common Alarm**: set to 0
-* **SAT temperature**: set to 85
-
-### Running State
-* **Equipment running**: set to 1
-* **SAT temperature**: **Ramp Strategy** set to 65 deg setpoint
-
-### Fail State
-* **Commong Alarm**: set to 1
-* **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset
diff --git a/src/BMS/CDU/CDU_CoolIT_Oracle_TCP/State_Fail.cpp b/src/BMS/CDU/CDU_CoolIT_Oracle_TCP/State_Fail.cpp
deleted file mode 100644
index 8bc0385..0000000
--- a/src/BMS/CDU/CDU_CoolIT_Oracle_TCP/State_Fail.cpp
+++ /dev/null
@@ -1,81 +0,0 @@
-/**
- * @file State_Fail.cpp
- * @brief Implementation of the FailState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the FailState, which defines
- * the behavior of the equipment when it has entered a fault condition.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new FailState object with a list of active alarms.
- *
- * This constructor receives a list of alarm descriptions and creates strategies
- * to set the corresponding Modbus points to a value of 1, indicating an
- * active alarm. It also initializes a PID strategy for the 'CW Valve Position'
- * to maintain its state during the fault.
- * @param activeAlarms A vector of strings, where each string is the
- *                     description of a Modbus point to be set as an active alarm.
- */
-template<>
-FailState<ModbusIP>::FailState(const std::vector<std::string>& activeAlarms) {
-    // Simulate a failure: set common alarm and a specific fan alarm.
-
-    
-}
-
-/**
- * @brief Executes the fail state's logic for one update cycle.
- *
- * This method checks the "Alarm Reset" Modbus point for a command to
- * transition back to Standby, which would typically happen after a fault
- * is cleared by a user. If no transition is requested, it continues to apply
- * the failure strategies (e.g., keeping alarm bits active).
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* FailState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Fail update function");
-    
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the fail state.
- * Sets the "Alarm Common" point to 1 to indicate a general fault condition.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Fail State...");
-}
-
-/**
- * @brief Logic to execute once when exiting the fail state.
- * Clears the "Alarm Common" point to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Fail State...");
-}
\ No newline at end of file
diff --git a/src/BMS/CDU/CDU_CoolIT_Oracle_TCP/State_Running.cpp b/src/BMS/CDU/CDU_CoolIT_Oracle_TCP/State_Running.cpp
deleted file mode 100644
index ce88f62..0000000
--- a/src/BMS/CDU/CDU_CoolIT_Oracle_TCP/State_Running.cpp
+++ /dev/null
@@ -1,136 +0,0 @@
-/**
- * @file State_Running.cpp
- * @brief Implementation of the RunningState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the RunningState, which defines
- * the behavior of the equipment when it is actively running.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "Strategies/Strategy_Totalizer.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new RunningState object.
- *
- * This constructor initializes behavior strategies active during the running
- * state, such as a PID controller for the 'CW Valve Position' and totalizers
- * for the run-hours of each EC fan.
- */
-template<>
-RunningState<ModbusIP>::RunningState() {
-    addStrategy("TT01", new SingleValueStrategy(870.0F, 10.0f, 1000));
-    addStrategy("TT02", new SingleValueStrategy(880.0F, 10.0f, 1000));
-    addStrategy("TT31", new SingleValueStrategy(670.0F, 10.0f, 1000));
-    addStrategy("TT41", new SingleValueStrategy(660.0F, 10.0f, 1000));
-    addStrategy("PT01", new SingleValueStrategy(350.0F, 10.0f, 1000));
-    addStrategy("PT02", new SingleValueStrategy(380.0F, 10.0f, 1000));
-    addStrategy("PT31", new SingleValueStrategy(340.0F, 10.0f, 1000));
-    addStrategy("PT41", new SingleValueStrategy(370.0F, 10.0f, 1000));
-    addStrategy("PT32", new SingleValueStrategy(380.0F, 10.0f, 1000));
-    addStrategy("PT42", new SingleValueStrategy(350.0F, 10.0f, 1000));
-    addStrategy("PT21", new SingleValueStrategy(370.0F, 10.0f, 1000));
-    addStrategy("PT11", new SingleValueStrategy(390.0F, 10.0f, 1000));
-    addStrategy("AirTemp", new SingleValueStrategy(660.0F, 1.0f, 1000));
-    addStrategy("DP31", new SingleValueStrategy(150.0F, 10.0f, 1000));
-    addStrategy("DP41", new SingleValueStrategy(180.0F, 10.0f, 1000));
-    addStrategy("DP", new SingleValueStrategy(160.0F, 10.0f, 1000));
-    addStrategy("FL01", new SingleValueStrategy(7420.0F, 10.0f, 1000));
-    addStrategy("P31_Speed", new SingleValueStrategy(300.0F, 10.0f, 1000));
-    addStrategy("P41_Speed", new SingleValueStrategy(410.0F, 10.0f, 1000));
-    addStrategy("F1_Speed", new SingleValueStrategy(180.0F, 10.0f, 1000));
-    addStrategy("F2_Speed", new SingleValueStrategy(190.0F, 10.0f, 1000));
-    addStrategy("F3_Speed", new SingleValueStrategy(170.0F, 10.0f, 1000));
-    addStrategy("F4_Speed", new SingleValueStrategy(200.0F, 10.0f, 1000));
-    addStrategy("F5_Speed", new SingleValueStrategy(250.0F, 10.0f, 1000));
-    addStrategy("F6_Speed", new SingleValueStrategy(210.0F, 10.0f, 1000));
-    addStrategy("F7_Speed", new SingleValueStrategy(200.0F, 10.0f, 1000));
-    addStrategy("F8_Speed", new SingleValueStrategy(180.0F, 10.0f, 1000));
-    addStrategy("AirTemp", new SingleValueStrategy(680.0f, 100.0f, 5000));
-    addStrategy("Group_Flow", new SingleValueStrategy(7510.0F, 10.0f, 1000));
-    addStrategy("Group_DP", new SingleValueStrategy(200.0F, 10.0f, 1000));
-}
-
-/**
- * @brief Executes the running state's logic for one update cycle.
- *
- * This method first checks for state transition commands:
- * 1. It reads the "ON/OFF Command By BMS" point. If it's 0, it transitions to StandbyState.
- * 2. It reads the "Fault Code" point. If it's non-zero, it transitions to FailState,
- *    passing the corresponding alarm description.
- *
- * If no transition occurs, it applies the strategies defined for the running state.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* RunningState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Running update function");
-    float State_Ctrl = getPointValue(equipment, "Remote_Start"); 
-    if (State_Ctrl == 0){
-      return new StandbyState<ModbusIP>();
-    }
-
-    float TT01 = getPointValue(equipment, "TT01");
-    float TT02 = getPointValue(equipment, "TT02");
-    float TT31 = getPointValue(equipment, "TT31");
-    float TT41 = getPointValue(equipment, "TT41");
-    float PT01 = getPointValue(equipment, "PT01");
-    float PT02 = getPointValue(equipment, "PT02");
-    float PT31 = getPointValue(equipment, "PT31");
-    float PT41 = getPointValue(equipment, "PT41");
-    setPointValue(equipment, "TT01_TT02", (TT01 + TT02)/2.0f);
-    setPointValue(equipment, "TT31_TT41", (TT31 + TT41)/2.0f);
-    setPointValue(equipment, "PT01_PT02", (PT01 + PT02)/2.0f);
-    setPointValue(equipment, "PT31_PT41", (PT31 + PT41)/2.0f);
-    
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the running state.
- * Sets the "Run Status" for all EC fans to 1 to indicate they are active.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Running State...");
-    // You could also update a Modbus register to show the "standby" state
-    setPointValue(equipment, "Status", 1);
-}
-
-/**
- * @brief Logic to execute once when exiting the running state.
- * Sets the "Run Status" for all EC fans to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Running State...");
-   
-}
\ No newline at end of file
diff --git a/src/BMS/CDU/CDU_CoolIT_Oracle_TCP/State_Standby.cpp b/src/BMS/CDU/CDU_CoolIT_Oracle_TCP/State_Standby.cpp
deleted file mode 100644
index c525d95..0000000
--- a/src/BMS/CDU/CDU_CoolIT_Oracle_TCP/State_Standby.cpp
+++ /dev/null
@@ -1,130 +0,0 @@
-/**
- * @file State_Standby.cpp
- * @brief Implementation of the StandbyState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the StandbyState, which defines
- * the behavior of the equipment when it is in an idle or standby mode.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-/**
- * @brief Constructs a new StandbyState object.
- *
- * In this state, the equipment is idle. This constructor initializes strategies
- * to bring the system to a safe, idle condition. It sets a stable value for
- * the SAT reading and creates ramp strategies to bring the CW valve and all
- * EC fan speeds down to zero.
- */
-template<>
-StandbyState<ModbusIP>::StandbyState() {
-    // You can add initialization code here if needed
-    addStrategy("TT01", new SingleValueStrategy(870.0F, 10.0f, 1000));
-    addStrategy("TT02", new SingleValueStrategy(870.0F, 10.0f, 1000));
-    addStrategy("TT31", new SingleValueStrategy(870.0F, 10.0f, 1000));
-    addStrategy("TT41", new SingleValueStrategy(870.0F, 10.0f, 1000));
-    addStrategy("PT01", new SingleValueStrategy(1.0F, 1.0f, 1000));
-    addStrategy("PT02", new SingleValueStrategy(1.0F, 1.0f, 1000));
-    addStrategy("PT31", new SingleValueStrategy(1.0F, 1.0f, 1000));
-    addStrategy("PT41", new SingleValueStrategy(1.0F, 1.0f, 1000));
-    addStrategy("PT32", new SingleValueStrategy(1.0F, 1.0f, 1000));
-    addStrategy("PT42", new SingleValueStrategy(1.0F, 1.0f, 1000));
-    addStrategy("PT21", new SingleValueStrategy(1.0F, 1.0f, 1000));
-    addStrategy("PT11", new SingleValueStrategy(1.0F, 1.0f, 1000));
-    addStrategy("DP31", new SingleValueStrategy(1.0F, 1.0f, 1000));
-    addStrategy("DP41", new SingleValueStrategy(1.0F, 1.0f, 1000));
-    addStrategy("DP", new SingleValueStrategy(1.0F, 1.0f, 1000));
-    addStrategy("FL01", new SingleValueStrategy(1.0F, 1.0f, 1000));
-    addStrategy("AirTemp", new SingleValueStrategy(870.0F, 10.0f, 1000));
-    addStrategy("P31_Speed", new SingleValueStrategy(1.0F, 1.0f, 1000));
-    addStrategy("P41_Speed", new SingleValueStrategy(1.0F, 1.0f, 1000));
-    addStrategy("F1_Speed", new SingleValueStrategy(1.0F, 1.0f, 1000));
-    addStrategy("F2_Speed", new SingleValueStrategy(1.0F, 1.0f, 1000));
-    addStrategy("F3_Speed", new SingleValueStrategy(1.0F, 1.0f, 1000));
-    addStrategy("F4_Speed", new SingleValueStrategy(1.0F, 1.0f, 1000));
-    addStrategy("F5_Speed", new SingleValueStrategy(1.0F, 1.0f, 1000));
-    addStrategy("F6_Speed", new SingleValueStrategy(1.0F, 1.0f, 1000));
-    addStrategy("F7_Speed", new SingleValueStrategy(1.0F, 1.0f, 1000));
-    addStrategy("F8_Speed", new SingleValueStrategy(1.0F, 1.0f, 1000));
-    addStrategy("Group_Flow", new SingleValueStrategy(1.0F, 1.0f, 1000));
-    addStrategy("Group_DP", new SingleValueStrategy(1.0F, 1.0f, 1000));
-    
-
-}
-
-/**
- * @brief Executes the standby state's logic for one update cycle.
- *
- * This method applies the strategies defined for the standby state (e.g.,
- * ramping values to zero).
- *
- * @warning This method currently does not check for a command to transition to the
- *          Running state. This logic needs to be added to allow the unit to start.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* StandbyState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Standby update function");
-    float State_Ctrl = getPointValue(equipment, "Remote_Start"); 
-    if (State_Ctrl == 1){
-      return new RunningState<ModbusIP>();
-    }
-    float TT01 = getPointValue(equipment, "TT01");
-    float TT02 = getPointValue(equipment, "TT02");
-    float TT31 = getPointValue(equipment, "TT31");
-    float TT41 = getPointValue(equipment, "TT41");
-    float PT01 = getPointValue(equipment, "PT01");
-    float PT02 = getPointValue(equipment, "PT02");
-    float PT31 = getPointValue(equipment, "PT31");
-    float PT41 = getPointValue(equipment, "PT41");
-    setPointValue(equipment, "TT01_TT02", (TT01 + TT02)/2.0f);
-    setPointValue(equipment, "TT31_TT41", (TT31 + TT41)/2.0f);
-    setPointValue(equipment, "PT01_PT02", (PT01 + PT02)/2.0f);
-    setPointValue(equipment, "PT31_PT41", (PT31 + PT41)/2.0f);
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the standby state.
- * This method performs cleanup by setting all alarm points and all EC fan
- * run status points to 0.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Standby State...");
-    setPointValue(equipment, "Status", 0);
-}
-
-/**
- * @brief Logic to execute once when exiting the standby state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Standby State...");
-}
\ No newline at end of file
diff --git a/src/BMS/CDU/CDU_CoolIT_Oracle_TCP/config.h b/src/BMS/CDU/CDU_CoolIT_Oracle_TCP/config.h
deleted file mode 100644
index fbd0547..0000000
--- a/src/BMS/CDU/CDU_CoolIT_Oracle_TCP/config.h
+++ /dev/null
@@ -1,129 +0,0 @@
-/**
- * @file config.h
- * @brief Main configuration file for the CRAH Unit (TCP) emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * This file contains two important configurations: WiFi network parameters
- * and the Modbus register map for the device.
- */
-
-#ifndef CONFIG_H
-#define CONFIG_H
-
-#include "core.h"
-#include "Equipment/Equipment.h"
-
-#if defined(USE_MODBUS_IP)
-/**
-   * @defgroup ModbusTCPConfig Modbus IP Configuration
-   * @brief Parameters for Modbus TCP communication.
-   * @{
-   */
-  #include <ModbusIP_ESP8266.h>
-  const char *ssid = "Oracle_SA";       /**< @brief The SSID of the WiFi network. */
-  const char *password = "Prime!123";   /**< @brief The password for the WiFi network. */
-  IPAddress local_IP(172, 17, 38, 23);       /**< @brief The static IP address for the device. */
-  IPAddress gateway(172, 17, 38, 1);          /**< @brief The gateway IP address. */
-  IPAddress subnet(255, 255, 255, 0);         /**< @brief The subnet mask. */
-  
-  ModbusIP mb;
-#else
-  /**
-   * @defgroup ModbusRTUConfig Modbus RTU Configuration
-   * @brief Parameters for serial Modbus RTU communication.
-   * @{
-   */
-  #include <ModbusRTU.h>
-  const int BAUDRATE = 19200;   /**< @brief The serial communication speed in bits per second. */
-  const int RX_PIN = 17;        /**< @brief The GPIO pin used for receiving data (RX). */
-  const int TX_PIN = 16;        /**< @brief The GPIO pin used for transmitting data (TX). */
-  const int RST_PIN = 4;        /**< @brief The GPIO pin connected to the RS485 driver's DE/RE pins for direction control. */
-  const int MODBUS_ID = 1;      /**< @brief The unique slave ID for this device on the Modbus bus. */
-  /** @} */
-
-  /** @brief Global instance of the Modbus RTU server. */
-  ModbusRTU mb;
-#endif
-
-
-
-/**
- * @defgroup ModbusMapConfig Modbus Map Configuration
- * @brief Defines the Modbus register map and related parameters for the emulator.
- * @{
- */
-/**
- * @brief The Modbus map for the Equipment device.
- * This array defines all the Modbus points available on the emulated device.
- * The `description` field is crucial as it's used to look up points within the application logic.
- */
-modbusMap mb_map[] =
-{   
-  {HR,        0,    0,   "Status"},
-  {HR,        1,    0,   "Group"},
-  {HR,        2,    0,   "TT01"},
-  {HR,        3,    0,   "TT02"},
-  {HR,        4,    0,   "TT31"},
-  {HR,        5,    0,   "TT41"},
-  {HR,        6,    0,   "PT01"},
-  {HR,        7,    0,   "PT02"},
-  {HR,        8,    0,   "PT31"},
-  {HR,        9,    0,   "PT41"},
-  {HR,        10,   0,   "PT32"},
-  {HR,        11,   0,   "PT42"},
-  {HR,        12,   0,   "PT21"},
-  {HR,        13,   0,   "PT11"},
-  {HR,        14,   0,   "TT01_TT02"},
-  {HR,        15,   0,   "TT31_TT41"},
-  {HR,        16,   0,   "PT01_PT02"},
-  {HR,        17,   0,   "PT31_PT41"},
-  {HR,        18,   0,   "DP31"},
-  {HR,        19,   0,   "DP41"},
-  {HR,        20,   0,   "DP"},
-  {HR,        21,   0,   "FL01"},  
-  {HR,        22,   0,   "P31_Speed"},
-  {HR,        23,   0,   "P41_Speed"},
-  {HR,        24,   0,   "F1_Speed"},
-  {HR,        25,   0,   "F2_Speed"},
-  {HR,        26,   0,   "F3_Speed"},
-  {HR,        27,   0,   "F4_Speed"},
-  {HR,        28,   0,   "F5_Speed"},
-  {HR,        29,   0,   "F6_Speed"},
-  {HR,        30,   0,   "F7_Speed"},
-  {HR,        31,   0,   "F8_Speed"},
-  {HR,        33,   0,   "AirTemp"},
-  {HR_FLOAT,  40,   0,   "Group_Flow"},
-  {HR_FLOAT,  42,   0,   "Group_DP"},
-  {HR,        44,   0,   "Version"},
-  {HR,        200,  0,   "Temp_SP"},
-  {HR,        201,  0,   "DP_SP"},
-  {HR,        202,  0,   "Flow_SP"},
-
-  {COIL,      0,    0,   "Alarm"},
-  {COIL,      1,    0,   "Alarm_Ack"},
-  {COIL,      5,    0,   "OvrPressure"},
-  {COIL,      14,   0,   "Ntwk_Fault"},
-  {COIL,      15,   0,   "Unit_Available"},
-  {COIL,      33,   0,   "OvrTemp"},
-  {COIL,      86,   0,   "LD01"},
-  {COIL,      87,   0,   "StpBtn"},
-  {COIL,      131,  0,   "Critical_Fault"},
-  {COIL,      132,  0,   "Power_Fault"},
-  {COIL,      133,  0,   "PLC_Fault"},
-  {COIL,      200,  0,   "Remote_Start"},
-  
-}; 
-//Size of modbus map used in FOR cycles, automatically calculated.
-
-/**
- * @brief The total number of entries in the `mb_map` array.
- * This is calculated at compile time and used for iterating over the map.
- */
-const int map_size = sizeof(mb_map) / sizeof(mb_map[0]);
-
-/** @brief The main loop update interval in milliseconds. */
-int interval = 250; 
-/** @} */ // End of ModbusMapConfig group
-
-#endif // CONFIG_H
diff --git a/src/BMS/CDU/CDU_CoolIT_Oracle_TCP/main.cpp b/src/BMS/CDU/CDU_CoolIT_Oracle_TCP/main.cpp
deleted file mode 100644
index 286a98c..0000000
--- a/src/BMS/CDU/CDU_CoolIT_Oracle_TCP/main.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-/**
- * @file main.cpp
- * @brief Main execution program for the CRAH Unit (TCP) Emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * @details This file contains the main execution program for an Arduino-based emulator of a CRAH unit. 
- * The program uses a Wi-Fi connection to communicate via the Modbus IP protocol.
- *
- * The setup() function initializes the following:
- * - Serial communication for debugging.
- * - Wi-Fi connection using credentials from config.h.
- * - A Modbus TCP server.
- * - Modbus points (Coils, Holding Registers, etc.) based on a predefined map in config.h.
- *
- * The loop() function continuously:
- * - Services the Modbus TCP server to handle incoming requests.
- * - Periodically calls the main update loop for the emulated equipment, which
- *   manages state transitions and behavior strategies.
- *
- * @see config.h for Wi-Fi and Modbus configuration.
- * @see Equipment.h for the main equipment logic.
- * @see State.h for different equipment states.
- * @see Strategies/Strategy_Behavior.h for value generation strategies.
- * @see Modbus_Point.h for the base class for all Modbus points.
- */
-//=================================================================================================================================
-//Libraries and declaration of variables.
-#include <WiFi.h>
-#include "config.h"
-#include "ModbusPoints/Modbus_PointFactory.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-//=================================================================================================================================
-/** 
- * @brief Initializes the application.
- * @details This function runs once at startup. It configures the serial communication, 
- * Wi-Fi, and the Modbus server. It also creates and initializes all the Modbus points 
- * based on the `mb_map` array in `config.h`.
- */
-void setup() {
-  Serial.begin(115200);                       //Serial comm start
-  WiFi.config(local_IP, gateway, subnet);     // Wifi service start
-  WiFi.begin(ssid, password);
-  while (WiFi.status() != WL_CONNECTED) {
-    delay(1000);
-    Serial.print(".");
-  }
-  Serial.println("Connected!!");
-  mb.server();                                //Modbus server start
-  Serial.println("Server Created");
-  Serial.println(map_size);
-  for(int i = 0; i < map_size; i++){
-    Modbus_Point<ModbusIP>* point = createModbus_Point(&mb, mb_map[i].category, mb_map[i].address, mb_map[i].value, mb_map[i].description);
-    if (point) {
-      point->addToModbusServer();
-      EquipmentInstance.addModbus_Point(mb_map[i].description, point);
-    }
-  }
-  Serial.println("All modbus Points created");
-  Serial.println("Setup function ended");
-}
-//=================================================================================================================================
-/** 
- * @brief The main application loop.
- * @details This function runs repeatedly after setup() has completed. It performs two main actions:
- * 1. It continuously services the Modbus server by calling `mb.task()` to handle
- *    incoming requests from a Modbus master.
- * 2. At a fixed interval (defined in `config.h`), it calls `EquipmentInstance.update()`
- *    to run the emulator's internal state machine and behavior logic.
- */
-void loop() {
-  mb.task();
-  unsigned long currentMillis = millis();
-  if (currentMillis - previousMillis >= interval) {
-    previousMillis = currentMillis;
-    unsigned long startTime = millis();
-    EquipmentInstance.update();
-    unsigned long endTime = millis();
-    unsigned long elapsedTime = endTime - startTime;
-    Serial.printf("Control Execution time: %d ms\n", elapsedTime);
-  } 
-}
diff --git a/src/BMS/CHILLER/CH_Daikin_AWV026B_RTU/README.md b/src/BMS/CHILLER/CH_Daikin_AWV026B_RTU/README.md
deleted file mode 100644
index 9d48406..0000000
--- a/src/BMS/CHILLER/CH_Daikin_AWV026B_RTU/README.md
+++ /dev/null
@@ -1,45 +0,0 @@
-# Chiller Daikin AWV026B RTU
-
-## Brief Introduction
-Equipment specifc details that make it different from other devices
-
-## List of Equipmentt
-This cofiguration has been used for these models:
-* **AWV026B**: 09-15-25 
-
-## Hardware Prerequisites
-
-The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities and at least one hardware serial port for RS485 communication.
-
-* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html) 
-* **RS485 Transceiver**: [RS485 Shield for Arduino.](https://www.dfrobot.com/product-1024.html)
-
----
-
-## States and Strategies
-Provide a brief description of what variables and strategies were used in this configuration
-
-### Standby State
-* **Comp1 Percent RLA**: **Ramp Strategy** set to 0.
-* **Comp2 Percent RLA**: **Ramp Strategy** set to 0.
-* **Chiller Enable SP**: Used to change to Running State (1).
-* **Outdoor Air Temp**: Read value to select between Ice or Cool mode, fixed 50 deg limit.
-* **Run Enabled**: set to 0 on enter state function. 
-
-### Running State
-* **Comp1 Percent RLA**: **Ramp Strategy** set to 0, this setpoint will change on update.
-* **Comp2 Percent RLA**: **Ramp Strategy** set to 0, this setpoint will change on update.
-* **Actual Capacity**: **PID Strategy** Emulate actual speed control based on **Supply Temp**, this strategy uses **Active SP** as setpoint, this is modified based on outdoor temp, if it's below 50 it uses Ice setpoint, otherwise it uses Cool setpoint.
-* **Chiller Enable SP**: Used to change to Running State (0).
-
-**Active Capacity Limit**: to set the max capacity of the motors.
-
-* **Comp1 Percent RLA**: **Ramp Strategy** setpoint based on actual capacity, if its below 50%, the only compressor 1 goes from 0 to limit. If capacity is above 50% then load is divided between both compressors. 
-* **Comp2 Percent RLA**: **Ramp Strategy** setpoint based on actual capacity, if its below 50%, only compressor 1 runs, compressor 2 will maintain off (0 setpoint), if capacity is above 50% then load is divided between both compressors. 
-* **Outddor Air Temp** constant reading of this value to change the setpoint from ice to cool.
-
-* **Run Enabled**: Set to 1 on enter state.
-
-
-### Fail State
-
diff --git a/src/BMS/CHILLER/CH_Daikin_AWV026B_RTU/State_Fail.cpp b/src/BMS/CHILLER/CH_Daikin_AWV026B_RTU/State_Fail.cpp
deleted file mode 100644
index 90e7258..0000000
--- a/src/BMS/CHILLER/CH_Daikin_AWV026B_RTU/State_Fail.cpp
+++ /dev/null
@@ -1,88 +0,0 @@
-/**
- * @file State_Fail.cpp
- * @brief Implementation of the FailState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the FailState, which defines
- * the behavior of the equipment when it has entered a fault condition.
- */
-#include "States/State_Standby.h"
-#include "States/State_Fail.h"
-#include "ModbusPoints/Modbus_Point.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_PID.h"
-
-#include <vector>
-#include <string>
-
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new FailState object.
- *
- * This constructor receives a list of alarm descriptions and creates strategies
- * to set the corresponding Modbus points to a value of 1, indicating an
- * active alarm. It also initializes a PID strategy for the valve position.
- */
-template<>
-FailState<ModbusRTU>::FailState(const std::vector<std::string>& activeAlarms) {
-    // Simulate a failure: set common alarm and a specific fan alarm.
-
-    for (const auto& alarmName : activeAlarms){
-        addStrategy(alarmName, new SingleValueStrategy(1.0f, 0.0f, 1000));
-    }
-    addStrategy("CW Valve Position", new PIDStrategy("RAT Setpoint", 1000, "RAT"));
-}
-
-/**
- * @brief Executes the fail state's logic for one update cycle.
- *
- * This method checks the "Clear Alm" Modbus point for a command to transition
- * back to Standby, which would typically happen after a fault is cleared by a
- * user. If no transition is requested, it continues to apply the failure strategies.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusRTU>* FailState<ModbusRTU>::update(Equipment<ModbusRTU>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Fail update function");
-    Modbus_Point<ModbusRTU>* clearAlm = equipment->getModbus_Point("Clear Alarms");
-    int nextStateId = clearAlm ? clearAlm->getValue() : 0;
-    if (nextStateId == 1){
-        return new StandbyState<ModbusRTU>();
-    }
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the fail state. Sets the main alarm bit.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusRTU>::enterState(Equipment<ModbusRTU>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Fail State...");
-    Modbus_Point<ModbusRTU>* alarm_common = equipment->getModbus_Point("Alarm Common");
-    alarm_common->setValue(1);
-}
-
-/**
- * @brief Logic to execute once when exiting the fail state. Clears the main alarm bit.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusRTU>::exitState(Equipment<ModbusRTU>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Fail State...");
-    Modbus_Point<ModbusRTU>* alarm_common = equipment->getModbus_Point("Alarm Common");
-    alarm_common->setValue(0);
-}
\ No newline at end of file
diff --git a/src/BMS/CHILLER/CH_Daikin_AWV026B_RTU/State_Running.cpp b/src/BMS/CHILLER/CH_Daikin_AWV026B_RTU/State_Running.cpp
deleted file mode 100644
index e6a1941..0000000
--- a/src/BMS/CHILLER/CH_Daikin_AWV026B_RTU/State_Running.cpp
+++ /dev/null
@@ -1,159 +0,0 @@
-/**
- * @file State_Running.cpp
- * @brief Implementation of the RunningState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the RunningState, which defines
- * the behavior of the equipment when it is actively running.
- */
-
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "Strategies/Strategy_Behavior.h"
-#include "Strategies/Strategy_PID.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Totalizer.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Equipment/Equipment.h"
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-
-#include <vector>
-#include <string>
-
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new RunningState object.
- *
- * This constructor initializes behavior strategies active during the running
- * state, such as a PID controller for the 'CW Valve Position' and totalizers
- * for the run-hours of each EC fan.
- */
-template<>
-RunningState<ModbusRTU>::RunningState() {
-    addStrategy("Actual Capacity", new PIDStrategy("Chiller Local Setpoint", 1000, "PICs Supply Temp"));
-    addStrategy("C1 Comp 1 Motor Percent (RLA)", new RampStrategy(0.0f, 5.0f, 1000));
-    addStrategy("C2 Comp 1 Motor Percent (RLA)", new RampStrategy(0.0f, 5.0f, 1000));
-    addStrategy("C3 Comp 1 Motor Percent (RLA)", new RampStrategy(0.0f, 5.0f, 1000));
-    addStrategy("PICs Return Temp", new SingleValueStrategy(85,3.0f, 1000));
-}
-
-/**
- * @brief Executes the running state's logic for one update cycle.
- *
- * This method first checks for state transition commands:
- * 1. It reads the "ON/OFF Command By BMS" point. If it's 0, it transitions to StandbyState.
- * 2. It reads the "Fault Code" point. If it's non-zero, it transitions to FailState,
- *    passing the corresponding alarm description.
- *
- * If no transition occurs, it applies the strategies defined for the running state.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusRTU>* RunningState<ModbusRTU>::update(Equipment<ModbusRTU>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Running update function");
-    int CH_Enable_SP = getPointValue(equipment, "Chiller Enable SP");
-    if (CH_Enable_SP == 0){
-        return new StandbyState<ModbusRTU>();
-    }
-
-    // Declare currentSP outside the switch so it's accessible later.
-    float highCapacityLimit = getPointValue(equipment, "Active Capacity Limit");
-    Strategy_Behavior* PID_Strat = getStrategy("Actual Capacity");
-    static_cast<PIDStrategy*>(PID_Strat)->setLimits(0.0f, highCapacityLimit);
-    float currentSP = 50.0f; // Default value
-    int currentMode = getPointValue(equipment, "Chiller Mode Output");
-    // Determine the correct setpoint based on the current operating mode.
-    switch(currentMode){
-        case 1:
-            currentSP = getPointValue(equipment, "Ice Setpoint");
-            currentSP = currentSP - 20;
-            break; // Added break to prevent fall-through
-        case 2:
-            currentSP = getPointValue(equipment, "Cooling Active Setpoint");
-            currentSP = currentSP + 20;
-            break; // Added break
-        default:
-            // The default value is already set.
-            break;
-    }
-    Strategy_Behavior* ramp_strategy1 = getStrategy("C1 Comp 1 Motor Percent (RLA)");
-    Strategy_Behavior* ramp_strategy2 = getStrategy("C2 Comp 1 Motor Percent (RLA)");
-    Strategy_Behavior* ramp_strategy3 = getStrategy("C3 Comp 1 Motor Percent (RLA)");
-    int actualCapacity = getPointValue(equipment, "Actual Capacity");
-    if (actualCapacity < 50){
-        actualCapacity = actualCapacity * 2;
-        if (actualCapacity > 100) actualCapacity = 100;
-        static_cast<RampStrategy*>(ramp_strategy1)->setTarget(actualCapacity);
-        static_cast<RampStrategy*>(ramp_strategy2)->setTarget(0);
-        static_cast<RampStrategy*>(ramp_strategy3)->setTarget(0);
-    } else {
-        if (actualCapacity > 100) actualCapacity = 100;
-        static_cast<RampStrategy*>(ramp_strategy1)->setTarget(actualCapacity);
-        int actualCapacity2 = (actualCapacity - 50)*4;
-        if (actualCapacity2 > 100) actualCapacity2 = 100;
-        static_cast<RampStrategy*>(ramp_strategy2)->setTarget(actualCapacity2);
-    }
-    
-    // 1. Get the strategy by its name.
-    Strategy_Behavior* strategy = getStrategy("Actual Capacity");
-    // 2. Check if the strategy exists and is a PID type.
-    if (strategy && strategy->isPID()) {
-        // 3. Cast it to a PIDStrategy pointer and call setSetpoint.
-        static_cast<PIDStrategy*>(strategy)->setSetpoint(currentSP);
-    }
-    
-    float OutdoorTemp = getPointValue(equipment, "Ambient Temperature");
-    Serial.printf("Outdoor Temp: %f\n", OutdoorTemp);
-    if (OutdoorTemp >50.0f) {
-        setPointValue(equipment, "Chiller Mode SP", 1.0f);
-        setPointValue(equipment, "Chiller Mode Output", 1.0f);
-    }else {
-        setPointValue(equipment, "Chiller Mode SP", 2.0f);
-        setPointValue(equipment, "Chiller Mode Output", 2.0f);
-    }
-    
-    float SupplyTemp = getPointValue(equipment, "PICs Supply Temp");
-    setPointValue(equipment, "PICs Return Temp", SupplyTemp + 14.0f);
-    
-    setPointValue(equipment, "Chiller Local Setpoint", currentSP);
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the running state.
- * Sets the "Chiller Sts" point to indicate the unit is running.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusRTU>::enterState(Equipment<ModbusRTU>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Running State...");
-    // You could also update a Modbus register to show the "standby" state
-    setPointValue(equipment, "Run Enable", 1);
-    setPointValue(equipment, "Flow Switch", 1);
-    
-}
-
-/**
- * @brief Logic to execute once when exiting the running state.
- * Sets the "Chiller Sts" point to indicate the unit is no longer running.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusRTU>::exitState(Equipment<ModbusRTU>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Running State...");
-}
\ No newline at end of file
diff --git a/src/BMS/CHILLER/CH_Daikin_AWV026B_RTU/State_Standby.cpp b/src/BMS/CHILLER/CH_Daikin_AWV026B_RTU/State_Standby.cpp
deleted file mode 100644
index 59fdd52..0000000
--- a/src/BMS/CHILLER/CH_Daikin_AWV026B_RTU/State_Standby.cpp
+++ /dev/null
@@ -1,92 +0,0 @@
-/**
- * @file State_Standby.cpp
- * @brief Implementation of the StandbyState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the StandbyState, which defines
- * the behavior of the equipment when it is in an idle or standby mode.
- */
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_SingleValue.h"
-
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new StandbyState object.
- *
- * In this state, the equipment is idle. This constructor initializes several
- * strategies to generate random values for various status points, simulating
- * a live but non-operational unit.
- */
-template<>
-StandbyState<ModbusRTU>::StandbyState() {
-  addStrategy("C1 Comp 1 Motor Percent (RLA)", new RampStrategy(0,5,1000));
-  addStrategy("C2 Comp 1 Motor Percent (RLA)", new RampStrategy(0,5,1000));
-  addStrategy("C3 Comp 1 Motor Percent (RLA)", new RampStrategy(0,5,1000));
-  addStrategy("PICs Return Temp", new SingleValueStrategy(85,3.0f, 1000));
-}
-
-/**
- * @brief Executes the standby state's logic for one update cycle.
- *
- * This method checks the "Chiller On-Off" Modbus point for a command to
- * transition to the Running state. If no transition is requested, it applies
- * the strategies defined for the standby state.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusRTU>* StandbyState<ModbusRTU>::update(Equipment<ModbusRTU>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Standby update function");
-    int CH_Enable_SP = getPointValue(equipment, "Chiller Enable SP");
-    if (CH_Enable_SP == 1){
-        return new RunningState<ModbusRTU>();
-    }
-    float OutdoorTemp = getPointValue(equipment, "Ambient Temperature");
-    Serial.printf("Outdoor Temp: %f\n", OutdoorTemp);
-    if (OutdoorTemp >50.0f) {
-        setPointValue(equipment, "Chiller Mode SP", 1);
-    }else {
-        setPointValue(equipment, "Chiller Mode SP", 2);
-    }
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the standby state.
- * Sets the "Chiller Sts" point to indicate the unit is not running.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusRTU>::enterState(Equipment<ModbusRTU>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Standby State...");
-    setPointValue(equipment, "Run Enable", 0);
-    setPointValue(equipment, "Flow Switch", 0);
-}
-
-/**
- * @brief Logic to execute once when exiting the standby state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusRTU>::exitState(Equipment<ModbusRTU>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Standby State...");
-}
\ No newline at end of file
diff --git a/src/BMS/CHILLER/CH_Daikin_AWV026B_RTU/config.h b/src/BMS/CHILLER/CH_Daikin_AWV026B_RTU/config.h
deleted file mode 100644
index 7abae6f..0000000
--- a/src/BMS/CHILLER/CH_Daikin_AWV026B_RTU/config.h
+++ /dev/null
@@ -1,116 +0,0 @@
-/**
- * @file config.h
- * @brief Main configuration file for the Daikin Chiller (RTU) emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * This file contains important configurations for the Modbus RTU communication
- * and the specific register map for the emulated device.
- */
-
-#ifndef CONFIG_H
-#define CONFIG_H
-#include <ModbusRTU.h>
-#include "core.h"
-#include "Equipment/Equipment.h"
-
-
-#if defined(USE_MODBUS_IP)
-/**
-   * @defgroup ModbusTCPConfig Modbus IP Configuration
-   * @brief Parameters for Modbus TCP communication.
-   * @{
-   */
-  #include <ModbusIP_ESP8266.h>
-  const char *ssid = "QTS_CDR_Arduino";       /**< @brief The SSID of the WiFi network. */
-  const char *password = "123abc456";   /**< @brief The password for the WiFi network. */
-  IPAddress local_IP(172, 17, 33, 78);       /**< @brief The static IP address for the device. */
-  IPAddress gateway(192, 17, 33, 1);          /**< @brief The gateway IP address. */
-  IPAddress subnet(255, 255, 255, 0);         /**< @brief The subnet mask. */
-  
-  ModbusIP mb;
-#else
-  /**
-   * @defgroup ModbusRTUConfig Modbus RTU Configuration
-   * @brief Parameters for serial Modbus RTU communication.
-   * @{
-   */
-  #include <ModbusRTU.h>
-  const int BAUDRATE = 19200;   /**< @brief The serial communication speed in bits per second. */
-  const int RX_PIN = 17;        /**< @brief The GPIO pin used for receiving data (RX). */
-  const int TX_PIN = 16;        /**< @brief The GPIO pin used for transmitting data (TX). */
-  const int RST_PIN = 4;        /**< @brief The GPIO pin connected to the RS485 driver's DE/RE pins for direction control. */
-  const int MODBUS_ID = 1;      /**< @brief The unique slave ID for this device on the Modbus bus. */
-  /** @} */
-
-  /** @brief Global instance of the Modbus RTU server. */
-  ModbusRTU mb;
-#endif
-
-/**
- * @brief The Modbus map for the Equipment device.
- * This array defines all the Modbus points available on the emulated device.
- * The `description` field is crucial as it's used to look up points within the application logic.
- */
-modbusMap mb_map[] =
-{   
-  {HR_FLOAT,  8100, 0,  "PICs Supply Temp"},  //Internal to control from Modscan
-  {COIL,      8102, 0,  "PICs Chiller Enable"},
-  {HR_FLOAT,  8104, 0,  "PICs Chiller Flow"}, 
-  {HR_FLOAT,  8106, 0,  "PICs Return Temp"},  
-  {HR,        3,    0,  "Run Enable"},
-  {HR,        9,    0,  "Chiller Enable SP"},
-  {HR,        10,   0,  "Clear Alarms"},
-  {HR,        11,   0,  "Chiller Mode Output"},
-  {HR_10x,    12,   0,  "Chiller Local Setpoint"},
-  {HR_10x,    13,   0,  "Actual Capacity"},
-  {HR_10x,    14,   0,  "Active Capacity Limit"},                          
-  {HR_10x,    16,   0,  "System Chill Water In Temp"},                   
-  {HR_10x,    17,   0,  "System Chill Water Out Temp"},                             
-  {HR_10x,    24,   0,  "Ambient Temperature"},                
-  {HR,        27,   0,  "Chiller Total Power"},
-  {HR,        34,   0,  "Chiller Mode SP"},                          
-  {HR_10x,    35,   0,  "Cooling Active Setpoint"},
-  {HR_10x,    36,   0,  "Ice Setpoint"},
-  {HR_10x,    39,   0,  "C1 Cond Refrig Pres"},                      
-  {HR_10x,    41,   0,  "C1 Evap Refrig Pres"},                          
-  {HR_10x,    43,   0,  "C2 Cond Refrig Pres"},                 
-  {HR_10x,    45,   0,  "C2 Evap Refrig Pres"},                            
-  {HR_10x,    47,   0,  "C3 Cond Refrig Pres"},                    
-  {HR_10x,    49,   0,  "C3 Evap Refrig Pres"},                        
-  {HR_10x,    51,   0,  "C4 Cond Refrig Pres"},                        
-  {HR_10x,    53,   0,  "C4 Evap Refrig Pres"},                 
-  {HR_10x,    63,   0,  "C1 Comp Suction Refrig Pres"},                         
-  {HR_10x,    66,   0,  "C1 Comp 1 Discharge Refrig Pres"},         
-  {HR,        69,   0,  "C1 Comp 1 Motor Percent (RLA)"},
-  {HR,        70,   0,  "C1 Comp Current"},                           
-  {HR,        72,   0,  "C1 Comp 1 Power"},
-  {HR_10x,    76,   0,  "C1 Comp 2 Suction Refrig Pres"},  
-  {HR_10x,    79,   0,  "C1 Comp 2 Discharge Refrig Pres"},         
-  {HR,        108,  0,  "C2 Comp 1 Current"},                       
-  {HR,        109,  0,  "C2 Comp 1 Current"}, 
-  {HR,        111,  0,  "C2 Comp 1 Power"},                        
-  {HR,        147,  0,  "C3 Comp 1 Motor Percent (RLA)"},                    
-  {HR,        148,  0,  "C3 Comp 1 Current"},                    
-  {HR,        150,  0,  "C3 Comp 1 Power"},                      
-  {HR,        592,  0,  "Alarm Freeze Protection Evap 1"},                     
-  {HR,        593,  0,  "Alarm Freeze Protection Evap 2"},                     
-  {HR_10x,    1731, 0,  "C4 Comp 1 Oil Pres"},                       
-  {HR_10x,    1770, 0,  "C3 Comp 1 Oil Pres"},                  
-  {HR_10x,    1809, 0,  "C2 Comp 1 Oil Pres"},                
-  {HR_10x,    1849, 0,  "C1 Comp 1 Oil Pres"},
-  
-};
-//Size of modbus map used in FOR cycles, automatically calculated.
-/**
- * @brief The total number of entries in the `mb_map` array.
- * This is calculated at compile time and used for iterating over the map.
- */
-const int map_size = sizeof(mb_map) / sizeof(mb_map[0]);
-
-/**
- * @brief The main loop update interval in milliseconds.
- */
-int interval = 250; 
-
-#endif // CONFIG_H
diff --git a/src/BMS/CHILLER/CH_Daikin_AWV026B_RTU/main.cpp b/src/BMS/CHILLER/CH_Daikin_AWV026B_RTU/main.cpp
deleted file mode 100644
index 5dbc9f1..0000000
--- a/src/BMS/CHILLER/CH_Daikin_AWV026B_RTU/main.cpp
+++ /dev/null
@@ -1,78 +0,0 @@
-/**
- * @file main.cpp
- * @brief Main execution program for the Daikin Chiller (RTU) Emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * @details This file contains the main execution program for an Arduino-based
- * emulator of a Daikin Chiller unit. The program communicates via the
- * Modbus RTU protocol over a serial connection.
- *
- * The setup() function initializes the following:
- * - Serial communication for debugging.
- * - A Modbus RTU server with parameters from config.h.
- * - Modbus points (Coils, Holding Registers, etc.) based on a predefined map in config.h.
- *
- * The loop() function continuously:
- * - Services the Modbus RTU server to handle incoming requests.
- * - Periodically calls the main update loop for the emulated equipment, which
- *   manages state transitions and behavior strategies.
- *
- * @see config.h for Modbus RTU and register map configuration.
- * @see Equipment.h for the main equipment logic.
- * @see State.h for different equipment states.
- * @see Strategies/Strategy_Behavior.h for value generation strategies.
- * @see Modbus_Point.h for the base class for all Modbus points.
- */
-//=================================================================================================================================
-//Libraries and declaration of variables.
-#include <Arduino.h>
-#include "config.h"
-#include "ModbusPoints/Modbus_PointFactory.h"
-
-//=================================================================================================================================
-/** 
- * @brief Initializes the application.
- * @details This function runs once at startup. It configures the serial communication
- * for debugging and the Modbus RTU server. It then creates and initializes all
- * the Modbus points based on the `mb_map` array in `config.h`.
- */
-const int rtsPin = 4;
-void setup() {
-  Serial.begin(115200);
-  Serial.println("Setup function started");
-
-  Serial2.begin(BAUDRATE, SERIAL_8N1, RX_PIN, TX_PIN);
-  mb.begin(&Serial2, RST_PIN); // Start the server
-  mb.slave(MODBUS_ID); // Set the slave ID
-   
-  for(int i = 0; i < map_size; i++){
-    Modbus_Point<ModbusRTU>* point = createModbus_Point(&mb, mb_map[i].category, mb_map[i].address, mb_map[i].value, mb_map[i].description);
-    if (point) {
-      point->addToModbusServer();
-      EquipmentInstance.addModbus_Point(mb_map[i].description, point);
-    }
-  }
-  Serial.println("Setup function ended"); 
-}
-//=================================================================================================================================
-/** 
- * @brief The main application loop.
- * @details This function runs repeatedly after setup() has completed. It performs two main actions:
- * 1. It continuously services the Modbus server by calling `mb.task()` to handle
- *    incoming requests from a Modbus master.
- * 2. At a fixed interval (defined in `config.h`), it calls `EquipmentInstance.update()`
- *    to run the emulator's internal state machine and behavior logic.
- */
-void loop() {
-  mb.task();
-  unsigned long currentMillis = millis();
-  if (currentMillis - previousMillis >= interval) {
-    previousMillis = currentMillis;
-    unsigned long startTime = millis();
-    EquipmentInstance.update();
-    unsigned long endTime = millis();
-    unsigned long elapsedTime = endTime - startTime;
-    Serial.printf("Control Execution time: %d ms\n", elapsedTime);
-  } 
-}
diff --git a/src/BMS/CHILLER/CH_York_XXXXX_RTU/README.md b/src/BMS/CHILLER/CH_York_XXXXX_RTU/README.md
deleted file mode 100644
index 630cf02..0000000
--- a/src/BMS/CHILLER/CH_York_XXXXX_RTU/README.md
+++ /dev/null
@@ -1,35 +0,0 @@
-# EQUIPMENT_TYPE MANUFACTURER MODEL RTU
-
-## Brief Introduction
-Equipment specifc details that make it different from other devices
-
-## List of Equipmentt
-This cofiguration has been used for these models:
-* **Model**: 09-15-22 
-* **Model**: 09-15-23 
-* **Model**: 09-15-25 
-
-## Hardware Prerequisites
-
-The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities and at least one hardware serial port for RS485 communication.
-
-* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html) 
-* **RS485 Transceiver**: [RS485 Shield for Arduino.](https://www.dfrobot.com/product-1024.html)
-
----
-
-## States and Strategies
-Provide a brief description of what variables and strategies were used in this configuraiton
-
-### Standby State
-* **Equipment running**: set to 0
-* **Common Alarm**: set to 0
-* **SAT temperature**: set to 85
-
-### Running State
-* **Equipment running**: set to 1
-* **SAT temperature**: **Ramp Strategy** set to 65 deg setpoint
-
-### Fail State
-* **Commong Alarm**: set to 1
-* **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset
diff --git a/src/BMS/CHILLER/CH_York_XXXXX_RTU/State_Fail.cpp b/src/BMS/CHILLER/CH_York_XXXXX_RTU/State_Fail.cpp
deleted file mode 100644
index 6d85f9a..0000000
--- a/src/BMS/CHILLER/CH_York_XXXXX_RTU/State_Fail.cpp
+++ /dev/null
@@ -1,77 +0,0 @@
-/**
- * @file State_Fail.cpp
- * @brief Implementation of the FailState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the FailState, which defines
- * the behavior of the equipment when it has entered a fault condition.
- */
-#include "States/State_Standby.h"
-#include "States/State_Fail.h"
-#include "ModbusPoints/Modbus_Point.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_PID.h"
-
-#include <vector>
-#include <string>
-
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new FailState object.
- *
- * This constructor receives a list of alarm descriptions and creates strategies
- * to set the corresponding Modbus points to a value of 1, indicating an
- * active alarm. It also initializes a PID strategy for the valve position.
- */
-template<>
-FailState<ModbusRTU>::FailState(const std::vector<std::string>& activeAlarms) {
-    // Simulate a failure: set common alarm and a specific fan alarm.
-}
-
-/**
- * @brief Executes the fail state's logic for one update cycle.
- *
- * This method checks the "Clear Alm" Modbus point for a command to transition
- * back to Standby, which would typically happen after a fault is cleared by a
- * user. If no transition is requested, it continues to apply the failure strategies.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusRTU>* FailState<ModbusRTU>::update(Equipment<ModbusRTU>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Fail update function");
-    
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the fail state. Sets the main alarm bit.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusRTU>::enterState(Equipment<ModbusRTU>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Fail State...");
-    
-}
-
-/**
- * @brief Logic to execute once when exiting the fail state. Clears the main alarm bit.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusRTU>::exitState(Equipment<ModbusRTU>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Fail State...");
-    
-}
\ No newline at end of file
diff --git a/src/BMS/CHILLER/CH_York_XXXXX_RTU/State_Running.cpp b/src/BMS/CHILLER/CH_York_XXXXX_RTU/State_Running.cpp
deleted file mode 100644
index 4299d0b..0000000
--- a/src/BMS/CHILLER/CH_York_XXXXX_RTU/State_Running.cpp
+++ /dev/null
@@ -1,89 +0,0 @@
-/**
- * @file State_Running.cpp
- * @brief Implementation of the RunningState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the RunningState, which defines
- * the behavior of the equipment when it is actively running.
- */
-
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "Strategies/Strategy_Behavior.h"
-#include "Strategies/Strategy_PID.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Totalizer.h"
-#include "Equipment/Equipment.h"
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-
-#include <vector>
-#include <string>
-
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new RunningState object.
- *
- * This constructor initializes behavior strategies active during the running
- * state, such as a PID controller for the 'CW Valve Position' and totalizers
- * for the run-hours of each EC fan.
- */
-template<>
-RunningState<ModbusRTU>::RunningState() {
-    //Add strategies 
-    //addStrategy("Actual Capacity", new PIDStrategy("Active SP", 1000, "Supply Temp"));
-    
-}
-
-/**
- * @brief Executes the running state's logic for one update cycle.
- *
- * This method first checks for state transition commands:
- * 1. It reads the "ON/OFF Command By BMS" point. If it's 0, it transitions to StandbyState.
- * 2. It reads the "Fault Code" point. If it's non-zero, it transitions to FailState,
- *    passing the corresponding alarm description.
- *
- * If no transition occurs, it applies the strategies defined for the running state.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusRTU>* RunningState<ModbusRTU>::update(Equipment<ModbusRTU>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Running update function");
-    
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the running state.
- * Sets the "Chiller Sts" point to indicate the unit is running.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusRTU>::enterState(Equipment<ModbusRTU>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Running State...");
-    
-}
-
-/**
- * @brief Logic to execute once when exiting the running state.
- * Sets the "Chiller Sts" point to indicate the unit is no longer running.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusRTU>::exitState(Equipment<ModbusRTU>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Running State...");
-}
\ No newline at end of file
diff --git a/src/BMS/CHILLER/CH_York_XXXXX_RTU/State_Standby.cpp b/src/BMS/CHILLER/CH_York_XXXXX_RTU/State_Standby.cpp
deleted file mode 100644
index 4d6de94..0000000
--- a/src/BMS/CHILLER/CH_York_XXXXX_RTU/State_Standby.cpp
+++ /dev/null
@@ -1,79 +0,0 @@
-/**
- * @file State_Standby.cpp
- * @brief Implementation of the StandbyState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the StandbyState, which defines
- * the behavior of the equipment when it is in an idle or standby mode.
- */
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new StandbyState object.
- *
- * In this state, the equipment is idle. This constructor initializes several
- * strategies to generate random values for various status points, simulating
- * a live but non-operational unit.
- */
-template<>
-StandbyState<ModbusRTU>::StandbyState() {
-
-  addStrategy("HR1", new RampStrategy(200.0f, 5.0f, 1000));
-  
-}
-
-/**
- * @brief Executes the standby state's logic for one update cycle.
- *
- * This method checks the "Chiller On-Off" Modbus point for a command to
- * transition to the Running state. If no transition is requested, it applies
- * the strategies defined for the standby state.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusRTU>* StandbyState<ModbusRTU>::update(Equipment<ModbusRTU>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Standby update function");
-    
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the standby state.
- * Sets the "Chiller Sts" point to indicate the unit is not running.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusRTU>::enterState(Equipment<ModbusRTU>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Standby State...");
-   
-}
-
-/**
- * @brief Logic to execute once when exiting the standby state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusRTU>::exitState(Equipment<ModbusRTU>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-   
-}
\ No newline at end of file
diff --git a/src/BMS/CHILLER/CH_York_XXXXX_RTU/config.h b/src/BMS/CHILLER/CH_York_XXXXX_RTU/config.h
deleted file mode 100644
index 2af3d03..0000000
--- a/src/BMS/CHILLER/CH_York_XXXXX_RTU/config.h
+++ /dev/null
@@ -1,74 +0,0 @@
-/**
- * @file config.h
- * @brief Main configuration file for the Daikin Chiller (RTU) emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * This file contains important configurations for the Modbus RTU communication
- * and the specific register map for the emulated device.
- */
-
-#ifndef CONFIG_H
-#define CONFIG_H
-#include <ModbusRTU.h>
-#include "core.h"
-#include "Equipment/Equipment.h"
-
-
-#if defined(USE_MODBUS_IP)
-/**
-   * @defgroup ModbusTCPConfig Modbus IP Configuration
-   * @brief Parameters for Modbus TCP communication.
-   * @{
-   */
-  #include <ModbusIP_ESP8266.h>
-  const char *ssid = "wifi_name";       /**< @brief The SSID of the WiFi network. */
-  const char *password = "wifi_password";   /**< @brief The password for the WiFi network. */
-  IPAddress local_IP(192, 168, 1, 234);       /**< @brief The static IP address for the device. */
-  IPAddress gateway(192, 168, 1, 1);          /**< @brief The gateway IP address. */
-  IPAddress subnet(255, 255, 255, 0);         /**< @brief The subnet mask. */
-  
-  ModbusIP mb;
-#else
-  /**
-   * @defgroup ModbusRTUConfig Modbus RTU Configuration
-   * @brief Parameters for serial Modbus RTU communication.
-   * @{
-   */
-  #include <ModbusRTU.h>
-  const int BAUDRATE = 19200;   /**< @brief The serial communication speed in bits per second. */
-  const int RX_PIN = 17;        /**< @brief The GPIO pin used for receiving data (RX). */
-  const int TX_PIN = 16;        /**< @brief The GPIO pin used for transmitting data (TX). */
-  const int RST_PIN = 4;        /**< @brief The GPIO pin connected to the RS485 driver's DE/RE pins for direction control. */
-  const int MODBUS_ID = 1;      /**< @brief The unique slave ID for this device on the Modbus bus. */
-  /** @} */
-
-  /** @brief Global instance of the Modbus RTU server. */
-  ModbusRTU mb;
-#endif
-
-/**
- * @brief The Modbus map for the Equipment device.
- * This array defines all the Modbus points available on the emulated device.
- * The `description` field is crucial as it's used to look up points within the application logic.
- */
-modbusMap mb_map[] =
-{   
-  {HR,        0,  0,  "HR1"},  //Internal to control from Modscan
-  {HR_10x,    1,  0,  "HR2"},  //Internal to control from Modscan
-  {HR_FLOAT,  2,  0,  "HR3"},  //Internal to control from Modscan
-  {HR_LONG,   4,  0,  "HR4"},  //Internal to control from Modscan  
-};
-//Size of modbus map used in FOR cycles, automatically calculated.
-/**
- * @brief The total number of entries in the `mb_map` array.
- * This is calculated at compile time and used for iterating over the map.
- */
-const int map_size = sizeof(mb_map) / sizeof(mb_map[0]);
-
-/**
- * @brief The main loop update interval in milliseconds.
- */
-int interval = 250; 
-
-#endif // CONFIG_H
diff --git a/src/BMS/CHILLER/CH_York_XXXXX_RTU/main.cpp b/src/BMS/CHILLER/CH_York_XXXXX_RTU/main.cpp
deleted file mode 100644
index 5dbc9f1..0000000
--- a/src/BMS/CHILLER/CH_York_XXXXX_RTU/main.cpp
+++ /dev/null
@@ -1,78 +0,0 @@
-/**
- * @file main.cpp
- * @brief Main execution program for the Daikin Chiller (RTU) Emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * @details This file contains the main execution program for an Arduino-based
- * emulator of a Daikin Chiller unit. The program communicates via the
- * Modbus RTU protocol over a serial connection.
- *
- * The setup() function initializes the following:
- * - Serial communication for debugging.
- * - A Modbus RTU server with parameters from config.h.
- * - Modbus points (Coils, Holding Registers, etc.) based on a predefined map in config.h.
- *
- * The loop() function continuously:
- * - Services the Modbus RTU server to handle incoming requests.
- * - Periodically calls the main update loop for the emulated equipment, which
- *   manages state transitions and behavior strategies.
- *
- * @see config.h for Modbus RTU and register map configuration.
- * @see Equipment.h for the main equipment logic.
- * @see State.h for different equipment states.
- * @see Strategies/Strategy_Behavior.h for value generation strategies.
- * @see Modbus_Point.h for the base class for all Modbus points.
- */
-//=================================================================================================================================
-//Libraries and declaration of variables.
-#include <Arduino.h>
-#include "config.h"
-#include "ModbusPoints/Modbus_PointFactory.h"
-
-//=================================================================================================================================
-/** 
- * @brief Initializes the application.
- * @details This function runs once at startup. It configures the serial communication
- * for debugging and the Modbus RTU server. It then creates and initializes all
- * the Modbus points based on the `mb_map` array in `config.h`.
- */
-const int rtsPin = 4;
-void setup() {
-  Serial.begin(115200);
-  Serial.println("Setup function started");
-
-  Serial2.begin(BAUDRATE, SERIAL_8N1, RX_PIN, TX_PIN);
-  mb.begin(&Serial2, RST_PIN); // Start the server
-  mb.slave(MODBUS_ID); // Set the slave ID
-   
-  for(int i = 0; i < map_size; i++){
-    Modbus_Point<ModbusRTU>* point = createModbus_Point(&mb, mb_map[i].category, mb_map[i].address, mb_map[i].value, mb_map[i].description);
-    if (point) {
-      point->addToModbusServer();
-      EquipmentInstance.addModbus_Point(mb_map[i].description, point);
-    }
-  }
-  Serial.println("Setup function ended"); 
-}
-//=================================================================================================================================
-/** 
- * @brief The main application loop.
- * @details This function runs repeatedly after setup() has completed. It performs two main actions:
- * 1. It continuously services the Modbus server by calling `mb.task()` to handle
- *    incoming requests from a Modbus master.
- * 2. At a fixed interval (defined in `config.h`), it calls `EquipmentInstance.update()`
- *    to run the emulator's internal state machine and behavior logic.
- */
-void loop() {
-  mb.task();
-  unsigned long currentMillis = millis();
-  if (currentMillis - previousMillis >= interval) {
-    previousMillis = currentMillis;
-    unsigned long startTime = millis();
-    EquipmentInstance.update();
-    unsigned long endTime = millis();
-    unsigned long elapsedTime = endTime - startTime;
-    Serial.printf("Control Execution time: %d ms\n", elapsedTime);
-  } 
-}
diff --git a/src/BMS/CHILLER/CH_York_YVAA_RTU/README.md b/src/BMS/CHILLER/CH_York_YVAA_RTU/README.md
deleted file mode 100644
index f2bc7c7..0000000
--- a/src/BMS/CHILLER/CH_York_YVAA_RTU/README.md
+++ /dev/null
@@ -1,70 +0,0 @@
-# CHILLER YORK YVAA 0428IOK46BAVTXX TCP
-
-## Brief Introduction
-Chiller receives Chiller Temp SP and Enable from PLC. The Supply Temp will ramp to Chiller Temp SP in Run Mode.
-Alarms are also simulated via Modscan, though those signals will be internal to Chiller.
-Hard IO points simulated with Modscan: Sys 1 Alarm, Sys 2 Alarm.
-Chiller Status is sent back to PLC.
-In practice, all Modbus points are for monitoring only and go to Ignition - not sent to PLC.
-For the sake of simulation, some hard IO points (simulated as Modbus points) will go back to PLC for feedback or will be sent from PLC to Arduino.
-
-## List of Equipment
-This cofiguration has been used for these models:
-* **YVAA**: 10-14-25
-
-## Hardware Prerequisites
-
-The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities.
-* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html) 
-
----
-
-## States and Strategies
-Updates Alarms States. Only the Sys 1 Fan Fault or Sys 2 Fan Fault will send unit --> FailState
-Sys 1 Alarm, Sys 2 Alarm, and General Alarm will annunciate only, will not stop the unit (this is an assumption the program follows, may differ in field).
-Updates Free Cooling Mode: Free Cooling Mode is activated using a coil, for simulation purposes only.
-Modbus points are simulated, mostly with a SingleValue strategy for image verification in Ignition.
-While in RunningState, the Supply Temp dynamically ramps to the Supply Temp SP sent from PLC (or Modscan)
-The CHW In and CHW Out temperature values also dynamically ramp to match the Return and Supply Temps.
-
-### Standby State
-* **Chiller Status**: set to 0
-* **Operational Code**: set to 77
-* **Chiller Start Command**: set to 0
-Supply Temp = 80 +/- 1
-Return Temp = 80 +/- 1
-System CHW Out = 80 +/- 1
-System CHW In = 80 +/- 1
-Ambient Temp = 1-- +/- 1
-Sys 1, 2 Oil Pressure = 420 +/- 1
-Sys 1, 2 Suction Pressure = 70 +/- 1
-Sys 1, 2 Discharge Pressure = 70 +/- 1
-Sys 1, 2 Condenser Temp = 124 +/- 1
-
-### Running State
-* **Chiller status**: set to 1
-* **Operational Code**: set to 78 (running)
-* **Supply Temperature**: **Ramp Strategy** ramps to Chiller Temp Setpoint from PLC (Modscan)
-Supply Temp dynamically ramps to Chiller Temp Setpoint as sent from PLC (or Modscan)
-Return Temp sawStrategy (79-83)
-System CHW Out dynamically ramps to follow Supply Temp
-System CHW In dynamically ramps to follow Return Temp
-Ambient Temp = 1-- +/- 1
-Sys 1, 2 Oil Pressure = 450 +/- 5
-Sys 1, 2 Suction Pressure = 70 +/- 2
-Sys 1, 2 Discharge Pressure = 375 +/- 4
-Sys 1, 2 Compressor Pct FLA = 93 +/- 2
-Sys 1, 2 Condenser Temp = 125 +/- 5
-Sys 1 Fan kW = 35 +/- 2
-Sys 2 Fan kW = 23 +/- 2
-Sys 1 Compressor kW = 304 +/- 5
-Sys 2 Compressor kW = 198 +/- 5
-
-### Fail State
-All values match that of Standby State.
-The difference is in Fail State, if a Start Command is sent it will not start the Chiller.
-All faults must be cleared, then unit transitions to Standby State.
-* **Chiller Status**: set to 0
-* **Operational Code**: set to 77
-* **Chiller Start Command**: set to 0
-All analog values same as in Standby State
\ No newline at end of file
diff --git a/src/BMS/CHILLER/CH_York_YVAA_RTU/StateUtils.cpp b/src/BMS/CHILLER/CH_York_YVAA_RTU/StateUtils.cpp
deleted file mode 100644
index 434a1f3..0000000
--- a/src/BMS/CHILLER/CH_York_YVAA_RTU/StateUtils.cpp
+++ /dev/null
@@ -1,95 +0,0 @@
-/**
- * @file StateUtils.cpp
- * @brief Implementation of the StateUtils class.
- * @author Robert J. Davis
- * @date 2025-10-14
- *
- * This file contains implementation of utility functions that are used in multiple States.
- */
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include "StateUtils.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Updates Alarms states
- * 
- * This function will update the Alarm status DI bits according to the Alarm Commands from Coils (Modscan)
- * The appropriate Fault Code will also be set to 56 (Condenser Fan VSD Warning).
- * Also updates the General Alarm bit. If any alarms are active, General Alarm --> 1, else 0.
- * 
- * This is a function used in the update() of the Standby, Running, and Fail States.
- *
-*/ 
-
-void updateAlarms(Equipment<ModbusRTU>* equipment){
-    // Updates Sys 1, 2 Fan Fault Alarms with associated Fault Code
-    Modbus_Point<ModbusRTU>* Sys1FanAlarmCommand = equipment->getModbus_Point("Sys 1 Fan Fault ON");
-    Modbus_Point<ModbusRTU>* Sys2FanAlarmCommand = equipment->getModbus_Point("Sys 2 Fan Fault ON");
-    Modbus_Point<ModbusRTU>* Sys1FanAlarm = equipment->getModbus_Point("Sys 1 Fan Fault Alarm");
-    Modbus_Point<ModbusRTU>* Sys2FanAlarm = equipment->getModbus_Point("Sys 2 Fan Fault Alarm");
-    if (Sys1FanAlarmCommand) {
-        Sys1FanAlarm->setValue(Sys1FanAlarmCommand->getValue());
-        if (Sys1FanAlarmCommand->getValue() == 1){
-            equipment->setModbus_Point("Sys 1 Fault Code", 56);
-        }
-        else equipment->setModbus_Point("Sys 1 Fault Code", 0);
-    }
-    if (Sys2FanAlarmCommand) {
-        Sys2FanAlarm->setValue(Sys2FanAlarmCommand->getValue());
-        if (Sys2FanAlarmCommand->getValue() == 1){
-            equipment->setModbus_Point("Sys 2 Fault Code", 56);
-        }
-        else equipment->setModbus_Point("Sys 2 Fault Code", 0);
-    }
-
-    // Update General Alarm (if any Alarm is active, make general alarm active)
-    const std::vector<std::string> alarmDescriptions = {
-        "Sys 1 Alarm", "Sys 2 Alarm", "Sys 1 Fan Fault Alarm", "Sys 2 Fan Fault Alarm"
-    };
-    int numAlarms = 0;
-    for (int i =0; i < alarmDescriptions.size(); ++i) {
-        Modbus_Point<ModbusRTU>* alarmPoint = equipment->getModbus_Point(alarmDescriptions[i]);
-        if (alarmPoint) {
-            if (alarmPoint->getValue() == 1) numAlarms++;
-        }
-    }
-    if (numAlarms >= 1) equipment->setModbus_Point("General Alarm", 1);
-    else equipment->setModbus_Point("General Alarm", 0);
-}
-
-/**
- * @brief Updates Free Cooling Mode
- * 
- * This function will update the Free Cooling Mode and Valve based on Free Cooling Command
- * received from Modscan. This is for simulation purposes only - in practice, the Chiller
- * will transition to Free Cooling Mode based on its own internal logic.
- * 
- * For ease of testing, this is a function used in the update() of the Standby, Running, and Fail States.
- *
-*/ 
-
-void updateFreeCooling(Equipment<ModbusRTU>* equipment){
-    Modbus_Point<ModbusRTU>* FreeCoolingCommand = equipment->getModbus_Point("Free Cooling Mode ON");
-    Modbus_Point<ModbusRTU>* FreeCoolingMode = equipment->getModbus_Point("Free Cooling Mode");
-    Modbus_Point<ModbusRTU>* FreeCoolingValve = equipment->getModbus_Point("Free Cooling Valve");
-    FreeCoolingMode->setValue(FreeCoolingCommand->getValue());
-    FreeCoolingValve->setValue(FreeCoolingCommand->getValue());
-}
\ No newline at end of file
diff --git a/src/BMS/CHILLER/CH_York_YVAA_RTU/StateUtils.h b/src/BMS/CHILLER/CH_York_YVAA_RTU/StateUtils.h
deleted file mode 100644
index 92438ec..0000000
--- a/src/BMS/CHILLER/CH_York_YVAA_RTU/StateUtils.h
+++ /dev/null
@@ -1,43 +0,0 @@
-/**
- * @file config.h
- * @brief StateUtils class
- * @author Robert J Davis
- * @date 2025-10-06
- *
- * Defines the StateUtils class, which contains utility functions used in multiple States.
- */
-
-#pragma once
-
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-template <typename T>
-class State;
-
-/**
- * @brief Updates Alarms states
- * @param equipment Pointer to the Equipment instance.
- * @return void
- */
-void updateAlarms(Equipment<ModbusRTU>* equipment);
-
-/**
- * @brief Updates Free Cooling Mode
- * @param equipment Pointer to the Equipment instance.
- * @return void
- */
-void updateFreeCooling(Equipment<ModbusRTU>* equipment);
\ No newline at end of file
diff --git a/src/BMS/CHILLER/CH_York_YVAA_RTU/State_Fail.cpp b/src/BMS/CHILLER/CH_York_YVAA_RTU/State_Fail.cpp
deleted file mode 100644
index 0ea3225..0000000
--- a/src/BMS/CHILLER/CH_York_YVAA_RTU/State_Fail.cpp
+++ /dev/null
@@ -1,135 +0,0 @@
-/**
- * @file State_Fail.cpp
- * @brief Implementation of the FailState class.
- * @author Robert J. Davis
- * @date 2025-10-14
- *
- * This file contains the implementation for the FailState, which defines
- * the behavior of the equipment when it has entered a fault condition.
- * The unit enters Fail State if Sys 1 Fan Fault Alarm or Sys 2 Fan Fault Alarm is active.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "StateUtils.h"
-#include <vector>
-#include <string>
-
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new FailState object.
- *
- * This constructor receives a list of alarm descriptions and creates strategies
- * to set the unit back into an idle, de-energized state.
- * 
- * @param activeFaults A vector of strings, where each string is the
- *                     description of the currently active faults.
- */
-template<>
-FailState<ModbusRTU>::FailState(const std::vector<std::string>& activeFaults) {
-    addStrategy("Supply Temp", new SingleValueStrategy(80.0f, 1.0f, 10000));
-    addStrategy("Return Temp", new SingleValueStrategy(80.0f, 1.0f, 10000));
-    addStrategy("Ambient Temp", new SingleValueStrategy(100.0f, 1.0f, 10000));
-
-    addStrategy("System CHW Out", new SingleValueStrategy(80.0f, 1.0f, 10000));
-    addStrategy("System CHW In", new SingleValueStrategy(80.0f, 1.0f, 10000));
-    addStrategy("Sys 1 Condenser Temp", new SingleValueStrategy(124.0f, 1.0f, 10000));
-    addStrategy("Sys 2 Condenser Temp", new SingleValueStrategy(124.0f, 1.0f, 10000));
-    addStrategy("Sys 1 Oil Pressure", new SingleValueStrategy(420.0f, 1.0f, 10000));
-    addStrategy("Sys 2 Oil Pressure", new SingleValueStrategy(420.0f, 1.0f, 10000));
-    addStrategy("Sys 1 Suction Pressure", new SingleValueStrategy(70.0f, 1.0f, 10000));
-    addStrategy("Sys 2 Suction Pressure", new SingleValueStrategy(70.0f, 1.0f, 10000));
-    addStrategy("Sys 1 Discharge Pressure", new SingleValueStrategy(70.0f, 1.0f, 10000));
-    addStrategy("Sys 2 Discharge Pressure", new SingleValueStrategy(70.0f, 1.0f, 10000));
-    addStrategy("Sys 1 Compressor Pct FLA", new SingleValueStrategy(0.0f, 0.0f, 10000));
-    addStrategy("Sys 2 Compressor Pct FLA", new SingleValueStrategy(0.0f, 0.0f, 10000));
-    addStrategy("Local Leaving Temp Setpoint", new SingleValueStrategy(70.0f, 0.0f, 10000));
-    addStrategy("VSD Output Frequency", new SingleValueStrategy(0.0f, 0.0f, 10000));
-    addStrategy("Sys 1 Fan KW", new SingleValueStrategy(0.0f, 0.0f, 10000));
-    addStrategy("Sys 2 Fan KW", new SingleValueStrategy(0.0f, 0.0f, 10000));
-    addStrategy("Sys 1 Compressor KW", new SingleValueStrategy(0.0f, 0.0f, 10000));
-    addStrategy("Sys 2 Compressor KW", new SingleValueStrategy(0.0f, 0.0f, 10000));
-}
-
-/**
- * @brief Executes the fail state's logic for one update cycle.
- *
- * This method first updates all alarms states and Free Cooling Mode (for ease of testing).
- * If all faults have been cleared --> StandbyState.
- * If faults are still active, ensures the Chiller Start Command remains at 0.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusRTU>* FailState<ModbusRTU>::update(Equipment<ModbusRTU>* equipment) {
-    // Update alarms states, Free Cooling mode
-    updateAlarms(equipment);
-    updateFreeCooling(equipment);
-    
-    const std::vector<std::string> FaultDescriptions = {
-        "Sys 1 Fan Fault Alarm", "Sys 2 Fan Fault Alarm",
-    };
-
-    // If no faults active --> send to StandbyState()
-    bool faults_active = false;
-    for (const auto& desc : FaultDescriptions) {
-        Modbus_Point<ModbusRTU>* point = equipment->getModbus_Point(desc);
-        if (point->getValue() == 1) {
-            faults_active = true;
-        }
-    }
-    if (!faults_active) return new StandbyState<ModbusRTU>();
-
-    setPointValue(equipment, "Chiller Start Command", 0);
-
-    // Update Operational Code depending on Free Cooling Mode
-    int freeCoolingState = getPointValue(equipment, "Free Cooling Mode ON");
-    if (freeCoolingState == 1){
-        setPointValue(equipment, "Sys 1 Operational Code", 82);
-        setPointValue(equipment, "Sys 2 Operational Code", 82);
-    }
-    else{
-        setPointValue(equipment, "Sys 1 Operational Code", 77);
-        setPointValue(equipment, "Sys 2 Operational Code", 77);
-    }
-    
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the fail state.
- * Sets the Chiller Status to off, and updates the Operational Code for Systems to 77 (Not Running)
- * The Chiller Start Command is also set to 0.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusRTU>::enterState(Equipment<ModbusRTU>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Fail State...");
-    setPointValue(equipment, "Chiller Start Command", 0);
-    setPointValue(equipment, "Chiller Status", 0);
-    setPointValue(equipment, "Sys 1 Operational Code", 77);
-    setPointValue(equipment, "Sys 2 Operational Code", 77);
-}
-
-/**
- * @brief Logic to execute once when exiting the fail state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusRTU>::exitState(Equipment<ModbusRTU>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Fail State...");
-}
\ No newline at end of file
diff --git a/src/BMS/CHILLER/CH_York_YVAA_RTU/State_Running.cpp b/src/BMS/CHILLER/CH_York_YVAA_RTU/State_Running.cpp
deleted file mode 100644
index 6c3bb3c..0000000
--- a/src/BMS/CHILLER/CH_York_YVAA_RTU/State_Running.cpp
+++ /dev/null
@@ -1,182 +0,0 @@
-/**
- * @file State_Running.cpp
- * @brief Implementation of the RunningState class.
- * @author Robert J Davis
- * @date 2025-10-12
- *
- * This file contains the implementation for the RunningState, which defines
- * the behavior of the equipment when it is actively running.
- */
-
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "Strategies/Strategy_Totalizer.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include "StateUtils.h"
-#include <vector>
-#include <string>
-
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new RunningState object.
- *
- * This constructor initializes behavior strategies active during the running
- * state including various analog values, number of starts for each System and totalizers
- * for the run-hours of each System.
- */
-template<>
-RunningState<ModbusRTU>::RunningState() {
-    addStrategy("Supply Temp", new RampStrategy(67.0f, 1.0f, 3000));
-    addStrategy("Return Temp", new SawStrategy(79.0f, 83.0f, 1.0f, 4000));
-    addStrategy("Ambient Temp", new SingleValueStrategy(100.0f, 1.0f, 5000));
-    
-    addStrategy("System CHW Out", new RampStrategy(67.0f, 1.0f, 3000));
-    addStrategy("System CHW In", new RampStrategy(81.0f, 1.0f, 4000));
-    addStrategy("Sys 1 Condenser Temp", new SingleValueStrategy(125.0f, 5.0f, 5000));
-    addStrategy("Sys 2 Condenser Temp", new SingleValueStrategy(125.0f, 5.0f, 5000));
-    addStrategy("Sys 1 Oil Pressure", new SingleValueStrategy(450.0f, 5.0f, 5000));
-    addStrategy("Sys 2 Oil Pressure", new SingleValueStrategy(450.0f, 5.0f, 5000));
-    addStrategy("Sys 1 Suction Pressure", new SingleValueStrategy(70.0f, 2.0f, 5000));
-    addStrategy("Sys 2 Suction Pressure", new SingleValueStrategy(70.0f, 2.0f, 5000));
-    addStrategy("Sys 1 Discharge Pressure", new SingleValueStrategy(375.0f, 4.0f, 5000));
-    addStrategy("Sys 2 Discharge Pressure", new SingleValueStrategy(375.0f, 4.0f, 5000));
-    addStrategy("Sys 1 Compressor Pct FLA", new SingleValueStrategy(93.0f, 2.0f, 5000));
-    addStrategy("Sys 2 Compressor Pct FLA", new SingleValueStrategy(93.0f, 2.0f, 5000));
-    addStrategy("Sys 1 Run Hours", new TotalizerStrategy(5000)); 
-    addStrategy("Sys 2 Run Hours", new TotalizerStrategy(5000)); 
-    addStrategy("Local Leaving Temp Setpoint", new SingleValueStrategy(70.0f, 0.0f, 10000));
-    addStrategy("VSD Output Frequency", new SingleValueStrategy(59.0f, 1.0f, 10000));
-    addStrategy("Sys 1 Fan KW", new SingleValueStrategy(35.0f, 2.0f, 10000));
-    addStrategy("Sys 2 Fan KW", new SingleValueStrategy(23.0f, 2.0f, 10000));
-    addStrategy("Sys 1 Compressor KW", new SingleValueStrategy(304.0f, 5.0f, 10000));
-    addStrategy("Sys 2 Compressor KW", new SingleValueStrategy(198.0f, 5.0f, 10000));
-}
-
-/**
- * @brief Executes the running state's logic for one update cycle.
- *
- * This method first checks if there are any active alarms --> FailState.
- * Also checks for Free Cooling Mode (for ease of testing)
- * If no alarms are active, checks for "Chiller Start Command" = 0 (Modscan, but will be from PLC) 
- * for a command to transition to the Standby state. If no transition is requested, it updates the
- * rampStrategy targetValues for the Supply Temp, CHW In, CHW Out analog values and applies the 
- * strategies defined for the running state.
- *
- * If no transition occurs, it applies the strategies defined for the running state.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusRTU>* RunningState<ModbusRTU>::update(Equipment<ModbusRTU>* equipment) {
-    // Update alarms states, Free Cooling mode, Freeze Protection Mode
-    updateAlarms(equipment);
-    updateFreeCooling(equipment);
-
-    std::vector<std::string> activeFaultDescriptions = {}; 
-    const std::vector<std::string> FaultDescriptions = {
-        "Sys 1 Fan Fault Alarm", "Sys 2 Fan Fault Alarm"
-    };
-    
-    // Loop through faults, create array of active faults and send to FailState if any faults are active
-    bool faults_active = false;
-    for (const auto& desc : FaultDescriptions) {
-        Modbus_Point<ModbusRTU>* point = equipment->getModbus_Point(desc);
-        if (point->getValue() == 1) {
-            activeFaultDescriptions.push_back(desc);
-            faults_active = true;
-        }
-    }
-    if (faults_active) return new FailState<ModbusRTU>(activeFaultDescriptions);
-
-    // If no faults active and Start Command = 0--> send to StandbyState()
-    int Chiller_Enable = getPointValue(equipment, "Chiller Start Command");    // Modscan COIL 1
-    if (Chiller_Enable == 0){
-        return new StandbyState<ModbusRTU>();
-    }
-
-    // Set the Supply Temp ramp target value equal to the Chiller Temp Setpoint
-    // Ramp CHW In Temp to Return Temp and CHW Out Temp to Supply Temp
-    float BMS_Temp_Setpoint = getPointValue(equipment, "Chiller Temp Setpoint");
-    float supplyTemp = getPointValue(equipment, "Supply Temp");
-    float returnTemp = getPointValue(equipment, "Return Temp");
-    Strategy_Behavior* Supply_Temp_strat = getStrategy("Supply Temp");
-    Strategy_Behavior* CHW_Out_strat = getStrategy("System CHW Out");
-    Strategy_Behavior* CHW_In_strat = getStrategy("System CHW In");
-    if (Supply_Temp_strat){
-        static_cast<RampStrategy*>(Supply_Temp_strat)->setTarget(BMS_Temp_Setpoint);
-        static_cast<RampStrategy*>(CHW_Out_strat)->setTarget(supplyTemp);
-        static_cast<RampStrategy*>(CHW_In_strat)->setTarget(returnTemp);
-    }
-
-    // Update Operational Code depending on Free Cooling Mode
-    int freeCoolingState = getPointValue(equipment, "Free Cooling Mode ON");
-    if (freeCoolingState == 1){
-        setPointValue(equipment, "Sys 1 Operational Code", 82);
-        setPointValue(equipment, "Sys 2 Operational Code", 82);
-    }
-    else{
-        setPointValue(equipment, "Sys 1 Operational Code", 78);
-        setPointValue(equipment, "Sys 2 Operational Code", 78);
-    }
-
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the running state.
- * 
- * Sets the "Chiller Status" point to indicate the unit is running.
- * Update System Operational Code to 78 (Running).
- * Increment a counter for number of starts for each System.
- * We are assuming when the Chiller is commanded to run that both Systems will activate.
- * Not enough information in Vendor SOO to add details for running systems independently,
- * switching to Free-Cooling Mode, etc.
- * 
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusRTU>::enterState(Equipment<ModbusRTU>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Running State...");
-
-    setPointValue(equipment, "Chiller Status", 1);
-    setPointValue(equipment, "Sys 1 Operational Code", 78);
-    setPointValue(equipment, "Sys 2 Operational Code", 78);
-
-    // Add one to the System 1 and 2 Starts counter 
-    int Sys1_num_starts = getPointValue(equipment, "Sys 1 Starts");
-    int Sys2_num_starts = getPointValue(equipment, "Sys 2 Starts");
-    Sys1_num_starts++;
-    Sys2_num_starts++;
-    setPointValue(equipment, "Sys 1 Starts", Sys1_num_starts);
-    setPointValue(equipment, "Sys 2 Starts", Sys2_num_starts);
-    
-}
-
-/**
- * @brief Logic to execute once when exiting the running state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusRTU>::exitState(Equipment<ModbusRTU>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Running State...");
-}
\ No newline at end of file
diff --git a/src/BMS/CHILLER/CH_York_YVAA_RTU/State_Standby.cpp b/src/BMS/CHILLER/CH_York_YVAA_RTU/State_Standby.cpp
deleted file mode 100644
index c4ebf04..0000000
--- a/src/BMS/CHILLER/CH_York_YVAA_RTU/State_Standby.cpp
+++ /dev/null
@@ -1,147 +0,0 @@
-/**
- * @file State_Standby.cpp
- * @brief Implementation of the StandbyState class.
- * @author Robert J Davis
- * @date 2025-10-13
- *
- * This file contains the implementation for the StandbyState, which defines
- * the behavior of the equipment when it is in an idle or standby mode.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include "StateUtils.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new StandbyState object.
- *
- * In this state, the equipment is idle. This constructor initializes strategies
- * to bring the system to a safe, idle condition. It sets a stable value for
- * the analog readings and takes Fans and Compressors to 0 kW.
- */
-template<>
-StandbyState<ModbusRTU>::StandbyState() {
-    addStrategy("Supply Temp", new SingleValueStrategy(80.0f, 1.0f, 3000));
-    addStrategy("Return Temp", new SingleValueStrategy(80.0f, 1.0f, 3000));
-    addStrategy("Ambient Temp", new SingleValueStrategy(100.0f, 1.0f, 4000));
-
-    addStrategy("System CHW Out", new SingleValueStrategy(80.0f, 1.0f, 3000));
-    addStrategy("System CHW In", new SingleValueStrategy(80.0f, 1.0f, 3000));
-    addStrategy("Sys 1 Condenser Temp", new SingleValueStrategy(124.0f, 1.0f, 5000));
-    addStrategy("Sys 2 Condenser Temp", new SingleValueStrategy(124.0f, 1.0f, 5000));
-    addStrategy("Sys 1 Oil Pressure", new SingleValueStrategy(420.0f, 1.0f, 5000));
-    addStrategy("Sys 2 Oil Pressure", new SingleValueStrategy(420.0f, 1.0f, 5000));
-    addStrategy("Sys 1 Suction Pressure", new SingleValueStrategy(70.0f, 1.0f, 5000));
-    addStrategy("Sys 2 Suction Pressure", new SingleValueStrategy(70.0f, 1.0f, 5000));
-    addStrategy("Sys 1 Discharge Pressure", new SingleValueStrategy(70.0f, 1.0f, 5000));
-    addStrategy("Sys 2 Discharge Pressure", new SingleValueStrategy(70.0f, 1.0f, 5000));
-    addStrategy("Sys 1 Compressor Pct FLA", new SingleValueStrategy(0.0f, 0.0f, 5000));
-    addStrategy("Sys 2 Compressor Pct FLA", new SingleValueStrategy(0.0f, 0.0f, 5000));
-    addStrategy("VSD Output Frequency", new SingleValueStrategy(0.0f, 0.0f, 5000));
-    addStrategy("Sys 1 Fan KW", new SingleValueStrategy(0.0f, 0.0f, 5000));
-    addStrategy("Sys 2 Fan KW", new SingleValueStrategy(0.0f, 0.0f, 5000));
-    addStrategy("Sys 1 Compressor KW", new SingleValueStrategy(0.0f, 0.0f, 5000));
-    addStrategy("Sys 2 Compressor KW", new SingleValueStrategy(0.0f, 0.0f, 5000));
-
-}
-
-/**
- * @brief Executes the standby state's logic for one update cycle.
- *
- * This method first checks if there are any active alarms --> FailState.
- * Also checks for Free Cooling Mode (for ease of testing)
- * If no alarms are active, checks for "Chiller Start Command" (Modscan, but will be from PLC) 
- * for a command to transition to the Running state. If no transition is requested, it applies
- * the strategies defined for the standby state.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusRTU>* StandbyState<ModbusRTU>::update(Equipment<ModbusRTU>* equipment) {
-    // Update alarms states, Free Cooling mode, Freeze Protection Mode
-    updateAlarms(equipment);
-    updateFreeCooling(equipment);
-    
-    std::vector<std::string> activeAlarmsDescriptions = {}; 
-    const std::vector<std::string> alarmDescriptions = {
-        "Sys 1 Fan Fault Alarm", "Sys 2 Fan Fault Alarm"
-    };
-    
-    // Loop through alarms, create array of active alarms and send to FailState if any alarms are active
-    bool alarms_active = false;
-    for (const auto& desc : alarmDescriptions) {
-        Modbus_Point<ModbusRTU>* point = equipment->getModbus_Point(desc);
-        if (point->getValue() == 1) {
-            activeAlarmsDescriptions.push_back(desc);
-            alarms_active = true;
-        }
-    }
-    if (alarms_active) return new FailState<ModbusRTU>(activeAlarmsDescriptions);
-
-    // If no alarms active and Start Command = 1--> send to RunningState()
-    int Chiller_Enable = getPointValue(equipment, "Chiller Start Command");    // Modscan COIL 1
-    if  (Chiller_Enable == 1){
-        return new RunningState<ModbusRTU>();
-    }
-
-    // Update Operational Code depending on Free Cooling Mode
-    int freeCoolingState = getPointValue(equipment, "Free Cooling Mode ON");
-    if (freeCoolingState == 1){
-        setPointValue(equipment, "Sys 1 Operational Code", 82);
-        setPointValue(equipment, "Sys 2 Operational Code", 82);
-    }
-    else{
-        setPointValue(equipment, "Sys 1 Operational Code", 77);
-        setPointValue(equipment, "Sys 2 Operational Code", 77);
-    }
-
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the standby state.
- * Sets the "Chiller Status" point to indicate the unit is not running.
- * Updates Operational Codes for Sys 1 and Sys 2
- * Ensure Chiller Start Command is reset to 0.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusRTU>::enterState(Equipment<ModbusRTU>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Standby State...");
-    setPointValue(equipment, "Chiller Start Command", 0);
-    setPointValue(equipment, "Chiller Status", 0);
-    setPointValue(equipment, "Sys 1 Operational Code", 77);
-    setPointValue(equipment, "Sys 2 Operational Code", 77);
-    
-}
-
-/**
- * @brief Logic to execute once when exiting the standby state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusRTU>::exitState(Equipment<ModbusRTU>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Standby State...");
-}
\ No newline at end of file
diff --git a/src/BMS/CHILLER/CH_York_YVAA_RTU/config.h b/src/BMS/CHILLER/CH_York_YVAA_RTU/config.h
deleted file mode 100644
index cff73a3..0000000
--- a/src/BMS/CHILLER/CH_York_YVAA_RTU/config.h
+++ /dev/null
@@ -1,123 +0,0 @@
-/**
- * @file config.h
- * @brief Main configuration file for the York Chiller (RTU) emulator.
- * @author Robert J Davis
- * @date 2025-10-12
- *
- * This file contains important configurations for the Modbus RTU communication
- * and the specific register map for the emulated device.
- */
-
-#ifndef CONFIG_H
-#define CONFIG_H
-#include <ModbusRTU.h>
-#include "core.h"
-#include "Equipment/Equipment.h"
-
-
-#if defined(USE_MODBUS_IP)
-/**
-   * @defgroup ModbusTCPConfig Modbus IP Configuration
-   * @brief Parameters for Modbus TCP communication.
-   * @{
-   */
-  #include <ModbusIP_ESP8266.h>
-  const char *ssid = "ArduinoWifiB";          /**< @brief The SSID of the WiFi network. */
-  const char *password = "123abc456";          /**< @brief The password for the WiFi network. */
-  IPAddress local_IP(172, 17, 32, 35);       /**< @brief The static IP address for the device. */
-  IPAddress gateway(172, 17, 32, 1);          /**< @brief The gateway IP address. */
-  IPAddress subnet(255, 255, 255, 0);          /**< @brief The subnet mask. */
-  
-  ModbusIP mb;
-#else
-  /**
-   * @defgroup ModbusRTUConfig Modbus RTU Configuration
-   * @brief Parameters for serial Modbus RTU communication.
-   * @{
-   */
-  #include <ModbusRTU.h>
-  const int BAUDRATE = 19200;   /**< @brief The serial communication speed in bits per second. */
-  const int RX_PIN = 17;        /**< @brief The GPIO pin used for receiving data (RX). */
-  const int TX_PIN = 16;        /**< @brief The GPIO pin used for transmitting data (TX). */
-  const int RST_PIN = 4;        /**< @brief The GPIO pin connected to the RS485 driver's DE/RE pins for direction control. */
-  const int MODBUS_ID = 1;      /**< @brief The unique slave ID for this device on the Modbus bus. */
-  /** @} */
-
-  /** @brief Global instance of the Modbus RTU server. */
-  ModbusRTU mb;
-#endif
-
-/**
- * @brief The Modbus map for the Equipment device.
- * This array defines all the Modbus points available on the emulated device.
- * The `description` field is crucial as it's used to look up points within the application logic.
- */
-modbusMap mb_map[] =
-{   
-  {COIL,        0,      1,      "Chiller Start Command"},       // Use in Modscan - Hard IO in SCP, Used for Arduino simulation only. Signal should come from PLC.
-  {COIL,        1,      0,      "Sys 1 Alarm"},                 // Use in Modscan - Hard IO in SCP, Used for Arduino simulation only --> INDICATION ONLY (assumption)
-  {COIL,        2,      0,      "Sys 2 Alarm"},                 // Use in Modscan - Hard IO in SCP, Used for Arduino simulation only --> INDICATION ONLY (assumption)
-  {COIL,        3,      0,      "Sys 1 Fan Fault ON"},          // Use in Modscan - Used for Arduino simulation only --> FAILSTATE (assumption)
-  {COIL,        4,      0,      "Sys 2 Fan Fault ON"},          // Use in Modscan - Used for Arduino simulation only --> FAILSTATE (assumption)
-  {COIL,        5,      0,      "Free Cooling Mode ON"},        // Use in Modscan - Used for Arduino simulation only
-
-  {DI,          65,     0,      "General Alarm"},               // if any alarm is active, General Alarm = 1 --> used for INDICATION ONLY (assumption)
-  {DI,          174,    0,      "Sys 1 Fan Fault Alarm"},
-  {DI,          175,    0,      "Sys 2 Fan Fault Alarm"},
-
-  {IR,          130,    0,      "Free Cooling Mode"},     
-  {IR,          165,    0,      "Free Cooling Valve"},   
-
-  {HR,          0,      0,      "Chiller Status"},              // Use in Modscan - Hard IO in SCP, Used for Arduino simulation only
-  {HR,          1,      60,      "Chiller Temp Setpoint"},       // Use in Modscan - Hard IO in SCP, Used for Arduino simulation only
-  {HR,          2,      0,      "Supply Temp"},                 // Use in Modscan - Hard IO in SCP, Used for Arduino simulation only
-  {HR,          3,      0,      "Return Temp"},                 // Use in Modscan - Hard IO in SCP, Used for Arduino simulation only
-
-  {HR_10x,          4,    700,       "System CHW Out"},
-  {HR_10x,          5,    700,       "System CHW In"},
-  {HR_10x,      7,    0,        "Sys 1 Condenser Temp"},                   
-  {HR_10x,      9,    0,        "Ambient Temp"},                   
-
-  {HR_10x,      11,    0,       "Sys 1 Oil Pressure"},                             
-  {HR_10x,      12,    0,       "Sys 1 Suction Pressure"},
-  {HR_10x,      13,    0,       "Sys 1 Discharge Pressure"},
-  {HR_10x,      14,    0,       "Sys 1 Compressor Pct FLA"},                   
-  {HR,          15,    0,       "Sys 1 Run Hours"},                   
-  {HR,          16,    0,       "Sys 1 Starts"},           
-  
-  {HR_10x,      20,    0,       "Sys 2 Oil Pressure"},                             
-  {HR_10x,      21,    0,       "Sys 2 Suction Pressure"},
-  {HR_10x,      22,    0,       "Sys 2 Discharge Pressure"},
-  {HR_10x,      23,    0,       "Sys 2 Compressor Pct FLA"},                   
-  {HR,          24,    0,       "Sys 2 Run Hours"},                   
-  {HR,          25,    0,       "Sys 2 Starts"},  
-
-  {HR_10x,      26,    0,       "VSD Output Frequency"},           
-
-  {HR,          29,    77,      "Sys 1 Operational Code"},         // 77:not running, 78:running, 82:free cooling
-  {HR,          30,    0,       "Sys 1 Fault Code"},               // 56:condenser fan VSD warning
-  {HR,          31,    77,      "Sys 2 Operational Code"},         // 77:not running, 78:running, 82:free cooling
-  {HR,          32,    0,       "Sys 2 Fault Code"},               // 56:condenser fan VSD warning
-
-  {HR_10x,      39,    710,       "Local Leaving Temp Setpoint"},   // just an assumption
-
-  {HR_10x,      49,    0,       "Sys 2 Condenser Temp"},     
-  {HR_10x,      140,    0,      "Sys 1 Fan KW"},
-  {HR_10x,      141,    0,      "Sys 1 Compressor KW"},            
-  {HR_10x,      142,    0,      "Sys 2 Fan KW"},
-  {HR_10x,      143,    0,      "Sys 2 Compressor KW"},     
-
-};
-//Size of modbus map used in FOR cycles, automatically calculated.
-/**
- * @brief The total number of entries in the `mb_map` array.
- * This is calculated at compile time and used for iterating over the map.
- */
-const int map_size = sizeof(mb_map) / sizeof(mb_map[0]);
-
-/**
- * @brief The main loop update interval in milliseconds.
- */
-int interval = 250; 
-
-#endif // CONFIG_H
diff --git a/src/BMS/CHILLER/CH_York_YVAA_RTU/main.cpp b/src/BMS/CHILLER/CH_York_YVAA_RTU/main.cpp
deleted file mode 100644
index ec953c3..0000000
--- a/src/BMS/CHILLER/CH_York_YVAA_RTU/main.cpp
+++ /dev/null
@@ -1,78 +0,0 @@
-/**
- * @file main.cpp
- * @brief Main execution program for the York YVAA Chiller (RTU) Emulator.
- * @author Emmanuel Hernandez Cruz, Robert J. Davis
- * @date 2025-09-02
- *
- * @details This file contains the main execution program for an Arduino-based
- * emulator of a York YVAA Chiller unit. The program communicates via the
- * Modbus RTU protocol over a serial connection.
- *
- * The setup() function initializes the following:
- * - Serial communication for debugging.
- * - A Modbus RTU server with parameters from config.h.
- * - Modbus points (Coils, Holding Registers, etc.) based on a predefined map in config.h.
- *
- * The loop() function continuously:
- * - Services the Modbus RTU server to handle incoming requests.
- * - Periodically calls the main update loop for the emulated equipment, which
- *   manages state transitions and behavior strategies.
- *
- * @see config.h for Modbus RTU and register map configuration.
- * @see Equipment.h for the main equipment logic.
- * @see State.h for different equipment states.
- * @see Strategies/Strategy_Behavior.h for value generation strategies.
- * @see Modbus_Point.h for the base class for all Modbus points.
- */
-//=================================================================================================================================
-//Libraries and declaration of variables.
-#include <Arduino.h>
-#include "config.h"
-#include "ModbusPoints/Modbus_PointFactory.h"
-
-//=================================================================================================================================
-/** 
- * @brief Initializes the application.
- * @details This function runs once at startup. It configures the serial communication
- * for debugging and the Modbus RTU server. It then creates and initializes all
- * the Modbus points based on the `mb_map` array in `config.h`.
- */
-const int rtsPin = 4;
-void setup() {
-  Serial.begin(115200);
-  Serial.println("Setup function started");
-
-  Serial2.begin(BAUDRATE, SERIAL_8N1, RX_PIN, TX_PIN);
-  mb.begin(&Serial2, RST_PIN); // Start the server
-  mb.slave(MODBUS_ID); // Set the slave ID
-   
-  for(int i = 0; i < map_size; i++){
-    Modbus_Point<ModbusRTU>* point = createModbus_Point(&mb, mb_map[i].category, mb_map[i].address, mb_map[i].value, mb_map[i].description);
-    if (point) {
-      point->addToModbusServer();
-      EquipmentInstance.addModbus_Point(mb_map[i].description, point);
-    }
-  }
-  Serial.println("Setup function ended"); 
-}
-//=================================================================================================================================
-/** 
- * @brief The main application loop.
- * @details This function runs repeatedly after setup() has completed. It performs two main actions:
- * 1. It continuously services the Modbus server by calling `mb.task()` to handle
- *    incoming requests from a Modbus master.
- * 2. At a fixed interval (defined in `config.h`), it calls `EquipmentInstance.update()`
- *    to run the emulator's internal state machine and behavior logic.
- */
-void loop() {
-  mb.task();
-  unsigned long currentMillis = millis();
-  if (currentMillis - previousMillis >= interval) {
-    previousMillis = currentMillis;
-    unsigned long startTime = millis();
-    EquipmentInstance.update();
-    unsigned long endTime = millis();
-    unsigned long elapsedTime = endTime - startTime;
-    Serial.printf("Control Execution time: %d ms\n", elapsedTime);
-  } 
-}
diff --git a/src/BMS/CHILLER/CH_York_YVA_RTU_PHXA7/README.md b/src/BMS/CHILLER/CH_York_YVA_RTU_PHXA7/README.md
deleted file mode 100644
index 630cf02..0000000
--- a/src/BMS/CHILLER/CH_York_YVA_RTU_PHXA7/README.md
+++ /dev/null
@@ -1,35 +0,0 @@
-# EQUIPMENT_TYPE MANUFACTURER MODEL RTU
-
-## Brief Introduction
-Equipment specifc details that make it different from other devices
-
-## List of Equipmentt
-This cofiguration has been used for these models:
-* **Model**: 09-15-22 
-* **Model**: 09-15-23 
-* **Model**: 09-15-25 
-
-## Hardware Prerequisites
-
-The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities and at least one hardware serial port for RS485 communication.
-
-* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html) 
-* **RS485 Transceiver**: [RS485 Shield for Arduino.](https://www.dfrobot.com/product-1024.html)
-
----
-
-## States and Strategies
-Provide a brief description of what variables and strategies were used in this configuraiton
-
-### Standby State
-* **Equipment running**: set to 0
-* **Common Alarm**: set to 0
-* **SAT temperature**: set to 85
-
-### Running State
-* **Equipment running**: set to 1
-* **SAT temperature**: **Ramp Strategy** set to 65 deg setpoint
-
-### Fail State
-* **Commong Alarm**: set to 1
-* **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset
diff --git a/src/BMS/CHILLER/CH_York_YVA_RTU_PHXA7/State_Fail.cpp b/src/BMS/CHILLER/CH_York_YVA_RTU_PHXA7/State_Fail.cpp
deleted file mode 100644
index 6d85f9a..0000000
--- a/src/BMS/CHILLER/CH_York_YVA_RTU_PHXA7/State_Fail.cpp
+++ /dev/null
@@ -1,77 +0,0 @@
-/**
- * @file State_Fail.cpp
- * @brief Implementation of the FailState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the FailState, which defines
- * the behavior of the equipment when it has entered a fault condition.
- */
-#include "States/State_Standby.h"
-#include "States/State_Fail.h"
-#include "ModbusPoints/Modbus_Point.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_PID.h"
-
-#include <vector>
-#include <string>
-
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new FailState object.
- *
- * This constructor receives a list of alarm descriptions and creates strategies
- * to set the corresponding Modbus points to a value of 1, indicating an
- * active alarm. It also initializes a PID strategy for the valve position.
- */
-template<>
-FailState<ModbusRTU>::FailState(const std::vector<std::string>& activeAlarms) {
-    // Simulate a failure: set common alarm and a specific fan alarm.
-}
-
-/**
- * @brief Executes the fail state's logic for one update cycle.
- *
- * This method checks the "Clear Alm" Modbus point for a command to transition
- * back to Standby, which would typically happen after a fault is cleared by a
- * user. If no transition is requested, it continues to apply the failure strategies.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusRTU>* FailState<ModbusRTU>::update(Equipment<ModbusRTU>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Fail update function");
-    
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the fail state. Sets the main alarm bit.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusRTU>::enterState(Equipment<ModbusRTU>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Fail State...");
-    
-}
-
-/**
- * @brief Logic to execute once when exiting the fail state. Clears the main alarm bit.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusRTU>::exitState(Equipment<ModbusRTU>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Fail State...");
-    
-}
\ No newline at end of file
diff --git a/src/BMS/CHILLER/CH_York_YVA_RTU_PHXA7/State_Running.cpp b/src/BMS/CHILLER/CH_York_YVA_RTU_PHXA7/State_Running.cpp
deleted file mode 100644
index 4299d0b..0000000
--- a/src/BMS/CHILLER/CH_York_YVA_RTU_PHXA7/State_Running.cpp
+++ /dev/null
@@ -1,89 +0,0 @@
-/**
- * @file State_Running.cpp
- * @brief Implementation of the RunningState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the RunningState, which defines
- * the behavior of the equipment when it is actively running.
- */
-
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "Strategies/Strategy_Behavior.h"
-#include "Strategies/Strategy_PID.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Totalizer.h"
-#include "Equipment/Equipment.h"
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-
-#include <vector>
-#include <string>
-
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new RunningState object.
- *
- * This constructor initializes behavior strategies active during the running
- * state, such as a PID controller for the 'CW Valve Position' and totalizers
- * for the run-hours of each EC fan.
- */
-template<>
-RunningState<ModbusRTU>::RunningState() {
-    //Add strategies 
-    //addStrategy("Actual Capacity", new PIDStrategy("Active SP", 1000, "Supply Temp"));
-    
-}
-
-/**
- * @brief Executes the running state's logic for one update cycle.
- *
- * This method first checks for state transition commands:
- * 1. It reads the "ON/OFF Command By BMS" point. If it's 0, it transitions to StandbyState.
- * 2. It reads the "Fault Code" point. If it's non-zero, it transitions to FailState,
- *    passing the corresponding alarm description.
- *
- * If no transition occurs, it applies the strategies defined for the running state.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusRTU>* RunningState<ModbusRTU>::update(Equipment<ModbusRTU>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Running update function");
-    
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the running state.
- * Sets the "Chiller Sts" point to indicate the unit is running.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusRTU>::enterState(Equipment<ModbusRTU>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Running State...");
-    
-}
-
-/**
- * @brief Logic to execute once when exiting the running state.
- * Sets the "Chiller Sts" point to indicate the unit is no longer running.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusRTU>::exitState(Equipment<ModbusRTU>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Running State...");
-}
\ No newline at end of file
diff --git a/src/BMS/CHILLER/CH_York_YVA_RTU_PHXA7/State_Standby.cpp b/src/BMS/CHILLER/CH_York_YVA_RTU_PHXA7/State_Standby.cpp
deleted file mode 100644
index 4eff6ad..0000000
--- a/src/BMS/CHILLER/CH_York_YVA_RTU_PHXA7/State_Standby.cpp
+++ /dev/null
@@ -1,121 +0,0 @@
-/**
- * @file State_Standby.cpp
- * @brief Implementation of the StandbyState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the StandbyState, which defines
- * the behavior of the equipment when it is in an idle or standby mode.
- */
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Saw.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new StandbyState object.
- *
- * In this state, the equipment is idle. This constructor initializes several
- * strategies to generate random values for various status points, simulating
- * a live but non-operational unit.
- */
-template<>
-StandbyState<ModbusRTU>::StandbyState() {
-     addStrategy("Sts_EvapHeater", new SawStrategy(100.0f, 1000.0f, 12.0f, 1000));
-     addStrategy("Sts_EvapPump", new SawStrategy(100.0f, 1000.0f, 13.0f, 1000));
-     addStrategy("Sts_FlowSwitch", new SawStrategy(100.0f, 1000.0f, 14.0f, 1000));
-     addStrategy("Sts_AmbientTemp", new SawStrategy(100.0f, 1000.0f, 15.0f, 1000));
-     addStrategy("Sts_EvapTempIN", new SawStrategy(100.0f, 1000.0f, 16.0f, 1000));
-     addStrategy("Sts_EvapTempOUT", new SawStrategy(100.0f, 1000.0f, 17.0f, 1000));
-     addStrategy("Sts_VSD_Cmd_Hz", new SawStrategy(100.0f, 1000.0f, 18.0f, 1000));
-     addStrategy("Sts_VSD_FdbkHz", new SawStrategy(100.0f, 1000.0f, 19.0f, 1000));
-     addStrategy("Sts_Cond1Temp", new SawStrategy(100.0f, 1000.0f, 18.0f, 1000));
-     addStrategy("StS_Cond1FanSpd", new SawStrategy(100.0f, 1000.0f, 17.0f, 1000));
-     addStrategy("Sts_Cond2Temp", new SawStrategy(100.0f, 1000.0f, 16.0f, 1000));
-     addStrategy("Sts_Cond2FanSpd", new SawStrategy(100.0f, 1000.0f, 15.0f, 1000));
-     addStrategy("Sts_Comp1", new SawStrategy(100.0f, 1000.0f, 14.0f, 1000));
-     addStrategy("Sts_Comp1_DischargePressure", new SawStrategy(100.0f, 1000.0f, 13.0f, 1000));
-     addStrategy("Sts_Comp1_SuctionPressure", new SawStrategy(100.0f, 1000.0f, 12.0f, 1000));
-     addStrategy("Sts_Comp1_FLA", new SawStrategy(100.0f, 1000.0f, 11.0f, 1000));
-     addStrategy("Sts_Comp1Starts", new SawStrategy(100.0f, 1000.0f, 12.0f, 1000));
-     addStrategy("Sts_Comp2", new SawStrategy(100.0f, 1000.0f, 13.0f, 1000));
-     addStrategy("Sts_Comp2_DischargePressure", new SawStrategy(100.0f, 1000.0f, 14.0f, 1000));
-     addStrategy("Sts_Comp2_SuctionPressure", new SawStrategy(100.0f, 1000.0f, 15.0f, 1000));
-     addStrategy("Sts_Comp2_FLA", new SawStrategy(100.0f, 1000.0f, 16.0f, 1000));
-     addStrategy("Sts_Comp2Starts", new SawStrategy(100.0f, 1000.0f, 17.0f, 1000));
-     addStrategy("Sts_Sys1_DischPress", new SawStrategy(100.0f, 1000.0f, 18.0f, 1000));
-     addStrategy("Sts_Sys1_SuctPress", new SawStrategy(100.0f, 1000.0f, 19.0f, 1000));
-     addStrategy("Sts_Sys1_DischTemp", new SawStrategy(100.0f, 1000.0f, 18.0f, 1000));
-     addStrategy("Sts_Sys1_OilPress", new SawStrategy(100.0f, 1000.0f, 17.0f, 1000));
-     addStrategy("Sts_Sys1_EconValvePos", new SawStrategy(100.0f, 1000.0f, 16.0f, 1000));
-     addStrategy("Sts_Sys1_EductorTemp", new SawStrategy(100.0f, 1000.0f, 15.0f, 1000));
-     addStrategy("Sts_Sys1_MotorTemp", new SawStrategy(100.0f, 1000.0f, 14.0f, 1000));
-     addStrategy("Sts_Sys1_Runtime", new SawStrategy(100.0f, 1000.0f, 13.0f, 1000));
-     addStrategy("Sts_Sys1_FankW", new SawStrategy(100.0f, 1000.0f, 12.0f, 1000));
-     addStrategy("Sts_Sys1_CompkW", new SawStrategy(100.0f, 1000.0f, 11.0f, 1000));
-     addStrategy("Sts_Sys2_DischPress", new SawStrategy(100.0f, 1000.0f, 12.0f, 1000));
-     addStrategy("Sts_Sys2_SuctPress", new SawStrategy(100.0f, 1000.0f, 13.0f, 1000));
-     addStrategy("Sts_Sys2_DischTemp", new SawStrategy(100.0f, 1000.0f, 14.0f, 1000));
-     addStrategy("Sts_Sys2_OilPress", new SawStrategy(100.0f, 1000.0f, 15.0f, 1000));
-     addStrategy("Sts_Sys2_EconValvePos", new SawStrategy(100.0f, 1000.0f, 16.0f, 1000));
-     addStrategy("Sts_Sys2_EductorTemp", new SawStrategy(100.0f, 1000.0f, 17.0f, 1000));
-     addStrategy("Sts_Sys2_MotorTemp", new SawStrategy(100.0f, 1000.0f, 18.0f, 1000));
-     addStrategy("Sts_Sys2_Runtime", new SawStrategy(100.0f, 1000.0f, 19.0f, 1000));
-     addStrategy("Sts_Sys2_FankW", new SawStrategy(100.0f, 1000.0f, 18.0f, 1000));
-     addStrategy("Sts_Sys2_CompkW", new SawStrategy(100.0f, 1000.0f, 14.0f, 1000));
-     addStrategy("Temp_SP", new SingleValueStrategy(68.0f, 0.0f, 1000));
-}
- 
-
-/**
- * @brief Executes the standby state's logic for one update cycle.
- *
- * This method checks the "Chiller On-Off" Modbus point for a command to
- * transition to the Running state. If no transition is requested, it applies
- * the strategies defined for the standby state.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusRTU>* StandbyState<ModbusRTU>::update(Equipment<ModbusRTU>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Standby update function");
-    
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the standby state.
- * Sets the "Chiller Sts" point to indicate the unit is not running.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusRTU>::enterState(Equipment<ModbusRTU>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Standby State...");
-   
-}
-
-/**
- * @brief Logic to execute once when exiting the standby state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusRTU>::exitState(Equipment<ModbusRTU>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-   
-}
\ No newline at end of file
diff --git a/src/BMS/CHILLER/CH_York_YVA_RTU_PHXA7/config.h b/src/BMS/CHILLER/CH_York_YVA_RTU_PHXA7/config.h
deleted file mode 100644
index 8f0f15e..0000000
--- a/src/BMS/CHILLER/CH_York_YVA_RTU_PHXA7/config.h
+++ /dev/null
@@ -1,123 +0,0 @@
-/**
- * @file config.h
- * @brief Main configuration file for the Daikin Chiller (RTU) emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * This file contains important configurations for the Modbus RTU communication
- * and the specific register map for the emulated device.
- */
-
-#ifndef CONFIG_H
-#define CONFIG_H
-#include <ModbusRTU.h>
-#include "core.h"
-#include "Equipment/Equipment.h"
-
-
-#if defined(USE_MODBUS_IP)
-/**
-   * @defgroup ModbusTCPConfig Modbus IP Configuration
-   * @brief Parameters for Modbus TCP communication.
-   * @{
-   */
-  #include <ModbusIP_ESP8266.h>
-  const char *ssid = "Prime Guest";       /**< @brief The SSID of the WiFi network. */
-  const char *password = "Pr1meguest#";   /**< @brief The password for the WiFi network. */
-  IPAddress local_IP(192, 168, 103, 91);       /**< @brief The static IP address for the device. */
-  IPAddress gateway(192, 168, 103, 65);          /**< @brief The gateway IP address. */
-  IPAddress subnet(255, 255, 255, 0);         /**< @brief The subnet mask. */
-  
-  ModbusIP mb;
-#else
-  /**
-   * @defgroup ModbusRTUConfig Modbus RTU Configuration
-   * @brief Parameters for serial Modbus RTU communication.
-   * @{
-   */
-  #include <ModbusRTU.h>
-  const int BAUDRATE = 19200;   /**< @brief The serial communication speed in bits per second. */
-  const int RX_PIN = 17;        /**< @brief The GPIO pin used for receiving data (RX). */
-  const int TX_PIN = 16;        /**< @brief The GPIO pin used for transmitting data (TX). */
-  const int RST_PIN = 4;        /**< @brief The GPIO pin connected to the RS485 driver's DE/RE pins for direction control. */
-  const int MODBUS_ID = 11;      /**< @brief The unique slave ID for this device on the Modbus bus. */
-  /** @} */
-
-  /** @brief Global instance of the Modbus RTU server. */
-  ModbusRTU mb;
-#endif
-
-/**
- * @brief The Modbus map for the Equipment device.
- * This array defines all the Modbus points available on the emulated device.
- * The `description` field is crucial as it's used to look up points within the application logic.
- */
-modbusMap mb_map[] =
-{   
-  {HR,        45,    0,  "Temp_SP"},
-  {HR,        66,    0,  "Sts_EvapHeater"},
-  {HR,        67,    0,  "Sts_EvapPump"},
-  {HR,        86,    0,  "Sts_FlowSwitch"},
-  {HR,        9,     0,  "Sts_AmbientTemp"},
-  {HR,        5,     0,  "Sts_EvapTempIN"},
-  {HR,        4,     0,  "Sts_EvapTempOUT"},
-  {HR,        126,   0,  "Sts_VSD_CmdHz"},
-  {HR,        26,    0,  "Sts_VSD_FdbkHz"},
-  {HR,        7,     0,  "Sts_Cond1Temp"},
-  {HR,        119,   0,  "Sts_Cond1FanSpd"},
-  {HR,        49,    0,  "Sts_Cond2Temp"},
-  {HR,        120,   0,  "Sts_Cond2FanSpd"},
-  {HR,        68,    0,  "Sts_Comp1"},
-  {HR,        13,    0,  "Sts_Comp1_DischargePresure"},
-  {HR,        12,    0,  "Sts_Comp1_SuctionPresure"},
-  {HR,        14,    0,  "Sts_Comp1_FLA"},
-  {HR,        16,    0,  "Sts_Comp1Starts"},
-  {HR,        69,    0,  "Sts_Comp2"},
-  {HR,        22,    0,  "Sts_Comp2_DischargePresure"},
-  {HR,        21,    0,  "Sts_Comp2_SuctionPresure"},
-  {HR,        23,    0,  "Sts_Comp2_FLA"},
-  {HR,        25,    0,  "Sts_Comp2Starts"},
-  {HR,        13,    0,  "Sts_Sys1_DischPress"},
-  {HR,        12,    0,  "Sts_Sys1_SuctPress"},
-  {HR,        8,     0,  "Sts_Sys1_DischTemp"},
-  {HR,        11,    0,  "Sts_Sys1_OilPress"},
-  {HR,        41,    0,  "Sts_Sys1_EconValvePos"},
-  {HR,        10,    0,  "Sts_Sys1_EductorTemp"},
-  {HR,        17,    0,  "Sts_Sys1_MotorTemp"},
-  {HR,        29,    0,  "Sts_Sys1_OpCode"},
-  {HR,        30,    0,  "Sts_Sys1_FaultCode"},
-  {HR,        15,    0,  "Sts_Sys1_Runtime"},
-  {HR,        140,   0,  "Sts_Sys1_FankW"},
-  {HR,        142,   0,  "Sts_Sys1_CompkW"},
-  {HR,        23,    0,  "Sts_Sys2_DischPress"},
-  {HR,        22,    0,  "Sts_Sys2_SuctPress"},
-  {HR,        50,    0,  "Sts_Sys2_DischTemp"},
-  {HR,        20,    0,  "Sts_Sys2_OilPress"},
-  {HR,        42,    0,  "Sts_Sys2_EconValvePos"},
-  {HR,        19,    0,  "Sts_Sys2_EductorTemp"},
-  {HR,        18,    0,  "Sts_Sys2_MotorTemp"},
-  {HR,        31,    0,  "Sts_Sys2_OpCode"},
-  {HR,        32,    0,  "Sts_Sys2_FaultCode"},
-  {HR,        24,    0,  "Sts_Sys2_Runtime"},
-  {HR,        142,   0,  "Sts_Sys2_FankW"},
-  {HR,        143,   0,  "Sts_Sys2_CompkW"},
-  {HR,        65,    0,  "Alm_Summary"},
-  {HR,        84,    0,  "Alm_Sys1_Lockout"},
-  {HR,        85,    0,  "Alm_Sys2_Lockout"},
-  {HR,        174,   0,  "Alm_Cond1_FanFlt"},
-  {HR,        175,   0,  "Alm_Cond2_FanFlt"},
-};                     
- 
-//Size of modbus map used in FOR cycles, automatically calculated.
-/**
- * @brief The total number of entries in the `mb_map` array.
- * This is calculated at compile time and used for iterating over the map.
- */
-const int map_size = sizeof(mb_map) / sizeof(mb_map[0]);
-
-/**
- * @brief The main loop update interval in milliseconds.
- */
-int interval = 250; 
-
-#endif // CONFIG_H
diff --git a/src/BMS/CHILLER/CH_York_YVA_RTU_PHXA7/main.cpp b/src/BMS/CHILLER/CH_York_YVA_RTU_PHXA7/main.cpp
deleted file mode 100644
index 5dbc9f1..0000000
--- a/src/BMS/CHILLER/CH_York_YVA_RTU_PHXA7/main.cpp
+++ /dev/null
@@ -1,78 +0,0 @@
-/**
- * @file main.cpp
- * @brief Main execution program for the Daikin Chiller (RTU) Emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * @details This file contains the main execution program for an Arduino-based
- * emulator of a Daikin Chiller unit. The program communicates via the
- * Modbus RTU protocol over a serial connection.
- *
- * The setup() function initializes the following:
- * - Serial communication for debugging.
- * - A Modbus RTU server with parameters from config.h.
- * - Modbus points (Coils, Holding Registers, etc.) based on a predefined map in config.h.
- *
- * The loop() function continuously:
- * - Services the Modbus RTU server to handle incoming requests.
- * - Periodically calls the main update loop for the emulated equipment, which
- *   manages state transitions and behavior strategies.
- *
- * @see config.h for Modbus RTU and register map configuration.
- * @see Equipment.h for the main equipment logic.
- * @see State.h for different equipment states.
- * @see Strategies/Strategy_Behavior.h for value generation strategies.
- * @see Modbus_Point.h for the base class for all Modbus points.
- */
-//=================================================================================================================================
-//Libraries and declaration of variables.
-#include <Arduino.h>
-#include "config.h"
-#include "ModbusPoints/Modbus_PointFactory.h"
-
-//=================================================================================================================================
-/** 
- * @brief Initializes the application.
- * @details This function runs once at startup. It configures the serial communication
- * for debugging and the Modbus RTU server. It then creates and initializes all
- * the Modbus points based on the `mb_map` array in `config.h`.
- */
-const int rtsPin = 4;
-void setup() {
-  Serial.begin(115200);
-  Serial.println("Setup function started");
-
-  Serial2.begin(BAUDRATE, SERIAL_8N1, RX_PIN, TX_PIN);
-  mb.begin(&Serial2, RST_PIN); // Start the server
-  mb.slave(MODBUS_ID); // Set the slave ID
-   
-  for(int i = 0; i < map_size; i++){
-    Modbus_Point<ModbusRTU>* point = createModbus_Point(&mb, mb_map[i].category, mb_map[i].address, mb_map[i].value, mb_map[i].description);
-    if (point) {
-      point->addToModbusServer();
-      EquipmentInstance.addModbus_Point(mb_map[i].description, point);
-    }
-  }
-  Serial.println("Setup function ended"); 
-}
-//=================================================================================================================================
-/** 
- * @brief The main application loop.
- * @details This function runs repeatedly after setup() has completed. It performs two main actions:
- * 1. It continuously services the Modbus server by calling `mb.task()` to handle
- *    incoming requests from a Modbus master.
- * 2. At a fixed interval (defined in `config.h`), it calls `EquipmentInstance.update()`
- *    to run the emulator's internal state machine and behavior logic.
- */
-void loop() {
-  mb.task();
-  unsigned long currentMillis = millis();
-  if (currentMillis - previousMillis >= interval) {
-    previousMillis = currentMillis;
-    unsigned long startTime = millis();
-    EquipmentInstance.update();
-    unsigned long endTime = millis();
-    unsigned long elapsedTime = endTime - startTime;
-    Serial.printf("Control Execution time: %d ms\n", elapsedTime);
-  } 
-}
diff --git a/src/BMS/CRAC/CRAC_Munters_SysCooll_TCP/README.md b/src/BMS/CRAC/CRAC_Munters_SysCooll_TCP/README.md
deleted file mode 100644
index 355156f..0000000
--- a/src/BMS/CRAC/CRAC_Munters_SysCooll_TCP/README.md
+++ /dev/null
@@ -1,33 +0,0 @@
-# EQUIPMENT_TYPE MANUFACTURER MODEL TCP
-
-## Brief Introduction
-Equipment specifc details that make it different from other devices
-
-## List of Equipmentt
-This cofiguration has been used for these models:
-* **Model**: 09-15-22 
-* **Model**: 09-15-23 
-* **Model**: 09-15-25 
-
-## Hardware Prerequisites
-
-The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities.
-* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html) 
-
----
-
-## States and Strategies
-Provide a brief description of what variables and strategies were used in this configuraiton
-
-### Standby State
-* **Equipment running**: set to 0
-* **Common Alarm**: set to 0
-* **SAT temperature**: set to 85
-
-### Running State
-* **Equipment running**: set to 1
-* **SAT temperature**: **Ramp Strategy** set to 65 deg setpoint
-
-### Fail State
-* **Commong Alarm**: set to 1
-* **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset
diff --git a/src/BMS/CRAC/CRAC_Munters_SysCooll_TCP/State_Fail.cpp b/src/BMS/CRAC/CRAC_Munters_SysCooll_TCP/State_Fail.cpp
deleted file mode 100644
index 8bc0385..0000000
--- a/src/BMS/CRAC/CRAC_Munters_SysCooll_TCP/State_Fail.cpp
+++ /dev/null
@@ -1,81 +0,0 @@
-/**
- * @file State_Fail.cpp
- * @brief Implementation of the FailState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the FailState, which defines
- * the behavior of the equipment when it has entered a fault condition.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new FailState object with a list of active alarms.
- *
- * This constructor receives a list of alarm descriptions and creates strategies
- * to set the corresponding Modbus points to a value of 1, indicating an
- * active alarm. It also initializes a PID strategy for the 'CW Valve Position'
- * to maintain its state during the fault.
- * @param activeAlarms A vector of strings, where each string is the
- *                     description of a Modbus point to be set as an active alarm.
- */
-template<>
-FailState<ModbusIP>::FailState(const std::vector<std::string>& activeAlarms) {
-    // Simulate a failure: set common alarm and a specific fan alarm.
-
-    
-}
-
-/**
- * @brief Executes the fail state's logic for one update cycle.
- *
- * This method checks the "Alarm Reset" Modbus point for a command to
- * transition back to Standby, which would typically happen after a fault
- * is cleared by a user. If no transition is requested, it continues to apply
- * the failure strategies (e.g., keeping alarm bits active).
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* FailState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Fail update function");
-    
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the fail state.
- * Sets the "Alarm Common" point to 1 to indicate a general fault condition.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Fail State...");
-}
-
-/**
- * @brief Logic to execute once when exiting the fail state.
- * Clears the "Alarm Common" point to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Fail State...");
-}
\ No newline at end of file
diff --git a/src/BMS/CRAC/CRAC_Munters_SysCooll_TCP/State_Running.cpp b/src/BMS/CRAC/CRAC_Munters_SysCooll_TCP/State_Running.cpp
deleted file mode 100644
index b9e4a99..0000000
--- a/src/BMS/CRAC/CRAC_Munters_SysCooll_TCP/State_Running.cpp
+++ /dev/null
@@ -1,89 +0,0 @@
-/**
- * @file State_Running.cpp
- * @brief Implementation of the RunningState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the RunningState, which defines
- * the behavior of the equipment when it is actively running.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "Strategies/Strategy_Totalizer.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new RunningState object.
- *
- * This constructor initializes behavior strategies active during the running
- * state, such as a PID controller for the 'CW Valve Position' and totalizers
- * for the run-hours of each EC fan.
- */
-template<>
-RunningState<ModbusIP>::RunningState() {
-}
-
-/**
- * @brief Executes the running state's logic for one update cycle.
- *
- * This method first checks for state transition commands:
- * 1. It reads the "ON/OFF Command By BMS" point. If it's 0, it transitions to StandbyState.
- * 2. It reads the "Fault Code" point. If it's non-zero, it transitions to FailState,
- *    passing the corresponding alarm description.
- *
- * If no transition occurs, it applies the strategies defined for the running state.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* RunningState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Running update function");
-    
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the running state.
- * Sets the "Run Status" for all EC fans to 1 to indicate they are active.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Running State...");
-    // You could also update a Modbus register to show the "standby" state
-
-}
-
-/**
- * @brief Logic to execute once when exiting the running state.
- * Sets the "Run Status" for all EC fans to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Running State...");
-   
-}
\ No newline at end of file
diff --git a/src/BMS/CRAC/CRAC_Munters_SysCooll_TCP/State_Standby.cpp b/src/BMS/CRAC/CRAC_Munters_SysCooll_TCP/State_Standby.cpp
deleted file mode 100644
index 20029d1..0000000
--- a/src/BMS/CRAC/CRAC_Munters_SysCooll_TCP/State_Standby.cpp
+++ /dev/null
@@ -1,85 +0,0 @@
-/**
- * @file State_Standby.cpp
- * @brief Implementation of the StandbyState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the StandbyState, which defines
- * the behavior of the equipment when it is in an idle or standby mode.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-/**
- * @brief Constructs a new StandbyState object.
- *
- * In this state, the equipment is idle. This constructor initializes strategies
- * to bring the system to a safe, idle condition. It sets a stable value for
- * the SAT reading and creates ramp strategies to bring the CW valve and all
- * EC fan speeds down to zero.
- */
-template<>
-StandbyState<ModbusIP>::StandbyState() {
-    // You can add initialization code here if needed
-    
-
-}
-
-/**
- * @brief Executes the standby state's logic for one update cycle.
- *
- * This method applies the strategies defined for the standby state (e.g.,
- * ramping values to zero).
- *
- * @warning This method currently does not check for a command to transition to the
- *          Running state. This logic needs to be added to allow the unit to start.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* StandbyState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Standby update function");
-    
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the standby state.
- * This method performs cleanup by setting all alarm points and all EC fan
- * run status points to 0.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Standby State...");
-}
-
-/**
- * @brief Logic to execute once when exiting the standby state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Standby State...");
-}
\ No newline at end of file
diff --git a/src/BMS/CRAC/CRAC_Munters_SysCooll_TCP/config.h b/src/BMS/CRAC/CRAC_Munters_SysCooll_TCP/config.h
deleted file mode 100644
index ce882e2..0000000
--- a/src/BMS/CRAC/CRAC_Munters_SysCooll_TCP/config.h
+++ /dev/null
@@ -1,262 +0,0 @@
-/**
- * @file config.h
- * @brief Main configuration file for the CRAC Munters SysCooll
- * @author Zach Gutierrez
- * @date 2025-09-02
- *
- * This file contains two important configurations: WiFi network parameters
- * and the Modbus register map for the device.
- */
-
-#ifndef CONFIG_H
-#define CONFIG_H
-
-#include "core.h"
-#include "Equipment/Equipment.h"
-
-#if defined(USE_MODBUS_IP)
-/**
-   * @defgroup ModbusTCPConfig Modbus IP Configuration
-   * @brief Parameters for Modbus TCP communication.
-   * @{
-   */
-  #include <ModbusIP_ESP8266.h>
-  const char *ssid = "Wifi1";       /**< @brief The SSID of the WiFi network. */
-  const char *password = "123abc456";   /**< @brief The password for the WiFi network. */
-  IPAddress local_IP(172, 17, 22, 130);       /**< @brief The static IP address for the device. */
-  IPAddress gateway(172, 17, 22, 254);          /**< @brief The gateway IP address. */
-  IPAddress subnet(255, 255, 255, 0);         /**< @brief The subnet mask. */
-  
-  ModbusIP mb;
-#else
-  /**
-   * @defgroup ModbusRTUConfig Modbus RTU Configuration
-   * @brief Parameters for serial Modbus RTU communication.
-   * @{
-   */
-  #include <ModbusRTU.h>
-  const int BAUDRATE = 19200;   /**< @brief The serial communication speed in bits per second. */
-  const int RX_PIN = 17;        /**< @brief The GPIO pin used for receiving data (RX). */
-  const int TX_PIN = 16;        /**< @brief The GPIO pin used for transmitting data (TX). */
-  const int RST_PIN = 4;        /**< @brief The GPIO pin connected to the RS485 driver's DE/RE pins for direction control. */
-  const int MODBUS_ID = 1;      /**< @brief The unique slave ID for this device on the Modbus bus. */
-  /** @} */
-
-  /** @brief Global instance of the Modbus RTU server. */
-  ModbusRTU mb;
-#endif
-
-
-
-/**
- * @defgroup ModbusMapConfig Modbus Map Configuration
- * @brief Defines the Modbus register map and related parameters for the emulator.
- * @{
- */
-/**
- * @brief The Modbus map for the Equipment device.
- * This array defines all the Modbus points available on the emulated device.
- * The `description` field is crucial as it's used to look up points within the application logic.
- */
-modbusMap mb_map[] = {
-  {COIL, 0, 0, "Start_CMD" },
-  {COIL, 1, 0, "Reset_CMD" },
-  {COIL, 2, 0, "Start_CMD" },
-  {COIL, 3, 0, "Reset_CMD" },
-  {DI, 2, 0, "BldgSafety" },
-  {DI, 31, 0, "SystemOnSts" },
-  {DI, 35, 0, "CoolingStatus" },
-  {DI, 42, 0, "ComAlm" },
-  {DI, 43, 0, "TSAlerts" },
-  {DI, 44, 0, "DXAlerts" },
-  {DI, 45, 0, "PwrMonAlm" },
-  {DI, 101, 0, "RAFilterAlm" },
-  {DI, 126, 0, "SmokeAlm" },
-  {DI, 171, 0, "SACmnAlm" },
-  {DI, 112, 0, "FanDPASnsr" },
-  {DI, 113, 0, "FanDPBSnsr" },
-  {DI, 66, 0, "CondComsLost" },
-  {DI, 4, 0, "HPSwitchCkt1" },
-  {DI, 5, 0, "HPSwitchCkt2" },
-  {DI, 6, 0, "HPSwitchCkt3" },
-  {DI, 7, 0, "HPSwitchCkt4" },
-  {DI, 19, 0, "Comp1AEnable" },
-  {DI, 8, 0, "Comp1Status" },
-  {DI, 160, 0, "Comp1A Alm" },
-  {DI, 21, 0, "Comp1BEnable" },
-  {DI, 9, 0, "Comp1BStatus" },
-  {DI, 161, 0, "Comp1BAlm" },
-  {DI, 22, 0, "Comp2AEnable" },
-  {DI, 13, 0, "Comp2AStatus" },
-  {DI, 162, 0, "Comp2AAlm" },
-  {DI, 23, 0, "Comp2BEnable" },
-  {DI, 14, 0, "Comp2BStatus" },
-  {DI, 163, 0, "Comp2BAlm" },
-  {DI, 24, 0, "Comp3AEnable" },
-  {DI, 15, 0, "Comp3AStatus" },
-  {DI, 164, 0, "Comp3AAlm" },
-  {DI, 25, 0, "Comp3BEnable" },
-  {DI, 16, 0, "Comp3BStatus" },
-  {DI, 165, 0, "Comp3BAlm" },
-  {DI, 26, 0, "Comp4AEnable" },
-  {DI, 17, 0, "Comp4AStatus" },
-  {DI, 166, 0, "Comp4AAlm" },
-  {DI, 28, 0, "Comp4BEnable" },
-  {DI, 18, 0, "Comp4BStatus" },
-  {DI, 167, 0, "Comp4BAlm" },
-  {DI, 47, 0, "Fan1AAlm" },
-  {DI, 48, 0, "Fan1BAlm" },
-  {DI, 49, 0, "Fan1CAlm" },
-  {DI, 50, 0, "Fan1DAlm" },
-  {DI, 51, 0, "Fan1EAlm" },
-  {DI, 52, 0, "Fan1FAlm" },
-  {DI, 53, 0, "Fan1GAlm" },
-  {DI, 54, 0, "Fan1HAlm" },
-  {DI, 57, 0, "Fan2AAlm" },
-  {DI, 58, 0, "Fan2BAlm" },
-  {DI, 59, 0, "Fan2CAlm" },
-  {DI, 60, 0, "Fan2DAlm" },
-  {DI, 61, 0, "Fan2EAlm" },
-  {DI, 62, 0, "Fan2FAlm" },
-  {DI, 63, 0, "Fan2GAlm" },
-  {DI, 64, 0, "Fan2HAlm" },
-  {DI, 55, 0, "SAFlowAlm" },
-  {DI, 56, 0, "SAFansAlm" },
-  {DI, 75, 0, "Ckt1LoWrn" },
-  {DI, 83, 0, "Ckt2LoWrn" },
-  {DI, 90, 0, "Ckt3LoWrn" },
-  {DI, 97, 0, "Ckt4LoWrn" },
-  {DI, 104, 0, "RA_FAULT_1" },
-  {DI, 105, 0, "RA_FAULT_2" },
-  {DI, 246, 0, "Cond2AStatus" },
-  {DI, 249, 0, "Cond2BStatus" },
-  {DI, 252, 0, "Cond2CStatus" },
-  {DI, 255, 0, "Cond2DStatus" },
-  {DI, 258, 0, "Cond2EStatus" },
-  {DI, 261, 0, "Cond2FStatus" },
-  {DI, 264, 0, "Cond2GStatus" },
-  {DI, 267, 0, "Cond2Status" },
-  {DI, 65, 0, "CondFansAlm" },
-  {DI, 123, 0, "CondPot" },
-  {DI, 243, 0, "SupFan1ASts" },
-  {DI, 180, 0, "SupFan1BSts" },
-  {DI, 189, 0, "SupFan1CSts" },
-  {DI, 198, 0, "SupFan1DSts" },
-  {DI, 207, 0, "SupFan1ESts" },
-  {DI, 216, 0, "SupFan1FSts" },
-  {DI, 225, 0, "SupFan1GSts" },
-  {DI, 234, 0, "SupFan1HSts" },
-  {IR, 1, 0, "OA Temp" },
-  {IR, 2, 0, "OA Temp" },
-  {IR, 3, 0, "Ckt1 DisPrs" },
-  {IR, 4, 0, "Ckt1 DisPrs" },
-  {IR, 7, 0, "Ckt2 DisPrs" },
-  {IR, 8, 0, "Ckt2 DisPrs" },
-  {IR, 9, 0, "Ckt3 DisPrs" },
-  {IR, 10, 0, "Ckt3 DisPrs" },
-  {IR, 11, 0, "Ckt4 DisPrs" },
-  {IR, 12, 0, "Ckt4 DisPrs" },
-  {IR, 19, 0, "RA Hum" },
-  {IR, 20, 0, "RA Hum" },
-  {IR, 25, 0, "RA Temp1" },
-  {IR, 26, 0, "RA Temp1" },
-  {IR, 27, 0, "RA Temp2" },
-  {IR, 28, 0, "RA Temp2" },
-  {IR, 33, 0, "RF Diff" },
-  {IR, 34, 0, "RF Diff" },
-  {IR, 37, 0, "SF Diff" },
-  {IR, 38, 0, "SF Diff" },
-  {IR, 37, 0, "RA FilterDP" },
-  {IR, 38, 0, "RA FilterDP" },
-  {IR, 105, 0, "RA Temp Avg" },
-  {IR, 106, 0, "RA Temp Avg" },
-  {IR, 107, 0, "SA Temp Avg" },
-  {IR, 108, 0, "SA Temp Avg" },
-  {IR, 113, 0, "SA Flow Total MSB" },
-  {IR, 114, 0, "SA Flow Total LSB" },
-  {IR, 133, 0, "RA Dew Calc" },
-  {IR, 134, 0, "RA Dew Calc" },
-  {IR, 143, 0, "Clg Pcnt" },
-  {IR, 144, 0, "Clg Pcnt" },
-  {IR, 147, 0, "TS1 Low" },
-  {IR, 148, 0, "TS1 Low" },
-  {IR, 149, 0, "TS1 Up" },
-  {IR, 150, 0, "TS1 Up" },
-  {IR, 151, 0, "TS2 Low" },
-  {IR, 152, 0, "TS2 Low" },
-  {IR, 153, 0, "TS2 Up" },
-  {IR, 154, 0, "TS2 Up" },
-  {IR, 155, 0, "Sys Stat" },
-  {IR, 156, 0, "" },
-  {IR, 185, 0, "Fan1B Spd MSB" },
-  {IR, 186, 0, "Fan1B Spd LSB" },
-  {IR, 197, 0, "Fan1C Spd MSB" },
-  {IR, 198, 0, "Fan1C Spd LSB" },
-  {IR, 205, 0, "Fan1D Spd MSB" },
-  {IR, 206, 0, "Fan1D Spd LSB" },
-  {IR, 221, 0, "Fan1E Spd MSB" },
-  {IR, 222, 0, "Fan1E Spd LSB" },
-  {IR, 233, 0, "Fan1F Spd MSB" },
-  {IR, 234, 0, "Fan1F Spd LSB" },
-  {IR, 245, 0, "Fan1G Spd MSB" },
-  {IR, 246, 0, "Fan1G Spd LSB" },
-  {IR, 257, 0, "Fan1H Spd MSB" },
-  {IR, 258, 0, "Fan1H Spd LSB" },
-  {IR, 269, 0, "Fan1A Spd MSB" },
-  {IR, 270, 0, "Fan1A Spd LSB" },
-  {IR, 426, 0, "EVM1SuctPrsA" },
-  {IR, 427, 0, "EVM1SuctPrsA" },
-  {IR, 428, 0, "EVM1SuctPrsB" },
-  {IR, 429, 0, "EVM1SuctPrsB" },
-  {IR, 430, 0, "EVM1SuctTmpA" },
-  {IR, 431, 0, "EVM1SuctTmpA" },
-  {IR, 432, 0, "EVM1SuctTmpB" },
-  {IR, 433, 0, "EVM1SuctTmpB" },
-  {IR, 438, 0, "EVM1ValveA" },
-  {IR, 439, 0, "EVM1ValveA" },
-  {IR, 440, 0, "EVM1ValveB" },
-  {IR, 441, 0, "EVM1ValveB" },
-  {IR, 462, 0, "EVM3SuctPrsA" },
-  {IR, 463, 0, "EVM3SuctPrsA" },
-  {IR, 464, 0, "EVM3SuctPrsB" },
-  {IR, 465, 0, "EVM3SuctPrsB" },
-  {IR, 466, 0, "EVM3SuctTmpA" },
-  {IR, 467, 0, "EVM3SuctTmpA" },
-  {IR, 468, 0, "EVM3SuctTmpB" },
-  {IR, 469, 0, "EVM3SuctTmpB" },
-  {IR, 474, 0, "EVM3Valve A" },
-  {IR, 475, 0, "EVM3Valve A" },
-  {IR, 476, 0, "EVM3Valve B" },
-  {IR, 477, 0, "EVM3Valve B" },
-  {IR, 526, 0, "EVM1ErrCode" },
-  {IR, 527, 0, "EVM2ErrCode" },
-  {IR, 528, 0, "EVM3ErrCode" },
-  {IR, 529, 0, "EVM4ErrCode" },
-  {HR, 1, 0, "RATemp SP" },
-  {HR, 2, 0, "RATemp SP" },
-  {HR, 3, 0, "SATemp SP" },
-  {HR, 4, 0, "SATemp SP" },
-  {HR, 5, 0, "SATemp DF" },
-  {HR, 6, 0, "SATemp DF" },
-  {HR, 7, 0, "SAFSpdSP" },
-  {HR, 8, 0, "SAFSpdSP" },
-  {HR, 9, 0, "SAFlMaxSpdSP" },
-  {HR, 10, 0, "SAFlMaxSpdSP" },
-  {HR, 11, 0, "SAFlMinSpdSP" },
-  {HR, 12, 0, "SAFlMinSpdSP" },
-  {HR, 13, 0, "RAFltrDPSP" },
-  {HR, 14, 0, "RAFltrDPSP" },
-};
-//Size of modbus map used in FOR cycles, automatically calculated.
-
-/**
- * @brief The total number of entries in the `mb_map` array.
- * This is calculated at compile time and used for iterating over the map.
- */
-const int map_size = sizeof(mb_map) / sizeof(mb_map[0]);
-
-/** @brief The main loop update interval in milliseconds. */
-int interval = 250; 
-/** @} */ // End of ModbusMapConfig group
-
-#endif // CONFIG_H
diff --git a/src/BMS/CRAH/CRAH_HTS_PLC_TCP/README.md b/src/BMS/CRAH/CRAH_HTS_PLC_TCP/README.md
deleted file mode 100644
index 355156f..0000000
--- a/src/BMS/CRAH/CRAH_HTS_PLC_TCP/README.md
+++ /dev/null
@@ -1,33 +0,0 @@
-# EQUIPMENT_TYPE MANUFACTURER MODEL TCP
-
-## Brief Introduction
-Equipment specifc details that make it different from other devices
-
-## List of Equipmentt
-This cofiguration has been used for these models:
-* **Model**: 09-15-22 
-* **Model**: 09-15-23 
-* **Model**: 09-15-25 
-
-## Hardware Prerequisites
-
-The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities.
-* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html) 
-
----
-
-## States and Strategies
-Provide a brief description of what variables and strategies were used in this configuraiton
-
-### Standby State
-* **Equipment running**: set to 0
-* **Common Alarm**: set to 0
-* **SAT temperature**: set to 85
-
-### Running State
-* **Equipment running**: set to 1
-* **SAT temperature**: **Ramp Strategy** set to 65 deg setpoint
-
-### Fail State
-* **Commong Alarm**: set to 1
-* **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset
diff --git a/src/BMS/CRAH/CRAH_HTS_PLC_TCP/State_Fail.cpp b/src/BMS/CRAH/CRAH_HTS_PLC_TCP/State_Fail.cpp
deleted file mode 100644
index 8bc0385..0000000
--- a/src/BMS/CRAH/CRAH_HTS_PLC_TCP/State_Fail.cpp
+++ /dev/null
@@ -1,81 +0,0 @@
-/**
- * @file State_Fail.cpp
- * @brief Implementation of the FailState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the FailState, which defines
- * the behavior of the equipment when it has entered a fault condition.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new FailState object with a list of active alarms.
- *
- * This constructor receives a list of alarm descriptions and creates strategies
- * to set the corresponding Modbus points to a value of 1, indicating an
- * active alarm. It also initializes a PID strategy for the 'CW Valve Position'
- * to maintain its state during the fault.
- * @param activeAlarms A vector of strings, where each string is the
- *                     description of a Modbus point to be set as an active alarm.
- */
-template<>
-FailState<ModbusIP>::FailState(const std::vector<std::string>& activeAlarms) {
-    // Simulate a failure: set common alarm and a specific fan alarm.
-
-    
-}
-
-/**
- * @brief Executes the fail state's logic for one update cycle.
- *
- * This method checks the "Alarm Reset" Modbus point for a command to
- * transition back to Standby, which would typically happen after a fault
- * is cleared by a user. If no transition is requested, it continues to apply
- * the failure strategies (e.g., keeping alarm bits active).
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* FailState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Fail update function");
-    
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the fail state.
- * Sets the "Alarm Common" point to 1 to indicate a general fault condition.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Fail State...");
-}
-
-/**
- * @brief Logic to execute once when exiting the fail state.
- * Clears the "Alarm Common" point to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Fail State...");
-}
\ No newline at end of file
diff --git a/src/BMS/CRAH/CRAH_HTS_PLC_TCP/State_Running.cpp b/src/BMS/CRAH/CRAH_HTS_PLC_TCP/State_Running.cpp
deleted file mode 100644
index b9e4a99..0000000
--- a/src/BMS/CRAH/CRAH_HTS_PLC_TCP/State_Running.cpp
+++ /dev/null
@@ -1,89 +0,0 @@
-/**
- * @file State_Running.cpp
- * @brief Implementation of the RunningState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the RunningState, which defines
- * the behavior of the equipment when it is actively running.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "Strategies/Strategy_Totalizer.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new RunningState object.
- *
- * This constructor initializes behavior strategies active during the running
- * state, such as a PID controller for the 'CW Valve Position' and totalizers
- * for the run-hours of each EC fan.
- */
-template<>
-RunningState<ModbusIP>::RunningState() {
-}
-
-/**
- * @brief Executes the running state's logic for one update cycle.
- *
- * This method first checks for state transition commands:
- * 1. It reads the "ON/OFF Command By BMS" point. If it's 0, it transitions to StandbyState.
- * 2. It reads the "Fault Code" point. If it's non-zero, it transitions to FailState,
- *    passing the corresponding alarm description.
- *
- * If no transition occurs, it applies the strategies defined for the running state.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* RunningState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Running update function");
-    
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the running state.
- * Sets the "Run Status" for all EC fans to 1 to indicate they are active.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Running State...");
-    // You could also update a Modbus register to show the "standby" state
-
-}
-
-/**
- * @brief Logic to execute once when exiting the running state.
- * Sets the "Run Status" for all EC fans to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Running State...");
-   
-}
\ No newline at end of file
diff --git a/src/BMS/CRAH/CRAH_HTS_PLC_TCP/State_Standby.cpp b/src/BMS/CRAH/CRAH_HTS_PLC_TCP/State_Standby.cpp
deleted file mode 100644
index 20029d1..0000000
--- a/src/BMS/CRAH/CRAH_HTS_PLC_TCP/State_Standby.cpp
+++ /dev/null
@@ -1,85 +0,0 @@
-/**
- * @file State_Standby.cpp
- * @brief Implementation of the StandbyState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the StandbyState, which defines
- * the behavior of the equipment when it is in an idle or standby mode.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-/**
- * @brief Constructs a new StandbyState object.
- *
- * In this state, the equipment is idle. This constructor initializes strategies
- * to bring the system to a safe, idle condition. It sets a stable value for
- * the SAT reading and creates ramp strategies to bring the CW valve and all
- * EC fan speeds down to zero.
- */
-template<>
-StandbyState<ModbusIP>::StandbyState() {
-    // You can add initialization code here if needed
-    
-
-}
-
-/**
- * @brief Executes the standby state's logic for one update cycle.
- *
- * This method applies the strategies defined for the standby state (e.g.,
- * ramping values to zero).
- *
- * @warning This method currently does not check for a command to transition to the
- *          Running state. This logic needs to be added to allow the unit to start.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* StandbyState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Standby update function");
-    
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the standby state.
- * This method performs cleanup by setting all alarm points and all EC fan
- * run status points to 0.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Standby State...");
-}
-
-/**
- * @brief Logic to execute once when exiting the standby state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Standby State...");
-}
\ No newline at end of file
diff --git a/src/BMS/CRAH/CRAH_HTS_PLC_TCP/config.h b/src/BMS/CRAH/CRAH_HTS_PLC_TCP/config.h
deleted file mode 100644
index 21a339a..0000000
--- a/src/BMS/CRAH/CRAH_HTS_PLC_TCP/config.h
+++ /dev/null
@@ -1,134 +0,0 @@
-/**
- * @file config.h
- * @brief Main configuration file for the CRAH Unit (TCP) emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * This file contains two important configurations: WiFi network parameters
- * and the Modbus register map for the device.
- */
-
-#ifndef CONFIG_H
-#define CONFIG_H
-
-#include "core.h"
-#include "Equipment/Equipment.h"
-
-#if defined(USE_MODBUS_IP)
-/**
-   * @defgroup ModbusTCPConfig Modbus IP Configuration
-   * @brief Parameters for Modbus TCP communication.
-   * @{
-   */
-  #include <ModbusIP_ESP8266.h>
-  const char *ssid = "QTS_ATL_Arduino";       /**< @brief The SSID of the WiFi network. */
-  const char *password = "Fayetteville123";   /**< @brief The password for the WiFi network. */
-  IPAddress local_IP(172, 17, 25, 123);       /**< @brief The static IP address for the device. */
-  IPAddress gateway(172, 17, 25, 1);          /**< @brief The gateway IP address. */
-  IPAddress subnet(255, 255, 255, 0);         /**< @brief The subnet mask. */
-  ModbusIP mb;
-#else
-  /**
-   * @defgroup ModbusRTUConfig Modbus RTU Configuration
-   * @brief Parameters for serial Modbus RTU communication.
-   * @{
-   */
-  #include <ModbusRTU.h>
-  const int BAUDRATE = 19200;   /**< @brief The serial communication speed in bits per second. */
-  const int RX_PIN = 17;        /**< @brief The GPIO pin used for receiving data (RX). */
-  const int TX_PIN = 16;        /**< @brief The GPIO pin used for transmitting data (TX). */
-  const int RST_PIN = 4;        /**< @brief The GPIO pin connected to the RS485 driver's DE/RE pins for direction control. */
-  const int MODBUS_ID = 1;      /**< @brief The unique slave ID for this device on the Modbus bus. */
-  /** @} */
-
-  /** @brief Global instance of the Modbus RTU server. */
-  ModbusRTU mb;
-#endif
-
-
-
-/**
- * @defgroup ModbusMapConfig Modbus Map Configuration
- * @brief Defines the Modbus register map and related parameters for the emulator.
- * @{
- */
-/**
- * @brief The Modbus map for the Equipment device.
- * This array defines all the Modbus points available on the emulated device.
- * The `description` field is crucial as it's used to look up points within the application logic.
- */
-modbusMap mb_map[] =
-{   
-  {HR,        49,    0,  "Total Ariflow"},
-  {HR_FLOAT,  31,    0,  "Airflow Effectiveness"},
-  {HR_FLOAT,  33,    0,  "Return Humidity"},
-  {HR_FLOAT,  35,    0,  "Return Air Temp"},
-  {HR_FLOAT,  37,    0,  "Return Dew Point"},
-  {HR_FLOAT,  55,    0,  "Supply Air Temp"},
-  {HR_FLOAT,  27,    0,  "Cooling Valve Output"},
-  {HR_FLOAT,  29,    0,  "Feedback Differential"},
-  {HR,        23,    0,  "Airflow Used"},
-  {HR,        24,    0,  "Available Airflow"},
-  {HR_FLOAT,  47,    0,  "Cooling Capacity"},
-  {HR_FLOAT,  45,    0,  "Net Sensible Cooling Capacity"},
-  {HR_FLOAT,  43,    0,  "Fan Time in Hrs"},
-  {HR_FLOAT,  51,    0,  "Differential Air Temp"},
-  {HR_FLOAT,  39,    0,  "Fan Speed"},
-  {HR,        20,    0,  "Heartbeat"},
-  
-  {HR_FLOAT,  41,    0,  "Air Temp Setpoint"},
-  {HR_FLOAT,  25,    0,  "Fan Speed Setpoint"},
-
-  {HR,        17,    0,  "Pump Run Status"},
-  {HR,        18,    0,  "Pump Health"},
-  {HR,        22,    0,  "Pump High Float"},
-
-  {DI,        2,    0,  "Common Alarm"},
-  {DI,        12,    0,  "Smoke Detected"},
-  {DI,        13,    0,  "Water Under Foot"},
-  {DI,        14,    0,  "Check Air Filter"},
-  {DI,        15,    0,  "Fan Issue"},
-  {DI,        16,    0,  "Alternate Power Source"},
-  {DI,        8,    0,  "Unit Status"},
-  {DI,        7,    0,  "Loss of Air Flow"},
-  {DI,        8,    0,  "Cooling State Input"},
-  {DI,        6,    0,  "Unit Local"},
-  {HR,        4,    0,  "Alarm Acknowledged"},
-
-  //{DI,        2,    0,  "Operator Status (Input)"},
-  //{COIL,      2,    0,  "Operator Status (Output)"},
-  //{DI,        2,    0,  "Program Status (Input)"},
-  //{COIL,      2,    0,  "Program Status (Output)"},
-  //{DI,        2,    0,  "Running Status"},
-  //{DI,        2,    0,  "Not Ready Status"},
-  //{DI,        2,    0,  "Start Command (Input)"},
-  //{COIL,      2,    0,  "Start Command (Output)"},
-  //{DI,        2,    0,  "Stop Command (Input)"},
-  //{COIL,      2,    0,  "Stop Command (Output)"},
-  //{DI,        2,    0,  "Reset (Input)"},
-  //{COIL,      2,    0,  "Reset (Output)"},
-  //{DI,        2,    0,  "Start Command (Input)"},
-  //{DI,        2,    0,  "Stopped Status"},
-  //{DI,        2,    0,  "Error Status"},
-  //{DI,        2,    0,  "Not Ready Fail"},
-  //{DI,        2,    0,  "Starting Status"},
-  //{DI,        2,    0,  "Stopping Status"},
-  //
-  //{HR_FLOAT,  2,    0,  "Air Temp Setpoint (Output)"},
-  //{HR_FLOAT,  2,    0,  "Fan Speed Setpoint (Output)"},
-
-
-}; 
-//Size of modbus map used in FOR cycles, automatically calculated.
-
-/**
- * @brief The total number of entries in the `mb_map` array.
- * This is calculated at compile time and used for iterating over the map.
- */
-const int map_size = sizeof(mb_map) / sizeof(mb_map[0]);
-
-/** @brief The main loop update interval in milliseconds. */
-int interval = 250; 
-/** @} */ // End of ModbusMapConfig group
-
-#endif // CONFIG_H
diff --git a/src/BMS/CRAH/CRAH_HTS_PLC_TCP/main.cpp b/src/BMS/CRAH/CRAH_HTS_PLC_TCP/main.cpp
deleted file mode 100644
index 286a98c..0000000
--- a/src/BMS/CRAH/CRAH_HTS_PLC_TCP/main.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-/**
- * @file main.cpp
- * @brief Main execution program for the CRAH Unit (TCP) Emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * @details This file contains the main execution program for an Arduino-based emulator of a CRAH unit. 
- * The program uses a Wi-Fi connection to communicate via the Modbus IP protocol.
- *
- * The setup() function initializes the following:
- * - Serial communication for debugging.
- * - Wi-Fi connection using credentials from config.h.
- * - A Modbus TCP server.
- * - Modbus points (Coils, Holding Registers, etc.) based on a predefined map in config.h.
- *
- * The loop() function continuously:
- * - Services the Modbus TCP server to handle incoming requests.
- * - Periodically calls the main update loop for the emulated equipment, which
- *   manages state transitions and behavior strategies.
- *
- * @see config.h for Wi-Fi and Modbus configuration.
- * @see Equipment.h for the main equipment logic.
- * @see State.h for different equipment states.
- * @see Strategies/Strategy_Behavior.h for value generation strategies.
- * @see Modbus_Point.h for the base class for all Modbus points.
- */
-//=================================================================================================================================
-//Libraries and declaration of variables.
-#include <WiFi.h>
-#include "config.h"
-#include "ModbusPoints/Modbus_PointFactory.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-//=================================================================================================================================
-/** 
- * @brief Initializes the application.
- * @details This function runs once at startup. It configures the serial communication, 
- * Wi-Fi, and the Modbus server. It also creates and initializes all the Modbus points 
- * based on the `mb_map` array in `config.h`.
- */
-void setup() {
-  Serial.begin(115200);                       //Serial comm start
-  WiFi.config(local_IP, gateway, subnet);     // Wifi service start
-  WiFi.begin(ssid, password);
-  while (WiFi.status() != WL_CONNECTED) {
-    delay(1000);
-    Serial.print(".");
-  }
-  Serial.println("Connected!!");
-  mb.server();                                //Modbus server start
-  Serial.println("Server Created");
-  Serial.println(map_size);
-  for(int i = 0; i < map_size; i++){
-    Modbus_Point<ModbusIP>* point = createModbus_Point(&mb, mb_map[i].category, mb_map[i].address, mb_map[i].value, mb_map[i].description);
-    if (point) {
-      point->addToModbusServer();
-      EquipmentInstance.addModbus_Point(mb_map[i].description, point);
-    }
-  }
-  Serial.println("All modbus Points created");
-  Serial.println("Setup function ended");
-}
-//=================================================================================================================================
-/** 
- * @brief The main application loop.
- * @details This function runs repeatedly after setup() has completed. It performs two main actions:
- * 1. It continuously services the Modbus server by calling `mb.task()` to handle
- *    incoming requests from a Modbus master.
- * 2. At a fixed interval (defined in `config.h`), it calls `EquipmentInstance.update()`
- *    to run the emulator's internal state machine and behavior logic.
- */
-void loop() {
-  mb.task();
-  unsigned long currentMillis = millis();
-  if (currentMillis - previousMillis >= interval) {
-    previousMillis = currentMillis;
-    unsigned long startTime = millis();
-    EquipmentInstance.update();
-    unsigned long endTime = millis();
-    unsigned long elapsedTime = endTime - startTime;
-    Serial.printf("Control Execution time: %d ms\n", elapsedTime);
-  } 
-}
diff --git a/src/BMS/CRAH/CRAH_LIEBERT_80_125_SLAB_TCP/README.md b/src/BMS/CRAH/CRAH_LIEBERT_80_125_SLAB_TCP/README.md
deleted file mode 100644
index c863c27..0000000
--- a/src/BMS/CRAH/CRAH_LIEBERT_80_125_SLAB_TCP/README.md
+++ /dev/null
@@ -1,31 +0,0 @@
-# CRAH Liebert 80 125 SLAB TCP
-
-## Brief Introduction
-Equipment specifc details that make it different from other devices
-
-## List of Equipmentt
-This cofiguration has been used for these models:
-* **Libert 80_125 SLAB**: 09-15-25 
-
-## Hardware Prerequisites
-
-The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities.
-* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html) 
-
----
-
-## States and Strategies
-Provide a brief description of what variables and strategies were used in this configuraiton
-
-### Standby State
-* **Equipment running**: set to 0
-* **Common Alarm**: set to 0
-* **SAT temperature**: set to 85
-
-### Running State
-* **Equipment running**: set to 1
-* **SAT temperature**: **Ramp Strategy** set to 65 deg setpoint
-
-### Fail State
-* **Commong Alarm**: set to 1
-* **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset
diff --git a/src/BMS/CRAH/CRAH_LIEBERT_80_125_SLAB_TCP/State_Fail.cpp b/src/BMS/CRAH/CRAH_LIEBERT_80_125_SLAB_TCP/State_Fail.cpp
deleted file mode 100644
index 046bf00..0000000
--- a/src/BMS/CRAH/CRAH_LIEBERT_80_125_SLAB_TCP/State_Fail.cpp
+++ /dev/null
@@ -1,92 +0,0 @@
-/**
- * @file State_Fail.cpp
- * @brief Implementation of the FailState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the FailState, which defines
- * the behavior of the equipment when it has entered a fault condition.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new FailState object with a list of active alarms.
- *
- * This constructor receives a list of alarm descriptions and creates strategies
- * to set the corresponding Modbus points to a value of 1, indicating an
- * active alarm. It also initializes a PID strategy for the 'CW Valve Position'
- * to maintain its state during the fault.
- * @param activeAlarms A vector of strings, where each string is the
- *                     description of a Modbus point to be set as an active alarm.
- */
-template<>
-FailState<ModbusIP>::FailState(const std::vector<std::string>& activeAlarms) {
-    // Simulate a failure: set common alarm and a specific fan alarm.
-
-    for (const auto& alarmName : activeAlarms){
-        addStrategy(alarmName, new SingleValueStrategy(1.0f, 0.0f, 1000));
-    }
-    addStrategy("CW Valve Position", new PIDStrategy("RAT Setpoint", 1000, "RAT"));
-}
-
-/**
- * @brief Executes the fail state's logic for one update cycle.
- *
- * This method checks the "Alarm Reset" Modbus point for a command to
- * transition back to Standby, which would typically happen after a fault
- * is cleared by a user. If no transition is requested, it continues to apply
- * the failure strategies (e.g., keeping alarm bits active).
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* FailState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Fail update function");
-    Modbus_Point<ModbusIP>* alarmReset = equipment->getModbus_Point("Alarm Reset");
-    int nextStateId = alarmReset ? alarmReset->getValue() : 0;
-    if (nextStateId == 1){
-        return new StandbyState<ModbusIP>();
-    }
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the fail state.
- * Sets the "Alarm Common" point to 1 to indicate a general fault condition.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Fail State...");
-    Modbus_Point<ModbusIP>* alarm_common = equipment->getModbus_Point("Alarm Common");
-    alarm_common->setValue(1);
-}
-
-/**
- * @brief Logic to execute once when exiting the fail state.
- * Clears the "Alarm Common" point to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Fail State...");
-    Modbus_Point<ModbusIP>* alarm_common = equipment->getModbus_Point("Alarm Common");
-    alarm_common->setValue(0);
-}
\ No newline at end of file
diff --git a/src/BMS/CRAH/CRAH_LIEBERT_80_125_SLAB_TCP/State_Running.cpp b/src/BMS/CRAH/CRAH_LIEBERT_80_125_SLAB_TCP/State_Running.cpp
deleted file mode 100644
index b0f5399..0000000
--- a/src/BMS/CRAH/CRAH_LIEBERT_80_125_SLAB_TCP/State_Running.cpp
+++ /dev/null
@@ -1,187 +0,0 @@
-/**
- * @file State_Running.cpp
- * @brief Implementation of the RunningState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the RunningState, which defines
- * the behavior of the equipment when it is actively running.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "Strategies/Strategy_Totalizer.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new RunningState object.
- *
- * This constructor initializes behavior strategies active during the running
- * state, such as a PID controller for the 'CW Valve Position' and totalizers
- * for the run-hours of each EC fan.
- */
-template<>
-RunningState<ModbusIP>::RunningState() {
-    addStrategy("CW Valve Position", new PIDStrategy("RAT Setpoint", 1000, "RAT"));
-    addStrategy("Operating Hours EC Fan #1", new TotalizerStrategy(10000));
-    addStrategy("Operating Hours EC Fan #2", new TotalizerStrategy(10000));
-    addStrategy("Operating Hours EC Fan #3", new TotalizerStrategy(10000));
-    addStrategy("Operating Hours EC Fan #4", new TotalizerStrategy(10000));
-    addStrategy("Operating Hours EC Fan #5", new TotalizerStrategy(10000));
-    addStrategy("Operating Hours EC Fan #6", new TotalizerStrategy(10000));
-    addStrategy("Operating Hours EC Fan #7", new TotalizerStrategy(10000));
-    addStrategy("Operating Hours EC Fan #8", new TotalizerStrategy(10000));
-    addStrategy("Operating Hours EC Fan #9", new TotalizerStrategy(10000));
-}
-
-/**
- * @brief Executes the running state's logic for one update cycle.
- *
- * This method first checks for state transition commands:
- * 1. It reads the "ON/OFF Command By BMS" point. If it's 0, it transitions to StandbyState.
- * 2. It reads the "Fault Code" point. If it's non-zero, it transitions to FailState,
- *    passing the corresponding alarm description.
- *
- * If no transition occurs, it applies the strategies defined for the running state.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* RunningState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Running update function");
-    Modbus_Point<ModbusIP>* On_Off_Command = equipment->getModbus_Point("ON/OFF Command By BMS");
-    int nextStateId = On_Off_Command ? On_Off_Command->getValue() : 0;
-    Serial.println(nextStateId);
-    if (nextStateId == 0){
-        return new StandbyState<ModbusIP>();
-    }
-
-    Modbus_Point<ModbusIP>* faultCode = equipment->getModbus_Point("Fault Code");
-    int faultCodeValue = faultCode ? faultCode->getValue() : 0;
-    switch (faultCodeValue){
-        case 1:
-            return new FailState<ModbusIP>({"Alarm SAT Sensor Fault"});
-        case 2:
-            return new FailState<ModbusIP>({"Alarm RAH Sensor Fault"});
-        case 3:
-            return new FailState<ModbusIP>({"Alarm RAT Sensor Fault"}); 
-        case 4:
-            return new FailState<ModbusIP>({"Alarm Filter DP Sensor Fault"});
-        case 5:
-            return new FailState<ModbusIP>({"Alarm Flooding"});
-        case 6:
-            return new FailState<ModbusIP>({"Alarm Dirty Filter"});
-        case 7:
-            return new FailState<ModbusIP>({"Alarm High RAT"});
-        case 8:
-            return new FailState<ModbusIP>({"Alarm Low RAT"});
-        case 9:
-            return new FailState<ModbusIP>({"Alarm High SAT"});
-        case 10:
-            return new FailState<ModbusIP>({"Alarm Low SAT"});
-        case 11:
-            return new FailState<ModbusIP>({"Alarm High RAH"});
-        case 12:
-            return new FailState<ModbusIP>({"Alarm Low RAH"});
-        case 13:
-            return new FailState<ModbusIP>({"Alarm Phase Failure"});
-        case 14:
-            return new FailState<ModbusIP>({"Alarm Condensate Pump"});
-        case 15:
-            return new FailState<ModbusIP>({"Alarm Smoke"});
-        case 16:
-            return new FailState<ModbusIP>({"Alarm Fire"});
-        case 17:
-            return new FailState<ModbusIP>({"Alarm EC Fan #1"});
-        case 18:
-            return new FailState<ModbusIP>({"Alarm EC Fan #2"});
-        case 19:
-            return new FailState<ModbusIP>({"Alarm EC Fan #3"});
-        case 20:
-            return new FailState<ModbusIP>({"Alarm EC Fan #4"});
-        case 21:
-            return new FailState<ModbusIP>({"Alarm EC Fan #5"});
-        case 22:
-            return new FailState<ModbusIP>({"Alarm EC Fan #6"});
-        case 23:
-            return new FailState<ModbusIP>({"Alarm EC Fan #7"});
-        case 24:
-            return new FailState<ModbusIP>({"Alarm EC Fan #8"});
-        case 25:
-            return new FailState<ModbusIP>({"Alarm EC Fan #9"});
-        default:
-            break;
-    }
-
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the running state.
- * Sets the "Run Status" for all EC fans to 1 to indicate they are active.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Running State...");
-    // You could also update a Modbus register to show the "standby" state
-
-    const std::vector<std::string> motorStatusDescriptions = {
-        "Run Status EC Fan #1", "Run Status EC Fan #2", "Run Status EC Fan #3",
-        "Run Status EC Fan #4", "Run Status EC Fan #5", "Run Status EC Fan #6",
-        "Run Status EC Fan #7", "Run Status EC Fan #8", "Run Status EC Fan #9"
-    };
-
-    // Loop through and set all motor statuses to 0
-    for (const auto& desc : motorStatusDescriptions) {
-        Modbus_Point<ModbusIP>* point = equipment->getModbus_Point(desc);
-        if (point) {
-            point->setValue(1);
-        }
-    }
-}
-
-/**
- * @brief Logic to execute once when exiting the running state.
- * Sets the "Run Status" for all EC fans to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Running State...");
-    const std::vector<std::string> motorStatusDescriptions = {
-        "Run Status EC Fan #1", "Run Status EC Fan #2", "Run Status EC Fan #3",
-        "Run Status EC Fan #4", "Run Status EC Fan #5", "Run Status EC Fan #6",
-        "Run Status EC Fan #7", "Run Status EC Fan #8", "Run Status EC Fan #9"
-    };
-
-    // Loop through and set all motor statuses to 0
-    for (const auto& desc : motorStatusDescriptions) {
-        Modbus_Point<ModbusIP>* point = equipment->getModbus_Point(desc);
-        if (point) {
-            point->setValue(0);
-        }
-    }
-}
\ No newline at end of file
diff --git a/src/BMS/CRAH/CRAH_LIEBERT_80_125_SLAB_TCP/State_Standby.cpp b/src/BMS/CRAH/CRAH_LIEBERT_80_125_SLAB_TCP/State_Standby.cpp
deleted file mode 100644
index f122906..0000000
--- a/src/BMS/CRAH/CRAH_LIEBERT_80_125_SLAB_TCP/State_Standby.cpp
+++ /dev/null
@@ -1,135 +0,0 @@
-/**
- * @file State_Standby.cpp
- * @brief Implementation of the StandbyState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the StandbyState, which defines
- * the behavior of the equipment when it is in an idle or standby mode.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-/**
- * @brief Constructs a new StandbyState object.
- *
- * In this state, the equipment is idle. This constructor initializes strategies
- * to bring the system to a safe, idle condition. It sets a stable value for
- * the SAT reading and creates ramp strategies to bring the CW valve and all
- * EC fan speeds down to zero.
- */
-template<>
-StandbyState<ModbusIP>::StandbyState() {
-    // You can add initialization code here if needed
-    addStrategy("SAT Reading", new SingleValueStrategy(100.0f, 0.1f, 1000));
-    addStrategy("CW Valve Position", new RampStrategy(0.0f, 5.0f, 1000));
-    addStrategy("Speed EC Fan #1", new RampStrategy(0.0f, 5.0f, 1000));
-    addStrategy("Speed EC Fan #2", new RampStrategy(0.0f, 5.0f, 1000));
-    addStrategy("Speed EC Fan #3", new RampStrategy(0.0f, 5.0f, 1000));
-    addStrategy("Speed EC Fan #4", new RampStrategy(0.0f, 5.0f, 1000));
-    addStrategy("Speed EC Fan #5", new RampStrategy(0.0f, 5.0f, 1000));
-    addStrategy("Speed EC Fan #6", new RampStrategy(0.0f, 5.0f, 1000));
-    addStrategy("Speed EC Fan #7", new RampStrategy(0.0f, 5.0f, 1000));
-    addStrategy("Speed EC Fan #8", new RampStrategy(0.0f, 5.0f, 1000));
-    addStrategy("Speed EC Fan #9", new RampStrategy(0.0f, 5.0f, 1000));
-
-}
-
-/**
- * @brief Executes the standby state's logic for one update cycle.
- *
- * This method applies the strategies defined for the standby state (e.g.,
- * ramping values to zero).
- *
- * @warning This method currently does not check for a command to transition to the
- *          Running state. This logic needs to be added to allow the unit to start.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* StandbyState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Standby update function");
-    int On_Off_Command = getPointValue(equipment, "ON/OFF Command By BMS");
-    Serial.printf("ON_OFF COmmand %f. \n", On_Off_Command);
-    if (On_Off_Command == 1){
-        return new RunningState<ModbusIP>();
-    }
-
-
-
-
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the standby state.
- * This method performs cleanup by setting all alarm points and all EC fan
- * run status points to 0.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-// A list of all alarm descriptions
-    const std::vector<std::string> alarmDescriptions = {
-        "Alarm SAT Sensor Fault", "Alarm RAH Sensor Fault", "Alarm RAT Sensor Fault",
-        "Alarm Filter DP Sensor Fault", "Alarm Flooding", "Alarm Dirty Filter",
-        "Alarm High RAT", "Alarm Low RAT", "Alarm High SAT", "Alarm Low SAT",
-        "Alarm High RAH", "Alarm Low RAH", "Alarm Common", "Alarm Phase Failure",
-        "Alarm Condensate Pump", "Alarm Smoke", "Alarm Fire", "Alarm EC Fan #1",
-        "Alarm EC Fan #2", "Alarm EC Fan #3", "Alarm EC Fan #4", "Alarm EC Fan #5",
-        "Alarm EC Fan #6", "Alarm EC Fan #7", "Alarm EC Fan #8", "Alarm EC Fan #9"
-    };
-
-    // A list of all motor run status descriptions
-    const std::vector<std::string> motorStatusDescriptions = {
-        "Run Status EC Fan #1", "Run Status EC Fan #2", "Run Status EC Fan #3",
-        "Run Status EC Fan #4", "Run Status EC Fan #5", "Run Status EC Fan #6",
-        "Run Status EC Fan #7", "Run Status EC Fan #8", "Run Status EC Fan #9"
-    };
-
-    // Loop through and set all alarms to 0
-    for (const auto& desc : alarmDescriptions) {
-        Modbus_Point<ModbusIP>* point = equipment->getModbus_Point(desc);
-        if (point) {
-            point->setValue(0);
-        }
-    }
-
-    // Loop through and set all motor statuses to 0
-    for (const auto& desc : motorStatusDescriptions) {
-        Modbus_Point<ModbusIP>* point = equipment->getModbus_Point(desc);
-        if (point) {
-            point->setValue(0);
-        }
-    }
-}
-
-/**
- * @brief Logic to execute once when exiting the standby state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Standby State...");
-}
\ No newline at end of file
diff --git a/src/BMS/CRAH/CRAH_LIEBERT_80_125_SLAB_TCP/config.h b/src/BMS/CRAH/CRAH_LIEBERT_80_125_SLAB_TCP/config.h
deleted file mode 100644
index d7ea52c..0000000
--- a/src/BMS/CRAH/CRAH_LIEBERT_80_125_SLAB_TCP/config.h
+++ /dev/null
@@ -1,152 +0,0 @@
-/**
- * @file config.h
- * @brief Main configuration file for the CRAH Unit (TCP) emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * This file contains two important configurations: WiFi network parameters
- * and the Modbus register map for the device.
- */
-
-#ifndef CONFIG_H
-#define CONFIG_H
-
-#include "core.h" //comment
-#include "Equipment/Equipment.h"
-
-#if defined(USE_MODBUS_IP)
-/**
-   * @defgroup ModbusTCPConfig Modbus IP Configuration
-   * @brief Parameters for Modbus TCP communication.
-   * @{
-   */
-  #include <ModbusIP_ESP8266.h>
-  const char *ssid = "wifi_name";       /**< @brief The SSID of the WiFi network. */
-  const char *password = "wifi_password";   /**< @brief The password for the WiFi network. */
-  IPAddress local_IP(192, 168, 1, 234);       /**< @brief The static IP address for the device. */
-  IPAddress gateway(192, 168, 1, 1);          /**< @brief The gateway IP address. */
-  IPAddress subnet(255, 255, 255, 0);         /**< @brief The subnet mask. */
-  
-  ModbusIP mb;
-#else
-  /**
-   * @defgroup ModbusRTUConfig Modbus RTU Configuration
-   * @brief Parameters for serial Modbus RTU communication.
-   * @{
-   */
-  #include <ModbusRTU.h>
-  const int BAUDRATE = 19200;   /**< @brief The serial communication speed in bits per second. */
-  const int RX_PIN = 17;        /**< @brief The GPIO pin used for receiving data (RX). */
-  const int TX_PIN = 16;        /**< @brief The GPIO pin used for transmitting data (TX). */
-  const int RST_PIN = 4;        /**< @brief The GPIO pin connected to the RS485 driver's DE/RE pins for direction control. */
-  const int MODBUS_ID = 1;      /**< @brief The unique slave ID for this device on the Modbus bus. */
-  /** @} */
-
-  /** @brief Global instance of the Modbus RTU server. */
-  ModbusRTU mb;
-#endif
-
-
-
-/**
- * @defgroup ModbusMapConfig Modbus Map Configuration
- * @brief Defines the Modbus register map and related parameters for the emulator.
- * @{
- */
-/**
- * @brief The Modbus map for the Equipment device.
- * This array defines all the Modbus points available on the emulated device.
- * The `description` field is crucial as it's used to look up points within the application logic.
- */
-modbusMap mb_map[] =
-{   
-  {HR,        15,     0,  "State Control"},  //Internal to control from Modscan
-  {HR,        16,     0,  "Fault Code"},
-  {HR_FLOAT,  18,     0,  "RAT"},     //Internal Fault code from Modscan  
-  {HR_FLOAT,  1,      0,  "SAT Setpoint"},                     
-  {HR_FLOAT,  681,    0,  "RAT Setpoint"},                   
-  {HR_FLOAT,  111,    0,  "High RAT Limit"},                 
-  {HR_FLOAT,  114,    0,  "Low RAT Limit"},                  
-  {HR_FLOAT,  118,    0,  "High SAT Limit"},                 
-  {HR_FLOAT,  122,    0,  "Low SAT Limit"},                  
-  {HR_FLOAT,  685,    0,  "High RAH Limit"},                 
-  {HR_FLOAT,  689,    0,  "Low RAH Limit"},                  
-  {HR,        5,      0,  "Setting the EC Fan Max Speed"},   
-  {HR,        695,    0,  "Setting the EC Fan Min Speed"},   
-  {HR_FLOAT,  693,    0,  "Setting Room Temp"},              
-  {HR,        691,    0,  "Setting EC Fan Speed "},          
-  {DI,        146,    0,  "Alarm SAT Sensor Fault"},         
-  {DI,        1246,   0,  "Alarm RAH Sensor Fault"},        
-  {DI,        1245,   0,  "Alarm RAT Sensor Fault"},        
-  {DI,        1250,   0,  "Alarm Filter DP Sensor Fault"},  
-  {DI,        51,     0,  "Alarm Flooding"},                  
-  {DI,        1096,   0,  "Alarm Dirty Filter"},            
-  {DI,        1367,   0,  "Alarm High RAT"},                
-  {DI,        1099,   0,  "Alarm Low RAT"},                 
-  {DI,        118,    0,  "Alarm High SAT"},                 
-  {DI,        122,    0,  "Alarm Low SAT"},                  
-  {DI,        1307,   0,  "Alarm High RAH"},                
-  {DI,        1308,   0,  "Alarm Low RAH"},                 
-  {DI,        1342,   0,  "Alarm Common"},                  
-  {DI,        148,    0,  "Alarm Phase Failure"},            
-  {DI,        1370,   0,  "Alarm Condensate Pump"},         
-  {DI,        1368,   0,  "Alarm Smoke"},                   
-  {DI,        1369,   0,  "Alarm Fire"},                    
-  {DI,        131,    0,  "Alarm EC Fan #1"},                
-  {DI,        132,    0,  "Alarm EC Fan #2"},                
-  {DI,        133,    0,  "Alarm EC Fan #3"},                
-  {DI,        134,    0,  "Alarm EC Fan #4"},                
-  {DI,        135,    0,  "Alarm EC Fan #5"},                
-  {DI,        136,    0,  "Alarm EC Fan #6"},                
-  {DI,        1360,   0,  "Alarm EC Fan #7"},               
-  {DI,        1361,   0,  "Alarm EC Fan #8"},               
-  {DI,        1362,   0,  "Alarm EC Fan #9"},               
-  {DI,        138,    0,  "Run Status EC Fan #1"},           
-  {DI,        139,    0,  "Run Status EC Fan #2"},           
-  {DI,        140,    0,  "Run Status EC Fan #3"},           
-  {DI,        141,    0,  "Run Status EC Fan #4"},           
-  {DI,        142,    0,  "Run Status EC Fan #5"},           
-  {DI,        143,    0,  "Run Status EC Fan #6"},           
-  {DI,        1363,   0,  "Run Status EC Fan #7"},          
-  {DI,        1364,   0,  "Run Status EC Fan #8"},          
-  {DI,        1365,   0,  "Run Status EC Fan #9"},          
-  {IR_FLOAT,  99,     0,  "SAT Reading"},                     
-  {IR_FLOAT,  70,     0,  "RAH Reading"},                     
-  {IR_FLOAT,  101,    0,  "RAT Reading"},                    
-  {IR_FLOAT,  106,    0,  "Filter DP Reading"},              
-  {IR_FLOAT,  496,    0,  "CW Valve Position"},              
-  {IR,        53,     0,  "Speed EC Fan #1"},                 
-  {IR,        228,    0,  "Speed EC Fan #2"},                
-  {IR,        229,    0,  "Speed EC Fan #3"},                
-  {IR,        230,    0,  "Speed EC Fan #4"},                
-  {IR,        231,    0,  "Speed EC Fan #5"},                
-  {IR,        232,    0,  "Speed EC Fan #6"},                
-  {IR,        678,    0,  "Speed EC Fan #7"},                
-  {IR,        679,    0,  "Speed EC Fan #8"},                
-  {IR,        680,    0,  "Speed EC Fan #9"},                
-  {IR,        274,    0,  "Operating Hours EC Fan #1"},      
-  {IR,        233,    0,  "Operating Hours EC Fan #2"},      
-  {IR,        244,    0,  "Operating Hours EC Fan #3"},      
-  {IR,        235,    0,  "Operating Hours EC Fan #4"},      
-  {IR,        236,    0,  "Operating Hours EC Fan #5"},      
-  {IR,        245,    0,  "Operating Hours EC Fan #6"},      
-  {IR,        486,    0,  "Operating Hours EC Fan #7"},      
-  {IR,        487,    0,  "Operating Hours EC Fan #8"},      
-  {IR,        488,    0,  "Operating Hours EC Fan #9"},      
-  {COIL,      301,    0,  "ON/OFF Command By BMS"},        
-  {COIL,      302,    0,  "Enable Off By Supervisory"},    
-  {COIL,      264,    0,  "Alarm Reset"}                                  
-};
-//Size of modbus map used in FOR cycles, automatically calculated.
-
-/**
- * @brief The total number of entries in the `mb_map` array.
- * This is calculated at compile time and used for iterating over the map.
- */
-const int map_size = sizeof(mb_map) / sizeof(mb_map[0]);
-
-/** @brief The main loop update interval in milliseconds. */
-int interval = 250; 
-/** @} */ // End of ModbusMapConfig group
-
-#endif // CONFIG_H
diff --git a/src/BMS/CRAH/CRAH_LIEBERT_80_125_SLAB_TCP/main.cpp b/src/BMS/CRAH/CRAH_LIEBERT_80_125_SLAB_TCP/main.cpp
deleted file mode 100644
index 286a98c..0000000
--- a/src/BMS/CRAH/CRAH_LIEBERT_80_125_SLAB_TCP/main.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-/**
- * @file main.cpp
- * @brief Main execution program for the CRAH Unit (TCP) Emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * @details This file contains the main execution program for an Arduino-based emulator of a CRAH unit. 
- * The program uses a Wi-Fi connection to communicate via the Modbus IP protocol.
- *
- * The setup() function initializes the following:
- * - Serial communication for debugging.
- * - Wi-Fi connection using credentials from config.h.
- * - A Modbus TCP server.
- * - Modbus points (Coils, Holding Registers, etc.) based on a predefined map in config.h.
- *
- * The loop() function continuously:
- * - Services the Modbus TCP server to handle incoming requests.
- * - Periodically calls the main update loop for the emulated equipment, which
- *   manages state transitions and behavior strategies.
- *
- * @see config.h for Wi-Fi and Modbus configuration.
- * @see Equipment.h for the main equipment logic.
- * @see State.h for different equipment states.
- * @see Strategies/Strategy_Behavior.h for value generation strategies.
- * @see Modbus_Point.h for the base class for all Modbus points.
- */
-//=================================================================================================================================
-//Libraries and declaration of variables.
-#include <WiFi.h>
-#include "config.h"
-#include "ModbusPoints/Modbus_PointFactory.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-//=================================================================================================================================
-/** 
- * @brief Initializes the application.
- * @details This function runs once at startup. It configures the serial communication, 
- * Wi-Fi, and the Modbus server. It also creates and initializes all the Modbus points 
- * based on the `mb_map` array in `config.h`.
- */
-void setup() {
-  Serial.begin(115200);                       //Serial comm start
-  WiFi.config(local_IP, gateway, subnet);     // Wifi service start
-  WiFi.begin(ssid, password);
-  while (WiFi.status() != WL_CONNECTED) {
-    delay(1000);
-    Serial.print(".");
-  }
-  Serial.println("Connected!!");
-  mb.server();                                //Modbus server start
-  Serial.println("Server Created");
-  Serial.println(map_size);
-  for(int i = 0; i < map_size; i++){
-    Modbus_Point<ModbusIP>* point = createModbus_Point(&mb, mb_map[i].category, mb_map[i].address, mb_map[i].value, mb_map[i].description);
-    if (point) {
-      point->addToModbusServer();
-      EquipmentInstance.addModbus_Point(mb_map[i].description, point);
-    }
-  }
-  Serial.println("All modbus Points created");
-  Serial.println("Setup function ended");
-}
-//=================================================================================================================================
-/** 
- * @brief The main application loop.
- * @details This function runs repeatedly after setup() has completed. It performs two main actions:
- * 1. It continuously services the Modbus server by calling `mb.task()` to handle
- *    incoming requests from a Modbus master.
- * 2. At a fixed interval (defined in `config.h`), it calls `EquipmentInstance.update()`
- *    to run the emulator's internal state machine and behavior logic.
- */
-void loop() {
-  mb.task();
-  unsigned long currentMillis = millis();
-  if (currentMillis - previousMillis >= interval) {
-    previousMillis = currentMillis;
-    unsigned long startTime = millis();
-    EquipmentInstance.update();
-    unsigned long endTime = millis();
-    unsigned long elapsedTime = endTime - startTime;
-    Serial.printf("Control Execution time: %d ms\n", elapsedTime);
-  } 
-}
diff --git a/src/BMS/CRAH/CRAH_PETRA_PAHHC_600_C6_TCP/README.md b/src/BMS/CRAH/CRAH_PETRA_PAHHC_600_C6_TCP/README.md
deleted file mode 100644
index 355156f..0000000
--- a/src/BMS/CRAH/CRAH_PETRA_PAHHC_600_C6_TCP/README.md
+++ /dev/null
@@ -1,33 +0,0 @@
-# EQUIPMENT_TYPE MANUFACTURER MODEL TCP
-
-## Brief Introduction
-Equipment specifc details that make it different from other devices
-
-## List of Equipmentt
-This cofiguration has been used for these models:
-* **Model**: 09-15-22 
-* **Model**: 09-15-23 
-* **Model**: 09-15-25 
-
-## Hardware Prerequisites
-
-The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities.
-* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html) 
-
----
-
-## States and Strategies
-Provide a brief description of what variables and strategies were used in this configuraiton
-
-### Standby State
-* **Equipment running**: set to 0
-* **Common Alarm**: set to 0
-* **SAT temperature**: set to 85
-
-### Running State
-* **Equipment running**: set to 1
-* **SAT temperature**: **Ramp Strategy** set to 65 deg setpoint
-
-### Fail State
-* **Commong Alarm**: set to 1
-* **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset
diff --git a/src/BMS/CRAH/CRAH_PETRA_PAHHC_600_C6_TCP/State_Fail.cpp b/src/BMS/CRAH/CRAH_PETRA_PAHHC_600_C6_TCP/State_Fail.cpp
deleted file mode 100644
index 046bf00..0000000
--- a/src/BMS/CRAH/CRAH_PETRA_PAHHC_600_C6_TCP/State_Fail.cpp
+++ /dev/null
@@ -1,92 +0,0 @@
-/**
- * @file State_Fail.cpp
- * @brief Implementation of the FailState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the FailState, which defines
- * the behavior of the equipment when it has entered a fault condition.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new FailState object with a list of active alarms.
- *
- * This constructor receives a list of alarm descriptions and creates strategies
- * to set the corresponding Modbus points to a value of 1, indicating an
- * active alarm. It also initializes a PID strategy for the 'CW Valve Position'
- * to maintain its state during the fault.
- * @param activeAlarms A vector of strings, where each string is the
- *                     description of a Modbus point to be set as an active alarm.
- */
-template<>
-FailState<ModbusIP>::FailState(const std::vector<std::string>& activeAlarms) {
-    // Simulate a failure: set common alarm and a specific fan alarm.
-
-    for (const auto& alarmName : activeAlarms){
-        addStrategy(alarmName, new SingleValueStrategy(1.0f, 0.0f, 1000));
-    }
-    addStrategy("CW Valve Position", new PIDStrategy("RAT Setpoint", 1000, "RAT"));
-}
-
-/**
- * @brief Executes the fail state's logic for one update cycle.
- *
- * This method checks the "Alarm Reset" Modbus point for a command to
- * transition back to Standby, which would typically happen after a fault
- * is cleared by a user. If no transition is requested, it continues to apply
- * the failure strategies (e.g., keeping alarm bits active).
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* FailState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Fail update function");
-    Modbus_Point<ModbusIP>* alarmReset = equipment->getModbus_Point("Alarm Reset");
-    int nextStateId = alarmReset ? alarmReset->getValue() : 0;
-    if (nextStateId == 1){
-        return new StandbyState<ModbusIP>();
-    }
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the fail state.
- * Sets the "Alarm Common" point to 1 to indicate a general fault condition.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Fail State...");
-    Modbus_Point<ModbusIP>* alarm_common = equipment->getModbus_Point("Alarm Common");
-    alarm_common->setValue(1);
-}
-
-/**
- * @brief Logic to execute once when exiting the fail state.
- * Clears the "Alarm Common" point to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Fail State...");
-    Modbus_Point<ModbusIP>* alarm_common = equipment->getModbus_Point("Alarm Common");
-    alarm_common->setValue(0);
-}
\ No newline at end of file
diff --git a/src/BMS/CRAH/CRAH_PETRA_PAHHC_600_C6_TCP/State_Running.cpp b/src/BMS/CRAH/CRAH_PETRA_PAHHC_600_C6_TCP/State_Running.cpp
deleted file mode 100644
index 6a2c459..0000000
--- a/src/BMS/CRAH/CRAH_PETRA_PAHHC_600_C6_TCP/State_Running.cpp
+++ /dev/null
@@ -1,170 +0,0 @@
-/**
- * @file State_Running.cpp
- * @brief Implementation of the RunningState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the RunningState, which defines
- * the behavior of the equipment when it is actively running.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "Strategies/Strategy_Totalizer.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new RunningState object.
- *
- * This constructor initializes behavior strategies active during the running
- * state, such as a PID controller for the 'CW Valve Position' and totalizers
- * for the run-hours of each EC fan.
- */
-template<>
-RunningState<ModbusIP>::RunningState() {
-    addStrategy("CW Valve Position", new PIDStrategy("SAT Setpoint", 2000, "SAT Reading"));
-    addStrategy("SAT Reading", new SingleValueStrategy(0.0f, 3.0f, 1000));
-    addStrategy("Speed EC Fan #1", new RampStrategy(0.0f, 500.0f, 1000));
-    addStrategy("Speed EC Fan #2", new RampStrategy(0.0f, 500.0f, 1000));
-    addStrategy("Speed EC Fan #3", new RampStrategy(0.0f, 500.0f, 1000));
-    addStrategy("Speed EC Fan #4", new RampStrategy(0.0f, 500.0f, 1000));
-    addStrategy("Speed EC Fan #5", new RampStrategy(0.0f, 500.0f, 1000));
-    addStrategy("Speed EC Fan #6", new RampStrategy(0.0f, 500.0f, 1000));
-    addStrategy("Speed EC Fan #7", new RampStrategy(0.0f, 500.0f, 1000));
-    addStrategy("Speed EC Fan #8", new RampStrategy(0.0f, 500.0f, 1000));
-    addStrategy("Speed EC Fan #9", new RampStrategy(0.0f, 500.0f, 1000));
-    addStrategy("Operating Hours EC Fan #1", new TotalizerStrategy(1100));
-    addStrategy("Operating Hours EC Fan #2", new TotalizerStrategy(1200));
-    addStrategy("Operating Hours EC Fan #3", new TotalizerStrategy(1300));
-    addStrategy("Operating Hours EC Fan #4", new TotalizerStrategy(1250));
-    addStrategy("Operating Hours EC Fan #5", new TotalizerStrategy(1350));
-    addStrategy("Operating Hours EC Fan #6", new TotalizerStrategy(1450));
-    addStrategy("Operating Hours EC Fan #7", new TotalizerStrategy(1150));
-    addStrategy("Operating Hours EC Fan #8", new TotalizerStrategy(1180));
-    addStrategy("Operating Hours EC Fan #9", new TotalizerStrategy(1340));
-}
-
-/**
- * @brief Executes the running state's logic for one update cycle.
- *
- * This method first checks for state transition commands:
- * 1. It reads the "ON/OFF Command By BMS" point. If it's 0, it transitions to StandbyState.
- * 2. It reads the "Fault Code" point. If it's non-zero, it transitions to FailState,
- *    passing the corresponding alarm description.
- *
- * If no transition occurs, it applies the strategies defined for the running state.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* RunningState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Running update function");
-    Modbus_Point<ModbusIP>* On_Off_Command = equipment->getModbus_Point("ON/OFF Command By BMS");
-    int nextStateId = On_Off_Command ? On_Off_Command->getValue() : 0;
-    Serial.println(nextStateId);
-    if (nextStateId == 0){
-        return new StandbyState<ModbusIP>();
-    }
-
-
-    float rat = getPointValue(equipment, "RAT");
-    setPointValue(equipment, "RAT Reading", rat);
-    float speed = getPointValue(equipment, "Setting EC Fan Speed");
-    Strategy_Behavior* fan1_rs = getStrategy("Speed EC Fan #1");
-    static_cast<RampStrategy*>(fan1_rs)->setTarget(4200.0f * (speed /100.0f));
-    Strategy_Behavior* fan2_rs = getStrategy("Speed EC Fan #2");
-    static_cast<RampStrategy*>(fan2_rs)->setTarget(4200.0f * (speed /100.0f));
-    Strategy_Behavior* fan3_rs = getStrategy("Speed EC Fan #3");
-    static_cast<RampStrategy*>(fan3_rs)->setTarget(4200.0f * (speed /100.0f));
-    Strategy_Behavior* fan4_rs = getStrategy("Speed EC Fan #4");
-    static_cast<RampStrategy*>(fan4_rs)->setTarget(4200.0f * (speed /100.0f));
-    Strategy_Behavior* fan5_rs = getStrategy("Speed EC Fan #5");
-    static_cast<RampStrategy*>(fan5_rs)->setTarget(4200.0f * (speed /100.0f));
-    Strategy_Behavior* fan6_rs = getStrategy("Speed EC Fan #6");
-    static_cast<RampStrategy*>(fan6_rs)->setTarget(4200.0f * (speed /100.0f));
-    Strategy_Behavior* fan7_rs = getStrategy("Speed EC Fan #7");
-    static_cast<RampStrategy*>(fan7_rs)->setTarget(4200.0f * (speed /100.0f));
-    Strategy_Behavior* fan8_rs = getStrategy("Speed EC Fan #8");
-    static_cast<RampStrategy*>(fan8_rs)->setTarget(4200.0f * (speed /100.0f));
-    Strategy_Behavior* fan9_rs = getStrategy("Speed EC Fan #9");
-    static_cast<RampStrategy*>(fan9_rs)->setTarget(4200.0f * (speed /100.0f));
-
- 
-
-    float value = getPointValue(equipment, "CW Valve Position");
-    Serial.printf("CW Valve Position: %0.2f\n", value);
-    float sat_setpoint = getPointValue(equipment, "SAT Setpoint");
-    Strategy_Behavior* sat_svs = getStrategy("SAT Reading");
-    static_cast<SingleValueStrategy*>(sat_svs)->setSetpoint(sat_setpoint);
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the running state.
- * Sets the "Run Status" for all EC fans to 1 to indicate they are active.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Running State...");
-    // You could also update a Modbus register to show the "standby" state
-
-    const std::vector<std::string> motorStatusDescriptions = {
-        "Run Status EC Fan #1", "Run Status EC Fan #2", "Run Status EC Fan #3",
-        "Run Status EC Fan #4", "Run Status EC Fan #5", "Run Status EC Fan #6",
-        "Run Status EC Fan #7", "Run Status EC Fan #8", "Run Status EC Fan #9"
-    };
-
-    // Loop through and set all motor statuses to 0
-    for (const auto& desc : motorStatusDescriptions) {
-        Modbus_Point<ModbusIP>* point = equipment->getModbus_Point(desc);
-        if (point) {
-            point->setValue(1);
-        }
-    }
-}
-
-/**
- * @brief Logic to execute once when exiting the running state.
- * Sets the "Run Status" for all EC fans to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Running State...");
-    const std::vector<std::string> motorStatusDescriptions = {
-        "Run Status EC Fan #1", "Run Status EC Fan #2", "Run Status EC Fan #3",
-        "Run Status EC Fan #4", "Run Status EC Fan #5", "Run Status EC Fan #6",
-        "Run Status EC Fan #7", "Run Status EC Fan #8", "Run Status EC Fan #9"
-    };
-
-    // Loop through and set all motor statuses to 0
-    for (const auto& desc : motorStatusDescriptions) {
-        Modbus_Point<ModbusIP>* point = equipment->getModbus_Point(desc);
-        if (point) {
-            point->setValue(0);
-        }
-    }
-}
\ No newline at end of file
diff --git a/src/BMS/CRAH/CRAH_PETRA_PAHHC_600_C6_TCP/State_Standby.cpp b/src/BMS/CRAH/CRAH_PETRA_PAHHC_600_C6_TCP/State_Standby.cpp
deleted file mode 100644
index 1ee0de6..0000000
--- a/src/BMS/CRAH/CRAH_PETRA_PAHHC_600_C6_TCP/State_Standby.cpp
+++ /dev/null
@@ -1,135 +0,0 @@
-/**
- * @file State_Standby.cpp
- * @brief Implementation of the StandbyState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the StandbyState, which defines
- * the behavior of the equipment when it is in an idle or standby mode.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-/**
- * @brief Constructs a new StandbyState object.
- *
- * In this state, the equipment is idle. This constructor initializes strategies
- * to bring the system to a safe, idle condition. It sets a stable value for
- * the SAT reading and creates ramp strategies to bring the CW valve and all
- * EC fan speeds down to zero.
- */
-template<>
-StandbyState<ModbusIP>::StandbyState() {
-    // You can add initialization code here if needed
-    addStrategy("SAT Reading", new SingleValueStrategy(100.0f, 0.1f, 1000));
-    addStrategy("CW Valve Position", new RampStrategy(0.0f, 5.0f, 1000));
-    addStrategy("Speed EC Fan #1", new RampStrategy(0.0f, 5.0f, 1000));
-    addStrategy("Speed EC Fan #2", new RampStrategy(0.0f, 5.0f, 1000));
-    addStrategy("Speed EC Fan #3", new RampStrategy(0.0f, 5.0f, 1000));
-    addStrategy("Speed EC Fan #4", new RampStrategy(0.0f, 5.0f, 1000));
-    addStrategy("Speed EC Fan #5", new RampStrategy(0.0f, 5.0f, 1000));
-    addStrategy("Speed EC Fan #6", new RampStrategy(0.0f, 5.0f, 1000));
-    addStrategy("Speed EC Fan #7", new RampStrategy(0.0f, 5.0f, 1000));
-    addStrategy("Speed EC Fan #8", new RampStrategy(0.0f, 5.0f, 1000));
-    addStrategy("Speed EC Fan #9", new RampStrategy(0.0f, 5.0f, 1000));
-
-}
-
-/**
- * @brief Executes the standby state's logic for one update cycle.
- *
- * This method applies the strategies defined for the standby state (e.g.,
- * ramping values to zero).
- *
- * @warning This method currently does not check for a command to transition to the
- *          Running state. This logic needs to be added to allow the unit to start.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* StandbyState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Standby update function");
-    int On_Off_Command = getPointValue(equipment, "ON/OFF Command By BMS");
-    Serial.printf("ON_OFF COmmand %f. \n", On_Off_Command);
-    if (On_Off_Command == 1){
-        return new RunningState<ModbusIP>();
-    }
-
-    
-
-    
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the standby state.
- * This method performs cleanup by setting all alarm points and all EC fan
- * run status points to 0.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-// A list of all alarm descriptions
-    const std::vector<std::string> alarmDescriptions = {
-        "Alarm SAT Sensor Fault", "Alarm RAH Sensor Fault", "Alarm RAT Sensor Fault",
-        "Alarm Filter DP Sensor Fault", "Alarm Flooding", "Alarm Dirty Filter",
-        "Alarm High RAT", "Alarm Low RAT", "Alarm High SAT", "Alarm Low SAT",
-        "Alarm High RAH", "Alarm Low RAH", "Alarm Common", "Alarm Phase Failure",
-        "Alarm Condensate Pump", "Alarm Smoke", "Alarm Fire", "Alarm EC Fan #1",
-        "Alarm EC Fan #2", "Alarm EC Fan #3", "Alarm EC Fan #4", "Alarm EC Fan #5",
-        "Alarm EC Fan #6", "Alarm EC Fan #7", "Alarm EC Fan #8", "Alarm EC Fan #9"
-    };
-
-    // A list of all motor run status descriptions
-    const std::vector<std::string> motorStatusDescriptions = {
-        "Run Status EC Fan #1", "Run Status EC Fan #2", "Run Status EC Fan #3",
-        "Run Status EC Fan #4", "Run Status EC Fan #5", "Run Status EC Fan #6",
-        "Run Status EC Fan #7", "Run Status EC Fan #8", "Run Status EC Fan #9"
-    };
-
-    // Loop through and set all alarms to 0
-    for (const auto& desc : alarmDescriptions) {
-        Modbus_Point<ModbusIP>* point = equipment->getModbus_Point(desc);
-        if (point) {
-            point->setValue(0);
-        }
-    }
-
-    // Loop through and set all motor statuses to 0
-    for (const auto& desc : motorStatusDescriptions) {
-        Modbus_Point<ModbusIP>* point = equipment->getModbus_Point(desc);
-        if (point) {
-            point->setValue(0);
-        }
-    }
-}
-
-/**
- * @brief Logic to execute once when exiting the standby state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Standby State...");
-}
\ No newline at end of file
diff --git a/src/BMS/CRAH/CRAH_PETRA_PAHHC_600_C6_TCP/config.h b/src/BMS/CRAH/CRAH_PETRA_PAHHC_600_C6_TCP/config.h
deleted file mode 100644
index d115f19..0000000
--- a/src/BMS/CRAH/CRAH_PETRA_PAHHC_600_C6_TCP/config.h
+++ /dev/null
@@ -1,153 +0,0 @@
-/**
- * @file config.h
- * @brief Main configuration file for the CRAH Unit (TCP) emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * This file contains two important configurations: WiFi network parameters
- * and the Modbus register map for the device.
- */
-
-#ifndef CONFIG_H
-#define CONFIG_H
-
-#include "core.h"
-#include "Equipment/Equipment.h"
-
-#if defined(USE_MODBUS_IP)
-/**
-   * @defgroup ModbusTCPConfig Modbus IP Configuration
-   * @brief Parameters for Modbus TCP communication.
-   * @{
-   */
-  #include <ModbusIP_ESP8266.h>
-  const char *ssid = "QTS_CDR_Arduino";       /**< @brief The SSID of the WiFi network. */
-  const char *password = "123abc456";         /**< @brief The password for the WiFi network. */
-  IPAddress local_IP(172, 17, 33, 11);       /**< @brief The static IP address for the device. */
-  IPAddress gateway(172, 17, 33, 1);          /**< @brief The gateway IP address. */
-  IPAddress subnet(255, 255, 255, 0);         /**< @brief The subnet mask. */
-  
-  ModbusIP mb;
-#else
-  /**
-   * @defgroup ModbusRTUConfig Modbus RTU Configuration
-   * @brief Parameters for serial Modbus RTU communication.
-   * @{
-   */
-  #include <ModbusRTU.h>
-  const int BAUDRATE = 19200;   /**< @brief The serial communication speed in bits per second. */
-  const int RX_PIN = 17;        /**< @brief The GPIO pin used for receiving data (RX). */
-  const int TX_PIN = 16;        /**< @brief The GPIO pin used for transmitting data (TX). */
-  const int RST_PIN = 4;        /**< @brief The GPIO pin connected to the RS485 driver's DE/RE pins for direction control. */
-  const int MODBUS_ID = 1;      /**< @brief The unique slave ID for this device on the Modbus bus. */
-  /** @} */
-
-  /** @brief Global instance of the Modbus RTU server. */
-  ModbusRTU mb;
-#endif
-
-
-
-/**
- * @defgroup ModbusMapConfig Modbus Map Configuration
- * @brief Defines the Modbus register map and related parameters for the emulator.
- * @{
- */
-/**
- * @brief The Modbus map for the Equipment device.
- * This array defines all the Modbus points available on the emulated device.
- * The `description` field is crucial as it's used to look up points within the application logic.
- */
-modbusMap mb_map[] =
-{   
-  {HR,        13,     0,  "Delta"},
-  {HR,        14,     0,  "State Control"},  //Internal to control from Modscan
-  {HR,        15,     0,  "Fault Code"},
-  {HR_FLOAT,  17,     0,  "RAT"},     //Internal Fault code from Modscan  
-  {HR_FLOAT,  0,      0,  "SAT Setpoint"},                     
-  {HR_FLOAT,  680,    0,  "RAT Setpoint"},                   
-  {HR_FLOAT,  110,    0,  "High RAT Limit"},                 
-  {HR_FLOAT,  113,    0,  "Low RAT Limit"},                  
-  {HR_FLOAT,  117,    0,  "High SAT Limit"},                 
-  {HR_FLOAT,  121,    0,  "Low SAT Limit"},                  
-  {HR_FLOAT,  684,    0,  "High RAH Limit"},                 
-  {HR_FLOAT,  688,    0,  "Low RAH Limit"},                  
-  {HR,        4,      0,  "Setting the EC Fan Max Speed"},   
-  {HR,        694,    0,  "Setting the EC Fan Min Speed"},   
-  {HR_FLOAT,  692,    0,  "Setting Room Temp"},              
-  {HR_FLOAT,  690,    0,  "Setting EC Fan Speed"},          
-  {DI,        145,    0,  "Alarm SAT Sensor Fault"},         
-  {DI,        1245,   0,  "Alarm RAH Sensor Fault"},        
-  {DI,        1244,   0,  "Alarm RAT Sensor Fault"},        
-  {DI,        1249,   0,  "Alarm Filter DP Sensor Fault"},  
-  {DI,        50,     0,  "Alarm Flooding"},                  
-  {DI,        1095,   0,  "Alarm Dirty Filter"},            
-  {DI,        1366,   0,  "Alarm High RAT"},                
-  {DI,        1098,   0,  "Alarm Low RAT"},                 
-  {DI,        117,    0,  "Alarm High SAT"},                 
-  {DI,        121,    0,  "Alarm Low SAT"},                  
-  {DI,        1306,   0,  "Alarm High RAH"},                
-  {DI,        1307,   0,  "Alarm Low RAH"},                 
-  {DI,        1341,   0,  "Alarm Common"},                  
-  {DI,        147,    0,  "Alarm Phase Failure"},            
-  {DI,        1369,   0,  "Alarm Condensate Pump"},         
-  {DI,        1367,   0,  "Alarm Smoke"},                   
-  {DI,        1368,   0,  "Alarm Fire"},                    
-  {DI,        130,    0,  "Alarm EC Fan #1"},                
-  {DI,        131,    0,  "Alarm EC Fan #2"},                
-  {DI,        132,    0,  "Alarm EC Fan #3"},                
-  {DI,        133,    0,  "Alarm EC Fan #4"},                
-  {DI,        134,    0,  "Alarm EC Fan #5"},                
-  {DI,        135,    0,  "Alarm EC Fan #6"},                
-  {DI,        1359,   0,  "Alarm EC Fan #7"},               
-  {DI,        1360,   0,  "Alarm EC Fan #8"},               
-  {DI,        1361,   0,  "Alarm EC Fan #9"},               
-  {DI,        137,    0,  "Run Status EC Fan #1"},           
-  {DI,        138,    0,  "Run Status EC Fan #2"},           
-  {DI,        139,    0,  "Run Status EC Fan #3"},           
-  {DI,        140,    0,  "Run Status EC Fan #4"},           
-  {DI,        141,    0,  "Run Status EC Fan #5"},           
-  {DI,        142,    0,  "Run Status EC Fan #6"},           
-  {DI,        1362,   0,  "Run Status EC Fan #7"},          
-  {DI,        1363,   0,  "Run Status EC Fan #8"},          
-  {DI,        1364,   0,  "Run Status EC Fan #9"},          
-  {IR_FLOAT,  98,     0,  "SAT Reading"},                     
-  {IR_FLOAT,  69,     0,  "RAH Reading"},                     
-  {IR_FLOAT,  100,    0,  "RAT Reading"},                    
-  {IR_FLOAT,  105,    0,  "Filter DP Reading"},              
-  {IR_FLOAT,  495,    0,  "CW Valve Position"},              
-  {IR,        52,     0,  "Speed EC Fan #1"},                 
-  {IR,        227,    0,  "Speed EC Fan #2"},                
-  {IR,        228,    0,  "Speed EC Fan #3"},                
-  {IR,        229,    0,  "Speed EC Fan #4"},                
-  {IR,        230,    0,  "Speed EC Fan #5"},                
-  {IR,        231,    0,  "Speed EC Fan #6"},                
-  {IR,        677,    0,  "Speed EC Fan #7"},                
-  {IR,        678,    0,  "Speed EC Fan #8"},                
-  {IR,        679,    0,  "Speed EC Fan #9"},                
-  {IR,        273,    0,  "Operating Hours EC Fan #1"},      
-  {IR,        232,    0,  "Operating Hours EC Fan #2"},      
-  {IR,        243,    0,  "Operating Hours EC Fan #3"},      
-  {IR,        234,    0,  "Operating Hours EC Fan #4"},      
-  {IR,        235,    0,  "Operating Hours EC Fan #5"},      
-  {IR,        244,    0,  "Operating Hours EC Fan #6"},      
-  {IR,        485,    0,  "Operating Hours EC Fan #7"},      
-  {IR,        486,    0,  "Operating Hours EC Fan #8"},      
-  {IR,        487,    0,  "Operating Hours EC Fan #9"},      
-  {COIL,      300,    0,  "ON/OFF Command By BMS"},        
-  {COIL,      301,    0,  "Enable Off By Supervisory"},    
-  {COIL,      264,    0,  "Alarm Reset"}                                  
-};
-//Size of modbus map used in FOR cycles, automatically calculated.
-
-/**
- * @brief The total number of entries in the `mb_map` array.
- * This is calculated at compile time and used for iterating over the map.
- */
-const int map_size = sizeof(mb_map) / sizeof(mb_map[0]);
-
-/** @brief The main loop update interval in milliseconds. */
-int interval = 250; 
-/** @} */ // End of ModbusMapConfig group
-
-#endif // CONFIG_H
diff --git a/src/BMS/CRAH/CRAH_PETRA_PAHHC_600_C6_TCP/main.cpp b/src/BMS/CRAH/CRAH_PETRA_PAHHC_600_C6_TCP/main.cpp
deleted file mode 100644
index 286a98c..0000000
--- a/src/BMS/CRAH/CRAH_PETRA_PAHHC_600_C6_TCP/main.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-/**
- * @file main.cpp
- * @brief Main execution program for the CRAH Unit (TCP) Emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * @details This file contains the main execution program for an Arduino-based emulator of a CRAH unit. 
- * The program uses a Wi-Fi connection to communicate via the Modbus IP protocol.
- *
- * The setup() function initializes the following:
- * - Serial communication for debugging.
- * - Wi-Fi connection using credentials from config.h.
- * - A Modbus TCP server.
- * - Modbus points (Coils, Holding Registers, etc.) based on a predefined map in config.h.
- *
- * The loop() function continuously:
- * - Services the Modbus TCP server to handle incoming requests.
- * - Periodically calls the main update loop for the emulated equipment, which
- *   manages state transitions and behavior strategies.
- *
- * @see config.h for Wi-Fi and Modbus configuration.
- * @see Equipment.h for the main equipment logic.
- * @see State.h for different equipment states.
- * @see Strategies/Strategy_Behavior.h for value generation strategies.
- * @see Modbus_Point.h for the base class for all Modbus points.
- */
-//=================================================================================================================================
-//Libraries and declaration of variables.
-#include <WiFi.h>
-#include "config.h"
-#include "ModbusPoints/Modbus_PointFactory.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-//=================================================================================================================================
-/** 
- * @brief Initializes the application.
- * @details This function runs once at startup. It configures the serial communication, 
- * Wi-Fi, and the Modbus server. It also creates and initializes all the Modbus points 
- * based on the `mb_map` array in `config.h`.
- */
-void setup() {
-  Serial.begin(115200);                       //Serial comm start
-  WiFi.config(local_IP, gateway, subnet);     // Wifi service start
-  WiFi.begin(ssid, password);
-  while (WiFi.status() != WL_CONNECTED) {
-    delay(1000);
-    Serial.print(".");
-  }
-  Serial.println("Connected!!");
-  mb.server();                                //Modbus server start
-  Serial.println("Server Created");
-  Serial.println(map_size);
-  for(int i = 0; i < map_size; i++){
-    Modbus_Point<ModbusIP>* point = createModbus_Point(&mb, mb_map[i].category, mb_map[i].address, mb_map[i].value, mb_map[i].description);
-    if (point) {
-      point->addToModbusServer();
-      EquipmentInstance.addModbus_Point(mb_map[i].description, point);
-    }
-  }
-  Serial.println("All modbus Points created");
-  Serial.println("Setup function ended");
-}
-//=================================================================================================================================
-/** 
- * @brief The main application loop.
- * @details This function runs repeatedly after setup() has completed. It performs two main actions:
- * 1. It continuously services the Modbus server by calling `mb.task()` to handle
- *    incoming requests from a Modbus master.
- * 2. At a fixed interval (defined in `config.h`), it calls `EquipmentInstance.update()`
- *    to run the emulator's internal state machine and behavior logic.
- */
-void loop() {
-  mb.task();
-  unsigned long currentMillis = millis();
-  if (currentMillis - previousMillis >= interval) {
-    previousMillis = currentMillis;
-    unsigned long startTime = millis();
-    EquipmentInstance.update();
-    unsigned long endTime = millis();
-    unsigned long elapsedTime = endTime - startTime;
-    Serial.printf("Control Execution time: %d ms\n", elapsedTime);
-  } 
-}
diff --git a/src/BMS/CRAH/CRAH_TxAir_BASX_TCP_PHXA7/README.md b/src/BMS/CRAH/CRAH_TxAir_BASX_TCP_PHXA7/README.md
deleted file mode 100644
index 355156f..0000000
--- a/src/BMS/CRAH/CRAH_TxAir_BASX_TCP_PHXA7/README.md
+++ /dev/null
@@ -1,33 +0,0 @@
-# EQUIPMENT_TYPE MANUFACTURER MODEL TCP
-
-## Brief Introduction
-Equipment specifc details that make it different from other devices
-
-## List of Equipmentt
-This cofiguration has been used for these models:
-* **Model**: 09-15-22 
-* **Model**: 09-15-23 
-* **Model**: 09-15-25 
-
-## Hardware Prerequisites
-
-The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities.
-* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html) 
-
----
-
-## States and Strategies
-Provide a brief description of what variables and strategies were used in this configuraiton
-
-### Standby State
-* **Equipment running**: set to 0
-* **Common Alarm**: set to 0
-* **SAT temperature**: set to 85
-
-### Running State
-* **Equipment running**: set to 1
-* **SAT temperature**: **Ramp Strategy** set to 65 deg setpoint
-
-### Fail State
-* **Commong Alarm**: set to 1
-* **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset
diff --git a/src/BMS/CRAH/CRAH_TxAir_BASX_TCP_PHXA7/State_Fail.cpp b/src/BMS/CRAH/CRAH_TxAir_BASX_TCP_PHXA7/State_Fail.cpp
deleted file mode 100644
index 8bc0385..0000000
--- a/src/BMS/CRAH/CRAH_TxAir_BASX_TCP_PHXA7/State_Fail.cpp
+++ /dev/null
@@ -1,81 +0,0 @@
-/**
- * @file State_Fail.cpp
- * @brief Implementation of the FailState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the FailState, which defines
- * the behavior of the equipment when it has entered a fault condition.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new FailState object with a list of active alarms.
- *
- * This constructor receives a list of alarm descriptions and creates strategies
- * to set the corresponding Modbus points to a value of 1, indicating an
- * active alarm. It also initializes a PID strategy for the 'CW Valve Position'
- * to maintain its state during the fault.
- * @param activeAlarms A vector of strings, where each string is the
- *                     description of a Modbus point to be set as an active alarm.
- */
-template<>
-FailState<ModbusIP>::FailState(const std::vector<std::string>& activeAlarms) {
-    // Simulate a failure: set common alarm and a specific fan alarm.
-
-    
-}
-
-/**
- * @brief Executes the fail state's logic for one update cycle.
- *
- * This method checks the "Alarm Reset" Modbus point for a command to
- * transition back to Standby, which would typically happen after a fault
- * is cleared by a user. If no transition is requested, it continues to apply
- * the failure strategies (e.g., keeping alarm bits active).
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* FailState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Fail update function");
-    
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the fail state.
- * Sets the "Alarm Common" point to 1 to indicate a general fault condition.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Fail State...");
-}
-
-/**
- * @brief Logic to execute once when exiting the fail state.
- * Clears the "Alarm Common" point to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Fail State...");
-}
\ No newline at end of file
diff --git a/src/BMS/CRAH/CRAH_TxAir_BASX_TCP_PHXA7/State_Running.cpp b/src/BMS/CRAH/CRAH_TxAir_BASX_TCP_PHXA7/State_Running.cpp
deleted file mode 100644
index b9e4a99..0000000
--- a/src/BMS/CRAH/CRAH_TxAir_BASX_TCP_PHXA7/State_Running.cpp
+++ /dev/null
@@ -1,89 +0,0 @@
-/**
- * @file State_Running.cpp
- * @brief Implementation of the RunningState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the RunningState, which defines
- * the behavior of the equipment when it is actively running.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "Strategies/Strategy_Totalizer.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new RunningState object.
- *
- * This constructor initializes behavior strategies active during the running
- * state, such as a PID controller for the 'CW Valve Position' and totalizers
- * for the run-hours of each EC fan.
- */
-template<>
-RunningState<ModbusIP>::RunningState() {
-}
-
-/**
- * @brief Executes the running state's logic for one update cycle.
- *
- * This method first checks for state transition commands:
- * 1. It reads the "ON/OFF Command By BMS" point. If it's 0, it transitions to StandbyState.
- * 2. It reads the "Fault Code" point. If it's non-zero, it transitions to FailState,
- *    passing the corresponding alarm description.
- *
- * If no transition occurs, it applies the strategies defined for the running state.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* RunningState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Running update function");
-    
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the running state.
- * Sets the "Run Status" for all EC fans to 1 to indicate they are active.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Running State...");
-    // You could also update a Modbus register to show the "standby" state
-
-}
-
-/**
- * @brief Logic to execute once when exiting the running state.
- * Sets the "Run Status" for all EC fans to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Running State...");
-   
-}
\ No newline at end of file
diff --git a/src/BMS/CRAH/CRAH_TxAir_BASX_TCP_PHXA7/State_Standby.cpp b/src/BMS/CRAH/CRAH_TxAir_BASX_TCP_PHXA7/State_Standby.cpp
deleted file mode 100644
index a6273a2..0000000
--- a/src/BMS/CRAH/CRAH_TxAir_BASX_TCP_PHXA7/State_Standby.cpp
+++ /dev/null
@@ -1,100 +0,0 @@
-/**
- * @file State_Standby.cpp
- * @brief Implementation of the StandbyState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the StandbyState, which defines
- * the behavior of the equipment when it is in an idle or standby mode.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-/**
- * @brief Constructs a new StandbyState object.
- *
- * In this state, the equipment is idle. This constructor initializes strategies
- * to bring the system to a safe, idle condition. It sets a stable value for
- * the SAT reading and creates ramp strategies to bring the CW valve and all
- * EC fan speeds down to zero.
- */
-template<>
-StandbyState<ModbusIP>::StandbyState() {
-    // You can add initialization code here if needed
-     addStrategy("Cool_PID_Demand", new SawStrategy(100.0f, 1000.0f, 12.0f, 1000));
-     addStrategy("SAT", new SawStrategy(100.0f, 1000.0f, 12.0f, 1000));
-     addStrategy("RAT", new SawStrategy(100.0f, 1000.0f, 12.0f, 1000));
-     addStrategy("RAH", new SawStrategy(100.0f, 1000.0f, 12.0f, 1000));
-     addStrategy("Plenum_DP", new SawStrategy(100.0f, 1000.0f, 12.0f, 1000));
-     addStrategy("CCV_Fdbk", new SawStrategy(100.0f, 1000.0f, 12.0f, 1000));
-     addStrategy("CCV_Cmd", new SawStrategy(100.0f, 1000.0f, 12.0f, 1000));
-     addStrategy("Active_SAT_SP", new SawStrategy(100.0f, 1000.0f, 12.0f, 1000));
-     addStrategy("Active_SF_Spd_Cmd", new SawStrategy(100.0f, 1000.0f, 12.0f, 1000));
-     addStrategy("SF1_Fbk", new SawStrategy(100.0f, 1000.0f, 12.0f, 1000));
-     addStrategy("SF2_Fbk", new SawStrategy(100.0f, 1000.0f, 12.0f, 1000));
-     addStrategy("SF1_Pwr", new SawStrategy(100.0f, 1000.0f, 12.0f, 1000));
-     addStrategy("SF2_Pwr", new SawStrategy(100.0f, 1000.0f, 12.0f, 1000));
-     addStrategy("RAT_PID_OUT", new SawStrategy(100.0f, 1000.0f, 12.0f, 1000));
-     addStrategy("SF1_Fbk_Percent_Supply", new SawStrategy(100.0f, 1000.0f, 12.0f, 1000));
-     addStrategy("SF2_Fbk_Percent_Supply", new SawStrategy(100.0f, 1000.0f, 12.0f, 1000));
-     addStrategy("Run_Hours", new SawStrategy(100.0f, 1000.0f, 12.0f, 1000));
-}
-
-/**
- * @brief Executes the standby state's logic for one update cycle.
- *
- * This method applies the strategies defined for the standby state (e.g.,
- * ramping values to zero).
- *
- * @warning This method currently does not check for a command to transition to the
- *          Running state. This logic needs to be added to allow the unit to start.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* StandbyState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Standby update function");
-    
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the standby state.
- * This method performs cleanup by setting all alarm points and all EC fan
- * run status points to 0.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Standby State...");
-}
-
-/**
- * @brief Logic to execute once when exiting the standby state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Standby State...");
-}
\ No newline at end of file
diff --git a/src/BMS/CRAH/CRAH_TxAir_BASX_TCP_PHXA7/config.h b/src/BMS/CRAH/CRAH_TxAir_BASX_TCP_PHXA7/config.h
deleted file mode 100644
index 45b8336..0000000
--- a/src/BMS/CRAH/CRAH_TxAir_BASX_TCP_PHXA7/config.h
+++ /dev/null
@@ -1,151 +0,0 @@
-/**
- * @file config.h
- * @brief Main configuration file for the CRAH Unit (TCP) emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * This file contains two important configurations: WiFi network parameters
- * and the Modbus register map for the device.
- */
-
-#ifndef CONFIG_H
-#define CONFIG_H
-
-#include "core.h"
-#include "Equipment/Equipment.h"
-
-#if defined(USE_MODBUS_IP)
-/**
-   * @defgroup ModbusTCPConfig Modbus IP Configuration
-   * @brief Parameters for Modbus TCP communication.
-   * @{
-   */
-  #include <ModbusIP_ESP8266.h>
-  const char *ssid = "PHXA7";       /**< @brief The SSID of the WiFi network. */
-  const char *password = "password";   /**< @brief The password for the WiFi network. */
-  IPAddress local_IP(172, 17, 40, 25);       /**< @brief The static IP address for the device. */
-  IPAddress gateway(172, 17, 40, 1);          /**< @brief The gateway IP address. */
-  IPAddress subnet(255, 255, 255, 0);         /**< @brief The subnet mask. */
-  
-  ModbusIP mb;
-#else
-  /**
-   * @defgroup ModbusRTUConfig Modbus RTU Configuration
-   * @brief Parameters for serial Modbus RTU communication.
-   * @{
-   */
-  #include <ModbusRTU.h>
-  const int BAUDRATE = 19200;   /**< @brief The serial communication speed in bits per second. */
-  const int RX_PIN = 17;        /**< @brief The GPIO pin used for receiving data (RX). */
-  const int TX_PIN = 16;        /**< @brief The GPIO pin used for transmitting data (TX). */
-  const int RST_PIN = 4;        /**< @brief The GPIO pin connected to the RS485 driver's DE/RE pins for direction control. */
-  const int MODBUS_ID = 1;      /**< @brief The unique slave ID for this device on the Modbus bus. */
-  /** @} */
-
-  /** @brief Global instance of the Modbus RTU server. */
-  ModbusRTU mb;
-#endif
-
-
-
-/**
- * @defgroup ModbusMapConfig Modbus Map Configuration
- * @brief Defines the Modbus register map and related parameters for the emulator.
- * @{
- */
-/**
- * @brief The Modbus map for the Equipment device.
- * This array defines all the Modbus points available on the emulated device.
- * The `description` field is crucial as it's used to look up points within the application logic.
- */
-modbusMap mb_map[] =
-{   
-  {COIL,      0,    0,  "BMS_OnOff"},
-  {COIL,      1,    0,  "Alm_reset"},
-  {COIL,      2,    0,  "BMS_HB"},
-  {COIL,      3,    0,  "BMS_CCV_Ovrride"},
-  {COIL,      4,    0,  "BMD_SF_Override"},
-  {COIL,      6,    0,  "BMS_Monitor_Disabled"},
-  {DI,        0,    0,  "Alm_General"},
-  {DI,        1,    0,  "Sensor_Fault"},
-  {DI,        2,    0,  "PLC_HB"},
-  {DI,        3,    0,  "SF_Start_Cmd"},
-  {DI,        4,    0,  "SF_Proven"},
-  {DI,        5,    0,  "SF1_Running"},
-  {DI,        6,    0,  "SF2_Running"},
-  {DI,        7,    0,  "Cool_Allowed"},
-  {DI,        8,    0,  "Alm_BMS_Lost"},
-  {DI,        9,    0,  "Alm_Ext_Intlk"},
-  {DI,        10,   0,  "Alm_Hi_Static"},
-  {DI,        11,   0,  "Alm_Leak"},
-  {DI,        12,   0,  "Alm_Pump"}, 
-  {DI,        13,   0,  "Alm_Filter"},
-  {DI,        14,   0,  "Alm_CCV_Pos"},
-  {DI,        15,   0,  "Alm_Hi_SAT"},
-  {DI,        16,   0,  "Alm_Low_SAT"},
-  {DI,        17,   0,  "Alm_Hi_RAT"},
-  {DI,        18,   0,  "Alm_Low_RAT"},
-  {DI,        19,   0,  "Alm_Hi_RAH"},
-  {DI,        20,   0,  "Alm_Low_RAH"},
-  {DI,        21,   0,  "SF1_Fault"},
-  {DI,        22,   0,  "SF2_Fault"},
-  {DI,        23,   0,  "SF1_Offline"},
-  {DI,        24,   0,  "SF2_Offline"},
-  {DI,        25,   0,  "SF1_ECM_Proof"},
-  {DI,        26,   0,  "SF2_ECM_Proof"},
-  {DI,        27,   0,  "SF1_Dir_Supply"},
-  {DI,        28,   0,  "SF2_Dir_Supply"},
-  {DI,        29,   0,  "Condensate_Pump_Running"},
-  {HR,        0,    0,  "BMS_CCV_Pos"},
-  {HR,        1,    0,  "BMS_SAT_SP"},
-  {HR,        2,    0,  "BMS_SF_Speed_cmd"},
-  {HR,        3,    0,  "BMS_Timeout"},
-  {HR,        4,    0,  "CCV_alm_Delay_Cooling"},
-  {HR,        5,    0,  "CCV_alm_Pos_Cooling"},
-  {HR,        6,    0,  "CCV_Startup_Pos_Cooling"},
-  {HR,        7,    0,  "CCV_Startup_Time_Cooling"},
-  {HR,        8,    0,  "Hi_RAH_SP"},
-  {HR,        9,    0,  "Hi_RAT_SP"},
-  {HR,        10,   0,  "Hi_SAT_SP"},
-  {HR,        11,   0,  "Low_RAH_SP"},
-  {HR,        12,   0,  "Low_RAT_SP"},
-  {HR,        13,   0,  "Low_SAT_SP"},
-  {HR,        14,   0,  "Hum_Alm_Delay"},
-  {HR,        15,   0,  "SF_Startup_SPD"},
-  {HR,        16,   0,  "SF_Startup_Time"},
-  {HR,        17,   0,  "Temp_Alm_Delay"},
-  {HR,        18,   0,  "RAT_SP"},
-  {IR,        0,    0,  "Cool_PID_Demand"},
-  {IR,        1,    0,  "SAT"}, 
-  {IR,        2,    0,  "RAT"},
-  {IR,        3,    0,  "RAH"},
-  {IR,        4,    0,  "Plenum_DP"},
-  {IR,        5,    0,  "CCV_Fdbk"},
-  {IR,        6,    0,  "CCV_Cmd"},
-  {IR,        8,    0,  "Active_SAT_SP"},
-  {IR,        9,    0,  "Active_SF_Spd_Cmd"},
-  {IR,        10,   0,  "SF_SPD_CMD"},
-  {IR,        11,   0,  "SF1_Fbk"},
-  {IR,        12,   0,  "SF2_Fbk"},
-  {IR,        13,   0,  "SF1_Pwr"},
-  {IR,        14,   0,  "SF2_Pwr"},
-  {IR,        15,   0,  "SF1_Fault"},
-  {IR,        16,   0,  "SF2_Fault"},
-  {IR,        17,   0,  "RAT_PID_OUT"},
-  {IR,        18,   0,  "SF1_Fbk_Percen_Supply"},
-  {IR,        19,   0,  "SF2_Fbk_Percen_Supply"},
-  {IR,        20,   0,  "Run_Hours"},
-}; 
-//Size of modbus map used in FOR cycles, automatically calculated.
-
-/**
- * @brief The total number of entries in the `mb_map` array.
- * This is calculated at compile time and used for iterating over the map.
- */
-const int map_size = sizeof(mb_map) / sizeof(mb_map[0]);
-
-/** @brief The main loop update interval in milliseconds. */
-int interval = 250; 
-/** @} */ // End of ModbusMapConfig group
-
-#endif // CONFIG_H
diff --git a/src/BMS/CRAH/CRAH_TxAir_BASX_TCP_PHXA7/main.cpp b/src/BMS/CRAH/CRAH_TxAir_BASX_TCP_PHXA7/main.cpp
deleted file mode 100644
index 286a98c..0000000
--- a/src/BMS/CRAH/CRAH_TxAir_BASX_TCP_PHXA7/main.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-/**
- * @file main.cpp
- * @brief Main execution program for the CRAH Unit (TCP) Emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * @details This file contains the main execution program for an Arduino-based emulator of a CRAH unit. 
- * The program uses a Wi-Fi connection to communicate via the Modbus IP protocol.
- *
- * The setup() function initializes the following:
- * - Serial communication for debugging.
- * - Wi-Fi connection using credentials from config.h.
- * - A Modbus TCP server.
- * - Modbus points (Coils, Holding Registers, etc.) based on a predefined map in config.h.
- *
- * The loop() function continuously:
- * - Services the Modbus TCP server to handle incoming requests.
- * - Periodically calls the main update loop for the emulated equipment, which
- *   manages state transitions and behavior strategies.
- *
- * @see config.h for Wi-Fi and Modbus configuration.
- * @see Equipment.h for the main equipment logic.
- * @see State.h for different equipment states.
- * @see Strategies/Strategy_Behavior.h for value generation strategies.
- * @see Modbus_Point.h for the base class for all Modbus points.
- */
-//=================================================================================================================================
-//Libraries and declaration of variables.
-#include <WiFi.h>
-#include "config.h"
-#include "ModbusPoints/Modbus_PointFactory.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-//=================================================================================================================================
-/** 
- * @brief Initializes the application.
- * @details This function runs once at startup. It configures the serial communication, 
- * Wi-Fi, and the Modbus server. It also creates and initializes all the Modbus points 
- * based on the `mb_map` array in `config.h`.
- */
-void setup() {
-  Serial.begin(115200);                       //Serial comm start
-  WiFi.config(local_IP, gateway, subnet);     // Wifi service start
-  WiFi.begin(ssid, password);
-  while (WiFi.status() != WL_CONNECTED) {
-    delay(1000);
-    Serial.print(".");
-  }
-  Serial.println("Connected!!");
-  mb.server();                                //Modbus server start
-  Serial.println("Server Created");
-  Serial.println(map_size);
-  for(int i = 0; i < map_size; i++){
-    Modbus_Point<ModbusIP>* point = createModbus_Point(&mb, mb_map[i].category, mb_map[i].address, mb_map[i].value, mb_map[i].description);
-    if (point) {
-      point->addToModbusServer();
-      EquipmentInstance.addModbus_Point(mb_map[i].description, point);
-    }
-  }
-  Serial.println("All modbus Points created");
-  Serial.println("Setup function ended");
-}
-//=================================================================================================================================
-/** 
- * @brief The main application loop.
- * @details This function runs repeatedly after setup() has completed. It performs two main actions:
- * 1. It continuously services the Modbus server by calling `mb.task()` to handle
- *    incoming requests from a Modbus master.
- * 2. At a fixed interval (defined in `config.h`), it calls `EquipmentInstance.update()`
- *    to run the emulator's internal state machine and behavior logic.
- */
-void loop() {
-  mb.task();
-  unsigned long currentMillis = millis();
-  if (currentMillis - previousMillis >= interval) {
-    previousMillis = currentMillis;
-    unsigned long startTime = millis();
-    EquipmentInstance.update();
-    unsigned long endTime = millis();
-    unsigned long elapsedTime = endTime - startTime;
-    Serial.printf("Control Execution time: %d ms\n", elapsedTime);
-  } 
-}
diff --git a/src/BMS/CRAH/CRAH_UMAS_TCP/README.md b/src/BMS/CRAH/CRAH_UMAS_TCP/README.md
deleted file mode 100644
index ed80569..0000000
--- a/src/BMS/CRAH/CRAH_UMAS_TCP/README.md
+++ /dev/null
@@ -1,48 +0,0 @@
-# Datahall CRAH UMAS 10FSV041206-058-117.00x114.00 TCP
-
-## Brief Introduction
-This is first of a kind CRAH, so Modbus maps are different.
-BMS Control Source (0:speed, 1:external room temp) and
-BMS Enable Source (0:keypad, 1:DI, 2:BMS) sent from PLC/Modscan
-PLC code for these CRAHs use Speed Control, i.e. Speed Setpoint sent from PLC/BMS.
-Return Air is generally not used for control during normal operation.
-Leak Detect alarm is the only alarm that will send unit to FailState.
-This is a (9) fan array CRAH unit.
-
-## List of Equipmentt
-This cofiguration has been used for these models:
-* **Model: 10FSV041206-058-117.00x114.00**: 10-07-25
-
-## Hardware Prerequisites
-
-The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities.
-* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html) 
-
----
-
-## States and Strategies
-Provide a brief description of what variables and strategies were used in this configuraiton
-
-### Standby State
-* **CW valve**: **Ramp Strategy** ramp to 0
-* **Supply Air temperature**: **Ramp Strategy** ramp to 74
-* **Return Air temperature**: **Ramp Strategy** ramp to 86
-* **Fan speeds**: **Ramp Strategy** ramp to 0
-* **Fan amps**: **Ramp Strategy** ramp to 0
-* **Fan run status**: set to 0
-
-### Running State
-* **Fan run status**: set to 1
-* **Fan min speed**: initialized to 30
-* **Fan max speed**: initialized to 100
-* **Fan speed**: **Ramp Strategy** dynamically ramps to speed setpoint
-* **Fan amps**: **Ramp Strategy** ramp to 15
-* **Fan operating hours**: initialize totalizers
-* **Supply air temperature**: **Saw Strategy** ramps back and forth between 60 and 100 deg
-* **CW valve**: **PID Strategy** adjusts until Supply Air Temperature matches Supply Air Temperature setpoint
-
-### Fail State
-* **Fan run status**: set to 0
-* **CW valve**: **Ramp Strategy** ramp to 0
-* **Fan speeds**: **Ramp Strategy** ramp to 0
-* **Fan amps**: **Ramp Strategy** ramp to 0
\ No newline at end of file
diff --git a/src/BMS/CRAH/CRAH_UMAS_TCP/StateUtils.cpp b/src/BMS/CRAH/CRAH_UMAS_TCP/StateUtils.cpp
deleted file mode 100644
index f479c57..0000000
--- a/src/BMS/CRAH/CRAH_UMAS_TCP/StateUtils.cpp
+++ /dev/null
@@ -1,220 +0,0 @@
-/**
- * @file StateUtils.cpp
- * @brief Implementation of the StateUtils class.
- * @author Robert J. Davis
- * @date 2025-10-03
- *
- * This file contains implementation of utility functions that are used in multiple States.
- */
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include "StateUtils.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief This function is used to update the Control Mode (feedback), 
- * based on the selected BMS Control Source and BMS Enable Source.
- * 
- * This is a function used in the update() of the Standby, Running, and Fail States.
- *
-*/ 
-void updateControlMode(Equipment<ModbusIP>* equipment){
-        Modbus_Point<ModbusIP>* BMS_Control_Source_Pt = equipment -> getModbus_Point ("BMS Control Source");
-        Modbus_Point<ModbusIP>* BMS_Enable_Source_Pt = equipment -> getModbus_Point ("BMS Enable Source");
-        Modbus_Point<ModbusIP>* Control_Mode_Pt = equipment -> getModbus_Point ("Control Mode Selected");
-        int BMS_Control_Source = BMS_Control_Source_Pt ? BMS_Control_Source_Pt->getValue() : 0;
-        int BMS_Enable_Source = BMS_Enable_Source_Pt ? BMS_Enable_Source_Pt->getValue() : 0;
-        int Control_Mode_Selected = Control_Mode_Pt ? Control_Mode_Pt->getValue() : -1;
-
-        if (BMS_Control_Source == 0 && BMS_Enable_Source == 2) {
-            Control_Mode_Selected = 0;
-        } else if (BMS_Control_Source == 1 && BMS_Enable_Source == 2) {
-            Control_Mode_Selected = 1;
-        } else if (BMS_Enable_Source == 0) {
-            Control_Mode_Selected = 2;
-        }
-        equipment->setModbus_Point("Control Mode Selected", Control_Mode_Selected);
-}
-
-/** This function will set RA Temp, SA Temp, RA Humidity analog values to a LOW or HIGH range for testing alarms in Ignition.
- * There is an associated COIL for performing each of those functions.
- * There is also a NORMAL bit, which sends a one-shot to reset the associated analog value back into a normal range.
- */
-
-void updateAnalogs(Equipment<ModbusIP>* equipment){
-    if (equipment->getModbus_Point("RA Temp NORMAL")->getValue()==1){
-        equipment->setModbus_Point("Return Air Temp", 84.0f);
-        equipment->setModbus_Point("RA Temp Low Alarm ON", 0);
-        equipment->setModbus_Point("RA Temp High Alarm ON", 0);
-        equipment->setModbus_Point("RA Temp NORMAL", 0);
-    }
-    else if (equipment->getModbus_Point("RA Temp Low Alarm ON")->getValue() ==1){
-        equipment->setModbus_Point("Return Air Temp", 60.0f);
-        equipment->setModbus_Point("RA Temp High Alarm ON", 0);
-    }
-    else if (equipment->getModbus_Point("RA Temp High Alarm ON")->getValue()==1){
-        equipment->setModbus_Point("Return Air Temp", 110.0f);
-        equipment->setModbus_Point("RA Temp Low Alarm ON", 0);
-    }
-
-    if (equipment->getModbus_Point("RA Humidity NORMAL")->getValue()==1){
-        equipment->setModbus_Point("Return Humidity", 25.0f);
-        equipment->setModbus_Point("RA Humidity Low Alarm ON", 0);
-        equipment->setModbus_Point("RA Humidity High Alarm ON", 0);
-        equipment->setModbus_Point("RA Humidity NORMAL", 0);
-    }
-    else if (equipment->getModbus_Point("RA Humidity Low Alarm ON")->getValue()==1){
-        equipment->setModbus_Point("Return Humidity", 5.0f);
-        equipment->setModbus_Point("RA Humidity High Alarm ON", 0);
-    }
-    else if (equipment->getModbus_Point("RA Humidity High Alarm ON")->getValue()==1){
-        equipment->setModbus_Point("Return Humidity", 80.0f);
-        equipment->setModbus_Point("RA Humidity Low Alarm ON", 0);
-    }
-
-    if (equipment->getModbus_Point("SA Temp NORMAL")->getValue()==1){
-        equipment->setModbus_Point("Supply Air Temp", 76.0f);
-        equipment->setModbus_Point("SA Temp Low Alarm ON", 0);
-        equipment->setModbus_Point("SA Temp High Alarm ON", 0);
-        equipment->setModbus_Point("SA Temp NORMAL", 0);
-    }
-    else if (equipment->getModbus_Point("SA Temp Low Alarm ON")->getValue() ==1){
-        equipment->setModbus_Point("Supply Air Temp", 60.0f);
-        equipment->setModbus_Point("SA Temp High Alarm ON", 0);
-    }
-    else if (equipment->getModbus_Point("SA Temp High Alarm ON")->getValue()==1){
-        equipment->setModbus_Point("Supply Air Temp", 90.0f);
-        equipment->setModbus_Point("SA Temp Low Alarm ON", 0);
-    }
-    
-}
-
-// Updates the RA Temp Alarms
-void updateReturnAirTempAlarms(Equipment<ModbusIP>* equipment){
-    Modbus_Point<ModbusIP>* returnAirTemp = equipment -> getModbus_Point("Return Air Temp");
-    Modbus_Point<ModbusIP>* returnTempHighAlarmSP = equipment->getModbus_Point("Return Air Temp Alarm High SP");
-    Modbus_Point<ModbusIP>* returnTempLowAlarmSP = equipment->getModbus_Point("Return Air Temp Alarm Low SP");
-
-    if (returnAirTemp->getValue() < returnTempLowAlarmSP->getValue()) {
-        equipment->setModbus_Point("Alarm Low Return Air Temp", 1);
-        equipment->setModbus_Point("Alarm High Return Air Temp", 0);
-    }
-    else if (returnAirTemp->getValue() > returnTempHighAlarmSP->getValue()) {
-        equipment->setModbus_Point("Alarm High Return Air Temp", 1);
-        equipment->setModbus_Point("Alarm Low Return Air Temp", 0);
-    }
-    else{
-        equipment->setModbus_Point("Alarm High Return Air Temp", 0);
-        equipment->setModbus_Point("Alarm Low Return Air Temp", 0);
-    }
-        
-}
-
-// Updates the SA Temp Alarms
-void updateSupplyAirTempAlarms(Equipment<ModbusIP>* equipment){
-    Modbus_Point<ModbusIP>* supplyAirTemp = equipment -> getModbus_Point("Supply Air Temp");
-    Modbus_Point<ModbusIP>* supplyTempHighAlarmSP = equipment->getModbus_Point("Supply Air Temp Alarm High SP");
-    Modbus_Point<ModbusIP>* supplyTempLowAlarmSP = equipment->getModbus_Point("Supply Air Temp Alarm Low SP");
-
-    if (supplyAirTemp->getValue() > supplyTempHighAlarmSP->getValue()) {
-        equipment->setModbus_Point("Alarm High Supply Temp", 1);
-        equipment->setModbus_Point("Alarm Low Supply Temp", 0);
-    }
-    else if (supplyAirTemp->getValue() < supplyTempLowAlarmSP->getValue()) {
-        equipment->setModbus_Point("Alarm Low Supply Temp", 1);
-        equipment->setModbus_Point("Alarm High Supply Temp", 0);
-    }
-    else{
-        equipment->setModbus_Point("Alarm High Supply Temp", 0);
-        equipment->setModbus_Point("Alarm Low Supply Temp", 0);
-    }
-}
-
-// Updates the RA Humidity Alarms
-void updateReturnHumidityAlarms(Equipment<ModbusIP>* equipment){
-    Modbus_Point<ModbusIP>* returnHumidity = equipment -> getModbus_Point("Return Humidity");
-    Modbus_Point<ModbusIP>* returnHumHighAlarmSP = equipment->getModbus_Point("Return Humidity Alarm High SP");
-    Modbus_Point<ModbusIP>* returnHumLowAlarmSP = equipment->getModbus_Point("Return Humidity Alarm Low SP");
-
-    if (returnHumidity->getValue() > returnHumHighAlarmSP->getValue()) {
-        equipment->setModbus_Point("Alarm High Return Humidity", 1);
-        equipment->setModbus_Point("Alarm Low Return Humidity", 0);
-    }
-    else if (returnHumidity->getValue() < returnHumLowAlarmSP->getValue()) {
-        equipment->setModbus_Point("Alarm Low Return Humidity", 1);
-        equipment->setModbus_Point("Alarm High Return Humidity", 0);
-    }
-    else{
-        equipment->setModbus_Point("Alarm High Return Humidity", 0);
-        equipment->setModbus_Point("Alarm Low Return Humidity", 0);
-    }
-}
-
-/**
- * @brief This function will update the Alarm status DI bits according to the Alarm Commands from Coils (Modscan)
- * It will also update the Common Alarm: if any alarm is active, the Common alarm will also be active.
- * 
- * This is a function used in the update() of the Standby, Running, and Fail States.
- *
-*/ 
-void updateAlarms(Equipment<ModbusIP>* equipment){
-    const std::vector<std::string> alarmDescriptions = {
-        "Alarm Fan 1", "Alarm Fan 2", "Alarm Fan 3", "Alarm Fan 4", 
-        "Alarm Fan 5", "Alarm Fan 6", "Alarm Fan 7", "Alarm Fan 8", 
-        "Alarm Fan 9", "Alarm Dirty Filter", "Alarm Leak Detect", 
-        "Alarm Condensate Pump", "Alarm Fire", "Alarm Smoke"
-    };
-
-    const std::vector<std::string> alarmCommands = {
-        "Alarm Fan 1 ON", "Alarm Fan 2 ON", "Alarm Fan 3 ON", "Alarm Fan 4 ON", 
-        "Alarm Fan 5 ON", "Alarm Fan 6 ON", "Alarm Fan 7 ON", "Alarm Fan 8 ON", 
-        "Alarm Fan 9 ON", "Alarm Dirty Filter ON", "Alarm Leak Detect ON", 
-        "Alarm Condensate Pump ON", "Alarm Fire ON", "Alarm Smoke ON"
-    };
-
-    const std::vector<std::string> alarmAnalogs = {
-        "Alarm High Return Air Temp", "Alarm Low Return Air Temp", "Alarm High Return Humidity", "Alarm Low Return Humidity",
-        "Alarm High Supply Temp", "Alarm Low Supply Temp"
-    };
-
-
-    // NOTE: Per UMAS hardwire signals, alarm opened in case of normal operation, closed in case of alarm condition
-    // 0: no alarm, 1: alarm
-    int numAlarms = 0;
-    for (int i =0; i< alarmCommands.size() && i < alarmDescriptions.size(); ++i) {
-        Modbus_Point<ModbusIP>* commandPoint = equipment->getModbus_Point(alarmCommands[i]);
-        Modbus_Point<ModbusIP>* alarmPoint = equipment->getModbus_Point(alarmDescriptions[i]);
-        if (commandPoint) {
-            alarmPoint->setValue(commandPoint->getValue());
-            if (alarmPoint->getValue() == 1) numAlarms++;
-        }
-    }
-    // If any of the analog alarms = 1, increment counter for number of active alarms
-    for (int j = 0; j<alarmAnalogs.size(); ++j){
-        Modbus_Point<ModbusIP>* alarmAnalogPoint = equipment->getModbus_Point(alarmAnalogs[j]);
-        if (alarmAnalogPoint) {
-            if (alarmAnalogPoint->getValue() == 1) numAlarms++;
-        }
-    }
-    // If any alarms are active, set the Common Alarm = 1, else Common Alarm = 0.
-
-    if (numAlarms >= 1) equipment->setModbus_Point("Common Alarm", 1);
-    else equipment->setModbus_Point("Common Alarm", 0);
-}
\ No newline at end of file
diff --git a/src/BMS/CRAH/CRAH_UMAS_TCP/StateUtils.h b/src/BMS/CRAH/CRAH_UMAS_TCP/StateUtils.h
deleted file mode 100644
index 7c49f8f..0000000
--- a/src/BMS/CRAH/CRAH_UMAS_TCP/StateUtils.h
+++ /dev/null
@@ -1,47 +0,0 @@
-/**
- * @file StateUtils.h
- * @brief StateUtils class
- * @author Robert J Davis
- * @date 2025-10-06
- *
- * Defines the StateUtils class, which contains utility functions used in multiple States.
- */
-
-#pragma once
-
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-template <typename T>
-class State;
-
-/**
- * @brief Updates the Control Mode based on BMS signals and writes it back to Modbus.
- * @param equipment Pointer to the Equipment instance.
- * @return The selected control mode (int).
- */
-void updateControlMode(Equipment<ModbusIP>* equipment);
-void updateAnalogs(Equipment<ModbusIP>* equipment);
-void updateReturnAirTempAlarms(Equipment<ModbusIP>* equipment);
-void updateSupplyAirTempAlarms(Equipment<ModbusIP>* equipment);
-void updateReturnHumidityAlarms(Equipment<ModbusIP>* equipment);
-
-/**
- * @brief Checks common alarms (non-fail alarms) and updates the Common Alarm Modbus point.
- * @param equipment Pointer to the Equipment instance.
- * @return true if any common alarm is active, false otherwise.
- */
-void updateAlarms(Equipment<ModbusIP>* equipment);
\ No newline at end of file
diff --git a/src/BMS/CRAH/CRAH_UMAS_TCP/State_Fail.cpp b/src/BMS/CRAH/CRAH_UMAS_TCP/State_Fail.cpp
deleted file mode 100644
index 5e9c124..0000000
--- a/src/BMS/CRAH/CRAH_UMAS_TCP/State_Fail.cpp
+++ /dev/null
@@ -1,139 +0,0 @@
-/**
- * @file State_Fail.cpp
- * @brief Implementation of the FailState class.
- * @author Robert J Davis
- * @date 2025-10-06
- *
- * This file contains the implementation for the FailState, which defines
- * the behavior of the equipment when it has entered a fault condition.
- * This can only be initiated when the Leak Detection Alarm is active according
- * to the UMAS SOO. If leak detection alarm --> close the cooling valve, turn off fans.
- * The Control Mode and Alarms can still be updated while in a Failed State.
- * Also resets the BMS Command to OFF.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_PID.h"
-#include "Strategies/Strategy_Saw.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "StateUtils.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new FailState object with a list of active alarms.
- *
- * This constructor creates strategies to ramp the corresponding Modbus points down to 0. 
- * 
- */
-template<>
-FailState<ModbusIP>::FailState(const std::vector<std::string>& activeAlarms) {
-    // The only failure mode is if the Leak Detect Alarm is activated, according to UMAS SOO.
-    // If leak detection alarm --> close cooling valve, turn off fans
-    // Fan speed --> 0, Run Status --> 0, Amps --> 0
-    
-    addStrategy("CW Valve Position", new RampStrategy(0.0f, 5.0f, 1000));   
-    addStrategy("Supply Air Temp", new SingleValueStrategy(74.0f, 1.0f, 1000));
-    addStrategy("Return Air Temp", new SingleValueStrategy(86.0f, 1.0f, 1000));
-    addStrategy("Return Humidity", new SingleValueStrategy(30.0f, 1.0f, 3000));
-    addStrategy("Speed Fan 1", new RampStrategy(0.0f, 300.0f, 1000)); 
-    addStrategy("Speed Fan 2", new RampStrategy(0.0f, 300.0f, 1000)); 
-    addStrategy("Speed Fan 3", new RampStrategy(0.0f, 300.0f, 1000)); 
-    addStrategy("Speed Fan 4", new RampStrategy(0.0f, 300.0f, 1000)); 
-    addStrategy("Speed Fan 5", new RampStrategy(0.0f, 300.0f, 1000)); 
-    addStrategy("Speed Fan 6", new RampStrategy(0.0f, 300.0f, 1000)); 
-    addStrategy("Speed Fan 7", new RampStrategy(0.0f, 300.0f, 1000)); 
-    addStrategy("Speed Fan 8", new RampStrategy(0.0f, 300.0f, 1000)); 
-    addStrategy("Speed Fan 9", new RampStrategy(0.0f, 300.0f, 1000)); 
-    addStrategy("Fan Speed Feedback", new RampStrategy(0.0f, 10.0f, 1000)); 
-    addStrategy("Amps Fan 1", new RampStrategy(0.0f, 4.5f, 1000));   
-    addStrategy("Amps Fan 2", new RampStrategy(0.0f, 4.5f, 1000));   
-    addStrategy("Amps Fan 3", new RampStrategy(0.0f, 4.5f, 1000));   
-    addStrategy("Amps Fan 4", new RampStrategy(0.0f, 4.5f, 1000));  
-    addStrategy("Amps Fan 5", new RampStrategy(0.0f, 4.5f, 1000));   
-    addStrategy("Amps Fan 6", new RampStrategy(0.0f, 4.5f, 1000));  
-    addStrategy("Amps Fan 7", new RampStrategy(0.0f, 4.5f, 1000));   
-    addStrategy("Amps Fan 8", new RampStrategy(0.0f, 4.5f, 1000));  
-    addStrategy("Amps Fan 9", new RampStrategy(0.0f, 4.5f, 1000));   
-    addStrategy("CRAH Heartbeat", new SawStrategy(0.0f, 60.0f, 1.0f, 1000));
-}
-
-/**
- * @brief Executes the fail state's logic for one update cycle.
- *
- * This method checks the status of the Leak Detect Alarm Modbus point, if alarm clears --> Standby State
- * While the CRAH is in a failed state, the Control Mode and Alarms are still updated,
- * but the BMS Command cannot be turned on.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* FailState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    Serial.println("Fail update function");
-
-    // Still want Control Mode and Alarms to be updated while in Fail State
-    // Ensure BMS Command is set to Off: want operator to re-start from BMS once Leak Detect Alarm is cleared.
-    updateControlMode(equipment);
-    updateAnalogs(equipment);
-    updateReturnAirTempAlarms(equipment);
-    updateSupplyAirTempAlarms(equipment);
-    updateReturnHumidityAlarms(equipment);
-    updateAlarms(equipment);
-    setPointValue(equipment, "ON/OFF Command By BMS", 0);
-
-    // The only way to exit the Fail State is for Leak Detect Alarm to turn off, then enter Standby State.
-    bool leakDetected = getPointValue(equipment, "Alarm Leak Detect");
-    if (!leakDetected){
-        return new StandbyState<ModbusIP>();
-    }
-
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the fail state.
- * When entering failed state, turn all fans off (fan status --> 1) and set BMS Command --> 0
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Fail State...");
-
-    const std::vector<std::string> motorStatusDescriptions = {
-        "Run Status Fan 1", "Run Status Fan 2", "Run Status Fan 3",
-        "Run Status Fan 4", "Run Status Fan 5", "Run Status Fan 6",
-        "Run Status Fan 7", "Run Status Fan 8", "Run Status Fan 9"
-    };
-
-    // Per UMAS submittal Hardwired Run Status signals- 0: fans running, 1: fans stopped
-    // Loop through and set all motor statuses to 1
-    for (const auto& desc : motorStatusDescriptions) {
-        Modbus_Point<ModbusIP>* point = equipment->getModbus_Point(desc);
-        if (point) {
-            point->setValue(0);
-        }
-    };
-
-    // Set BMS On/Off Command to 0
-    setPointValue(equipment, "ON/OFF Command By BMS", 0);
-}
-
-/**
- * @brief Logic to execute once when exiting the fail state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Fail State...");
-}
\ No newline at end of file
diff --git a/src/BMS/CRAH/CRAH_UMAS_TCP/State_Running.cpp b/src/BMS/CRAH/CRAH_UMAS_TCP/State_Running.cpp
deleted file mode 100644
index 9290275..0000000
--- a/src/BMS/CRAH/CRAH_UMAS_TCP/State_Running.cpp
+++ /dev/null
@@ -1,215 +0,0 @@
-/**
- * @file State_Running.cpp
- * @brief Implementation of the RunningState class.
- * @author Robert J Davis
- * @date 2025-10-03
- *
- * This file contains the implementation for the RunningState, which defines
- * the behavior of the equipment when it is actively running.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "Strategies/Strategy_Totalizer.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include "StateUtils.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new RunningState object.
- *
- * This constructor initializes behavior strategies active during the running
- * state, such as a PID controller for the 'CW Valve Position', totalizers
- * for the run-hours of each EC fan, fan speed, amps for each fan. Also sets
- * the fan min and max speeds to a default value. The supply air temperature
- * is set to a saw strategy between 60 and 100, which will also activate the 
- * SA high (78) and low (72) temperature alarms. 
- */
-template<>
-RunningState<ModbusIP>::RunningState() {
-    addStrategy("Fan Min Speed", new SingleValueStrategy(30.0f, 0.0f, 1000));
-    addStrategy("Fan Max Speed", new SingleValueStrategy(100.0f, 0.0f, 1000));
-    addStrategy("Speed Fan 1", new RampStrategy(0.0f, 100.0f, 1000));         
-    addStrategy("Speed Fan 2", new RampStrategy(0.0f, 100.0f, 1000));          
-    addStrategy("Speed Fan 3", new RampStrategy(0.0f, 100.0f, 1000));         
-    addStrategy("Speed Fan 4", new RampStrategy(0.0f, 100.0f, 1000));  
-    addStrategy("Speed Fan 5", new RampStrategy(0.0f, 100.0f, 1000));         
-    addStrategy("Speed Fan 6", new RampStrategy(0.0f, 100.0f, 1000));  
-    addStrategy("Speed Fan 7", new RampStrategy(0.0f, 100.0f, 1000));         
-    addStrategy("Speed Fan 8", new RampStrategy(0.0f, 100.0f, 1000));  
-    addStrategy("Speed Fan 9", new RampStrategy(0.0f, 100.0f, 1000));         
-    addStrategy("Amps Fan 1", new RampStrategy(15.0f, 2.5f, 1000));          
-    addStrategy("Amps Fan 2", new RampStrategy(15.0f, 2.5f, 1000));  
-    addStrategy("Amps Fan 3", new RampStrategy(15.0f, 2.5f, 1000));          
-    addStrategy("Amps Fan 4", new RampStrategy(15.0f, 2.5f, 1000));
-    addStrategy("Amps Fan 5", new RampStrategy(15.0f, 2.5f, 1000));          
-    addStrategy("Amps Fan 6", new RampStrategy(15.0f, 2.5f, 1000));
-    addStrategy("Amps Fan 7", new RampStrategy(15.0f, 2.5f, 1000));          
-    addStrategy("Amps Fan 8", new RampStrategy(15.0f, 2.5f, 1000));
-    addStrategy("Amps Fan 9", new RampStrategy(15.0f, 2.5f, 1000));                
-    addStrategy("Operating Hours Fan 1", new TotalizerStrategy(1000));            // Does not retain these values when switching States.
-    addStrategy("Operating Hours Fan 2", new TotalizerStrategy(1000));
-    addStrategy("Operating Hours Fan 3", new TotalizerStrategy(1000));
-    addStrategy("Operating Hours Fan 4", new TotalizerStrategy(1000));
-    addStrategy("Operating Hours Fan 5", new TotalizerStrategy(1000));
-    addStrategy("Operating Hours Fan 6", new TotalizerStrategy(1000));
-    addStrategy("Operating Hours Fan 7", new TotalizerStrategy(1000));
-    addStrategy("Operating Hours Fan 8", new TotalizerStrategy(1000));
-    addStrategy("Operating Hours Fan 9", new TotalizerStrategy(1000));
-    addStrategy("Supply Air Temp", new SawStrategy(73.0f, 77.0f, 0.2f, 1000));         // Won't initialize at lower bound; always initializes at 0 b/c FLOAT; initialize manually via Modscan
-    addStrategy("Return Humidity", new SawStrategy(25.0f, 35.0f, 0.2f, 1000));
-    addStrategy("Return Air Temp", new SawStrategy(80.0f, 90.0f, 0.2f, 1000)); 
-    addStrategy("Filter Differential Pressure", new SawStrategy(0.1f, 5.1f, 0.2f, 1000)); 
-    addStrategy("CW Valve Position", new PIDStrategy("Supply Air Temp Setpoint", 1000, "Supply Air Temp"));   // SAT must be greater than SAT Setpoint for this PID to work.
-    addStrategy("CRAH Heartbeat", new SawStrategy(0.0f, 60.0f, 1.0f, 1000));
-    addStrategy("Fan Speed Feedback", new RampStrategy(0.0f, 2.0f, 200)); 
-}
-
-/**
- * @brief Executes the running state's logic for one update cycle.
- *
- * This method first updates the Control Mode (based on BMS Control Source and BMS Enable Source),
- * and then updates the Alarms, setting the Common Alarm to 1 if any alarm is active. Alarms may be
- * set using Coils 2-9 in Modscan (for Arduino testing only). 
- * 
- * If the Leak Detect alarm is active, the unit will transition to FailState.
- * If the BMS Command is set to OFF, the unit will transition to StandbyState.
- * 
- * If the unit is still in a RunningState, the fan speed will dynamically be updated
- * to ramp to the speed setpoint sent from the PLC/Modscan.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* RunningState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    Serial.println("Running update function");
-    int On_Off_Command = getPointValue(equipment, "ON/OFF Command By BMS");    // Modscan COIL 1
-    int BMS_Control_Source = getPointValue(equipment, "BMS Control Source");   // Modscan HR 1
-    int BMS_Enable_Source = getPointValue(equipment, "BMS Enable Source");     // Modscan HR 2
-
-    updateControlMode(equipment);
-    updateAnalogs(equipment);
-    updateReturnAirTempAlarms(equipment);
-    updateSupplyAirTempAlarms(equipment);
-    updateReturnHumidityAlarms(equipment);
-    updateAlarms(equipment);
-
-    // Check to see if Leak Detect alarm is active (only alarm which will make unit FAIL and turn off) --> Send to FailState
-    bool leakDetect = getPointValue(equipment, "Alarm Leak Detect");
-    if (leakDetect){
-        return new FailState<ModbusIP>({"Alarm Leak Detect"});
-    }
-
-    // Check to see if BMS Command set to OFF --> Place unit in Standby
-    // Removed logic of placing unit on standby if BMS_Enable_Source != 2 for ease in testing Mode Feedback.
-    if (On_Off_Command == 0){
-        return new StandbyState<ModbusIP>();
-    }
-
-    // This will update the Fan Speed Setpoint dynamically while in run mode. Fan Speed Setpoint changed through Modscan.
-    // This functioanlity matches the UMAS SOO specifically for how it calculates Speed Setpoint.
-    float Fan_Min_Speed = getPointValue(equipment, "Fan Min Speed");
-    float Fan_Max_Speed = getPointValue(equipment, "Fan Max Speed");
-    float Fan_Nominal_Speed = 1900.0f;
-
-    float BMS_Speed_Setpoint = getPointValue(equipment, "Fan Speed Setpoint");
-    float BMS_Speed_Setpoint_Pct = BMS_Speed_Setpoint / 100.0f;
-    float Fan_Speed_Setpoint = BMS_Speed_Setpoint_Pct * (Fan_Max_Speed - Fan_Min_Speed) + Fan_Min_Speed;
-    float Fan_Speed_Setpoint_RPM = Fan_Speed_Setpoint / 100.0f * Fan_Nominal_Speed;
-    for (int i = 0; i < 10; i++){
-        std::string pointName = "Speed Fan " + std::to_string(i);
-        Strategy_Behavior* strat = getStrategy(pointName);
-        if (strat) {
-            RampStrategy* ramp = static_cast<RampStrategy*>(strat);
-            if (ramp){
-                if (BMS_Speed_Setpoint > 100){
-                    Fan_Speed_Setpoint = Fan_Max_Speed;
-                    Fan_Speed_Setpoint_RPM = Fan_Max_Speed / 100.0f * Fan_Nominal_Speed; 
-                }
-                else if (BMS_Speed_Setpoint < 0){
-                    Fan_Speed_Setpoint = Fan_Min_Speed; 
-                    Fan_Speed_Setpoint_RPM = Fan_Min_Speed / 100.0f * Fan_Nominal_Speed;
-                }
-                ramp->setTarget(Fan_Speed_Setpoint_RPM);
-            }
-        }
-    }
-
-    // Fan Speed Feedback dynamically ramp to Fan Speed Setpoint sent to Arduino
-    Strategy_Behavior* speedFeedback = getStrategy("Fan Speed Feedback");
-    if (speedFeedback){
-        static_cast<RampStrategy*>(speedFeedback)->setTarget(Fan_Speed_Setpoint);
-    }
-
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the running state.
- * Sets the "Run Status" for all EC fans to 1 to indicate they are active.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Running State...");
-    // You could also update a Modbus register to show the "standby" state
-
-    const std::vector<std::string> motorStatusDescriptions = {
-        "Run Status Fan 1", "Run Status Fan 2", "Run Status Fan 3",
-        "Run Status Fan 4", "Run Status Fan 5", "Run Status Fan 6",
-        "Run Status Fan 7", "Run Status Fan 8", "Run Status Fan 9"
-    };
-
-    // Per UMAS submittal Hardwired Run Status signals- 0: fans running, 1: fans stopped
-    // Loop through and set all motor statuses to 0
-    for (const auto& desc : motorStatusDescriptions) {
-        Modbus_Point<ModbusIP>* point = equipment->getModbus_Point(desc);
-        if (point) {
-            point->setValue(1);
-        }
-    }
-}
-
-/**
- * @brief Logic to execute once when exiting the running state.
- * Sets the "Run Status" for all EC fans to 1 (stopped) before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Running State...");
-    const std::vector<std::string> motorStatusDescriptions = {
-        "Run Status Fan 1", "Run Status Fan 2", "Run Status Fan 3",
-        "Run Status Fan 4", "Run Status Fan 5", "Run Status Fan 6",
-        "Run Status Fan 7", "Run Status Fan 8", "Run Status Fan 9"
-    };
-
-    // Per UMAS submittal Hardwired Run Status signals- 0: fans running, 1: fans stopped
-    // Loop through and set all motor statuses to 1
-    for (const auto& desc : motorStatusDescriptions) {
-        Modbus_Point<ModbusIP>* point = equipment->getModbus_Point(desc);
-        if (point) {
-            point->setValue(0);
-        }
-    }
-}
\ No newline at end of file
diff --git a/src/BMS/CRAH/CRAH_UMAS_TCP/State_Standby.cpp b/src/BMS/CRAH/CRAH_UMAS_TCP/State_Standby.cpp
deleted file mode 100644
index c863fcd..0000000
--- a/src/BMS/CRAH/CRAH_UMAS_TCP/State_Standby.cpp
+++ /dev/null
@@ -1,148 +0,0 @@
-/**
- * @file State_Standby.cpp
- * @brief Implementation of the StandbyState class.
- * @author Robert J. Davis
- * @date 2025-10-01
- *
- * This file contains the implementation for the StandbyState, which defines
- * the behavior of the equipment when it is in an idle or standby mode.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include "StateUtils.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-/**
- * @brief Constructs a new StandbyState object.
- *
- * In this state, the equipment is idle. This constructor initializes strategies
- * to bring the system to a safe, idle condition. It ramps to a stable value for
- * the SAT and RAT readings and creates ramp strategies to bring the CW valve and all
- * EC fan speeds and amps down to zero.
- */
-template<>
-StandbyState<ModbusIP>::StandbyState() {
-    // You can add initialization code here if needed.
-    // These strategies are applied at the end of the update function.
-    addStrategy("CW Valve Position", new RampStrategy(0.0f, 5.0f, 1000));   
-    addStrategy("Supply Air Temp", new SingleValueStrategy(76.0f, 1.0f, 2000));
-    addStrategy("Return Air Temp", new SingleValueStrategy(86.0f, 1.0f, 3000));
-    addStrategy("Return Humidity", new SingleValueStrategy(25.0f, 1.0f, 4000));
-    addStrategy("Speed Fan 1", new RampStrategy(0.0f, 300.0f, 1000)); 
-    addStrategy("Speed Fan 2", new RampStrategy(0.0f, 300.0f, 1000)); 
-    addStrategy("Speed Fan 3", new RampStrategy(0.0f, 300.0f, 1000)); 
-    addStrategy("Speed Fan 4", new RampStrategy(0.0f, 300.0f, 1000)); 
-    addStrategy("Speed Fan 5", new RampStrategy(0.0f, 300.0f, 1000)); 
-    addStrategy("Speed Fan 6", new RampStrategy(0.0f, 300.0f, 1000)); 
-    addStrategy("Speed Fan 7", new RampStrategy(0.0f, 300.0f, 1000)); 
-    addStrategy("Speed Fan 8", new RampStrategy(0.0f, 300.0f, 1000)); 
-    addStrategy("Speed Fan 9", new RampStrategy(0.0f, 300.0f, 1000)); 
-    addStrategy("Fan Speed Feedback", new RampStrategy(0.0f, 10.0f, 1000)); 
-    addStrategy("Amps Fan 1", new RampStrategy(0.0f, 4.5f, 1000));   
-    addStrategy("Amps Fan 2", new RampStrategy(0.0f, 4.5f, 1000));   
-    addStrategy("Amps Fan 3", new RampStrategy(0.0f, 4.5f, 1000));   
-    addStrategy("Amps Fan 4", new RampStrategy(0.0f, 4.5f, 1000)); 
-    addStrategy("Amps Fan 5", new RampStrategy(0.0f, 4.5f, 1000));   
-    addStrategy("Amps Fan 6", new RampStrategy(0.0f, 4.5f, 1000)); 
-    addStrategy("Amps Fan 7", new RampStrategy(0.0f, 4.5f, 1000));   
-    addStrategy("Amps Fan 8", new RampStrategy(0.0f, 4.5f, 1000)); 
-    addStrategy("Amps Fan 9", new RampStrategy(0.0f, 4.5f, 1000));  
-    addStrategy("CRAH Heartbeat", new SawStrategy(0.0f, 60.0f, 1.0f, 1000));
-}
-
-/**
- * @brief Executes the standby state's logic for one update cycle.
- *
- * While in Standby, the Control Mode will be updated (based on BMS Control Source and BMS Enable Source),
- * the Alarms will also be updated, with the Common Alarm being set to 1 if any alarm is active.
- * 
- * If the Leak Detect alarm is active, the unit will transition to a FailState.
- * If in the correct Control Mode, and BMS Command ON is sent from the PLC/Modscan, 
- * the unit will transition to a RunningState.
- *
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* StandbyState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Standby update function");
-    int On_Off_Command = getPointValue(equipment, "ON/OFF Command By BMS");    // Modscan COIL 1
-    int BMS_Control_Source = getPointValue(equipment, "BMS Control Source");   // Modscan HR 1
-    int BMS_Enable_Source = getPointValue(equipment, "BMS Enable Source");     // Modscan HR 2
-
-    updateControlMode(equipment);
-    updateAnalogs(equipment);
-    updateReturnAirTempAlarms(equipment);
-    updateSupplyAirTempAlarms(equipment);
-    updateReturnHumidityAlarms(equipment);
-    updateAlarms(equipment);
-
-    // Check to see if Leak Detect alarm is active (only alarm which will make unit FAIL and turn off) --> Send to FailState
-    bool leakDetect = getPointValue(equipment, "Alarm Leak Detect");
-    if (leakDetect){
-        return new FailState<ModbusIP>({"Alarm Leak Detect"});
-    }
-
-    if (On_Off_Command == 1 && BMS_Control_Source == 0 && BMS_Enable_Source == 2){
-        return new RunningState<ModbusIP>();
-    }
-
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the standby state.
- * This method performs cleanup by setting all EC fan run status points to 1 (stopped).
- * The BMS Command is also set to OFF.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-
-    // A list of all motor run status descriptions
-    const std::vector<std::string> motorStatusDescriptions = {
-        "Run Status Fan 1", "Run Status Fan 2", "Run Status Fan 3",
-        "Run Status Fan 4", "Run Status Fan 5", "Run Status Fan 6",
-        "Run Status Fan 7", "Run Status Fan 8", "Run Status Fan 9"
-    };
-
-    // Per UMAS submittal Hardwired Run Status signals- 0: fans running, 1: fans stopped
-    // Loop through and set all motor statuses to 1
-    for (const auto& desc : motorStatusDescriptions) {
-        Modbus_Point<ModbusIP>* point = equipment->getModbus_Point(desc);
-        if (point) {
-            point->setValue(0);
-        }
-    };
-
-    setPointValue(equipment, "ON/OFF Command By BMS", 0);
-}
-
-/**
- * @brief Logic to execute once when exiting the standby state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Standby State...");
-}
\ No newline at end of file
diff --git a/src/BMS/CRAH/CRAH_UMAS_TCP/config.h b/src/BMS/CRAH/CRAH_UMAS_TCP/config.h
deleted file mode 100644
index 0fac917..0000000
--- a/src/BMS/CRAH/CRAH_UMAS_TCP/config.h
+++ /dev/null
@@ -1,188 +0,0 @@
-/**
- * @file config.h
- * @brief Main configuration file for the UMAS CRAH Unit (TCP) emulator - used at PHX3 DC1
- * @author Robert J Davis
- * @date 2025-10-01
- *
- * This file contains two important configurations: WiFi network parameters
- * and the Modbus register map for the device.
- */
-
-#ifndef CONFIG_H
-#define CONFIG_H
-
-#include "core.h"
-#include "Equipment/Equipment.h"
-
-#if defined(USE_MODBUS_IP)
-/**
-   * @defgroup ModbusTCPConfig Modbus IP Configuration
-   * @brief Parameters for Modbus TCP communication.
-   * @{
-   */
-  #include <ModbusIP_ESP8266.h>
-  const char *ssid = "ArduinoWifiB";          /**< @brief The SSID of the WiFi network. */
-  const char *password = "123abc456";          /**< @brief The password for the WiFi network. */
-  IPAddress local_IP(172, 17, 32, 232);       /**< @brief The static IP address for the device. */
-  IPAddress gateway(172, 17, 32, 1);          /**< @brief The gateway IP address. */
-  IPAddress subnet(255, 255, 255, 0);         /**< @brief The subnet mask. */
-  
-  ModbusIP mb;
-#else
-  /**
-   * @defgroup ModbusRTUConfig Modbus RTU Configuration
-   * @brief Parameters for serial Modbus RTU communication.
-   * @{
-   */
-  #include <ModbusRTU.h>
-  const int BAUDRATE = 19200;   /**< @brief The serial communication speed in bits per second. */
-  const int RX_PIN = 17;        /**< @brief The GPIO pin used for receiving data (RX). */
-  const int TX_PIN = 16;        /**< @brief The GPIO pin used for transmitting data (TX). */
-  const int RST_PIN = 4;        /**< @brief The GPIO pin connected to the RS485 driver's DE/RE pins for direction control. */
-  const int MODBUS_ID = 1;      /**< @brief The unique slave ID for this device on the Modbus bus. */
-  /** @} */
-
-  /** @brief Global instance of the Modbus RTU server. */
-  ModbusRTU mb;
-#endif
-
-/**
- * @defgroup ModbusMapConfig Modbus Map Configuration
- * @brief Defines the Modbus register map and related parameters for the emulator.
- * @{
- */
-/**
- * @brief The Modbus map for the Equipment device.
- * This array defines all the Modbus points available on the emulated device.
- * The `description` field is crucial as it's used to look up points within the application logic.
- */
-
- // "One-Based" Addressing for IR, HR registers
-
-modbusMap mb_map[] =
-{   
-  {COIL,      0,    0,   "ON/OFF Command By BMS"},       // Receive signal from PLC
-  {COIL,      1,    0,   "Alarm Dirty Filter ON"},       // Just for Arduino testing. Sets Alarm Dirty Filter to 1.
-  {COIL,      2,    0,   "Alarm Leak Detect ON"},        // Just for Arduino testing. Sets Alarm Fan 1 to 1.
-
-  {COIL,      3,    0,   "Alarm Fan 1 ON"},              // Just for Arduino testing. Sets Alarm Fan 1 to 1.
-  {COIL,      4,    0,   "Alarm Fan 2 ON"},              // Just for Arduino testing. Sets Alarm Fan 2 to 1.
-  {COIL,      5,    0,   "Alarm Fan 3 ON"},              // Just for Arduino testing. Sets Alarm Fan 3 to 1.
-  {COIL,      6,   0,   "Alarm Fan 4 ON"},              // Just for Arduino testing. Sets Alarm Fan 4 to 1.
-  {COIL,      7,   0,   "Alarm Fan 5 ON"},              // Just for Arduino testing. Sets Alarm Fan 5 to 1.
-  {COIL,      8,   0,   "Alarm Fan 6 ON"},              // Just for Arduino testing. Sets Alarm Fan 6 to 1.
-  {COIL,      9,   0,   "Alarm Fan 7 ON"},              // Just for Arduino testing. Sets Alarm Fan 7 to 1.
-  {COIL,      10,   0,   "Alarm Fan 8 ON"},              // Just for Arduino testing. Sets Alarm Fan 8 to 1.
-  {COIL,      11,   0,   "Alarm Fan 9 ON"},              // Just for Arduino testing. Sets Alarm Fan 9 to 1.
-  {COIL,      12,   0,   "Alarm Condensate Pump ON"},    // Just for Arduino testing. Sets Alarm Condensate Pump to 1.
-  {COIL,      13,   0,   "Alarm Fire ON"},               // Just for Arduino testing. Sets Alarm Fire to 1.
-  {COIL,      14,   0,   "Alarm Smoke ON"},              // Just for Arduino testing. Sets Alarm Smoke to 1.
-
-  {COIL,      15,    0,   "RA Temp Low Alarm ON"},        // Just for Arduino testing. Sets RA Temp to 68F (low alarm)
-  {COIL,      16,    0,   "RA Temp NORMAL"},        // Just for Arduino testing. Sets RA Temp to 68F (low alarm)
-  {COIL,      17,    0,   "RA Temp High Alarm ON"},       // Just for Arduino testing. Sets RA Temp to 104F (high alarm)
-
-  {COIL,      18,    0,   "SA Temp Low Alarm ON"},        // Just for Arduino testing. Sets RA Temp to 68F (low alarm)
-  {COIL,      19,    0,   "SA Temp NORMAL"},        // Just for Arduino testing. Sets RA Temp to 68F (low alarm)
-  {COIL,      20,    0,   "SA Temp High Alarm ON"},       // Just for Arduino testing. Sets RA Temp to 104F (high alarm)
-
-  {COIL,      21,    0,   "RA Humidity Low Alarm ON"},    // Just for Arduino testing. Sets RA Humidity to 15% (low alarm)
-  {COIL,      22,    0,   "RA Humidity NORMAL"},        // Just for Arduino testing. Sets RA Temp to 68F (low alarm)
-  {COIL,      23,    0,   "RA Humidity High Alarm ON"},   // Just for Arduino testing. Sets RA Humidity to 65% (high alarm)
-
-  {DI,        4,    0,  "Alarm Leak Detect"}, 
-  {DI,        5,    0,  "Alarm Dirty Filter"}, 
-  {DI,        6,    0,  "Alarm High Return Air Temp"},      // suggested default 100, operator inputs High RA Temp SP for alarm limit
-  {DI,        7,    0,  "Alarm Low Return Air Temp"},      // suggested default 72, operator inputs Low RA Temp SP for alarm limit
-  {DI,        8,    0,  "Alarm High Supply Temp"},      // suggested default 78, operator inputs High SA Temp SP for alarm limit
-  {DI,        9,    0,  "Alarm Low Supply Temp"},      // suggested default 72, operator inputs Low SA Temp SP for alarm limit
-  {DI,        10,    0,  "Alarm High Return Humidity"},      // suggested default 60, operator inputs High Return Humidity SP for alarm limit
-  {DI,        11,    0,  "Alarm Low Return Humidity"},      // suggested default 20, operator inputs Low Return Humidity SP for alarm limit
-  {DI,        12,   0,  "Common Alarm"},                // Send to PLC
-  {DI,        14,   0,  "Alarm Condensate Pump"},
-  {DI,        15,   0,  "Alarm Smoke"},
-  {DI,        16,   0,  "Alarm Fire"},
-       
-  {IR_FLOAT,      1,     0,  "Supply Air Temp"}, 
-  {IR_FLOAT,      3,     0,  "Return Humidity"},       // Ignition visual only
-  {IR_FLOAT,      5,     0,  "Return Air Temp"},          // Send to PLC
-  {IR_FLOAT,      7,     0,  "Filter Differential Pressure"},  // sawStrategy between 0 and 5
-  {IR_FLOAT,      9,     0,  "CW Valve Position"}, 
-  {IR,            26,    0,  "Alarm Fan 1"},        
-  {IR,            30,    0,  "Alarm Fan 2"},        
-  {IR,            34,    0,  "Alarm Fan 3"},        
-  {IR,            38,    0,  "Alarm Fan 4"},    
-  {IR,            42,    0,  "Alarm Fan 5"},        
-  {IR,            46,    0,  "Alarm Fan 6"},    
-  {IR,            50,    0,  "Alarm Fan 7"},        
-  {IR,            54,    0,  "Alarm Fan 8"},    
-  {IR,            58,    0,  "Alarm Fan 9"},   
-  {IR,            27,    0,  "Run Status Fan 1"},        // Send to PLC
-  {IR,            31,    0,  "Run Status Fan 2"},        // Send to PLC
-  {IR,            35,    0,  "Run Status Fan 3"},        // Send to PLC
-  {IR,            39,    0,  "Run Status Fan 4"},        // Send to PLC
-  {IR,            43,    0,  "Run Status Fan 5"},        // Send to PLC
-  {IR,            47,    0,  "Run Status Fan 6"},        // Send to PLC
-  {IR,            51,    0,  "Run Status Fan 7"},        // Send to PLC
-  {IR,            55,    0,  "Run Status Fan 8"},        // Send to PLC
-  {IR,            59,    0,  "Run Status Fan 9"},        // Send to PLC
-  {IR,            25,    0,  "Speed Fan 1"},                
-  {IR,            29,    0,  "Speed Fan 2"},          
-  {IR,            33,    0,  "Speed Fan 3"},                
-  {IR,            37,    0,  "Speed Fan 4"},     
-  {IR,            41,    0,  "Speed Fan 5"},                
-  {IR,            45,    0,  "Speed Fan 6"},     
-  {IR,            49,    0,  "Speed Fan 7"},                
-  {IR,            53,    0,  "Speed Fan 8"},     
-  {IR,            57,    0,  "Speed Fan 9"},                
-  {IR,            28,    0,  "Operating Hours Fan 1"},                
-  {IR,            32,    0,  "Operating Hours Fan 2"},     
-  {IR,            36,    0,  "Operating Hours Fan 3"},                
-  {IR,            40,    0,  "Operating Hours Fan 4"},   
-  {IR,            44,    0,  "Operating Hours Fan 5"},                
-  {IR,            48,    0,  "Operating Hours Fan 6"},   
-  {IR,            52,    0,  "Operating Hours Fan 7"},                
-  {IR,            56,    0,  "Operating Hours Fan 8"},   
-  {IR,            60,    0,  "Operating Hours Fan 9"},         
-  {IR,            61,    0,  "Control Mode Selected"},         // 0: BMS+Speed, 1: BMS+Room Temp, 2: Return Temp
-  {IR_FLOAT,      63,    0,  "Amps Fan 1"},                
-  {IR_FLOAT,      65,    0,  "Amps Fan 2"},                
-  {IR_FLOAT,      67,    0,  "Amps Fan 3"},                
-  {IR_FLOAT,      69,    0,  "Amps Fan 4"},    
-  {IR_FLOAT,      71,    0,  "Amps Fan 5"},                
-  {IR_FLOAT,      73,    0,  "Amps Fan 6"},    
-  {IR_FLOAT,      75,    0,  "Amps Fan 7"},                
-  {IR_FLOAT,      77,    0,  "Amps Fan 8"},    
-  {IR_FLOAT,      79,    0,  "Amps Fan 9"},                               
-        
-  {HR_FLOAT,       1,    0,  "Return Air Temp Alarm High SP"},  // default: 100, set locally on unit
-  {HR_FLOAT,       3,    0,  "Return Air Temp Alarm Low SP"},    // default: 72, set locally on unit
-  {HR_FLOAT,       5,    0,  "Supply Air Temp Alarm High SP"},   // default: 78, set locally on unit
-  {HR_FLOAT,       7,    0,  "Supply Air Temp Alarm Low SP"},    // default: 72, set locally on unit
-  {HR_FLOAT,       9,    0,  "Return Humidity Alarm High SP"},   // default: 60, set locally on unit
-  {HR_FLOAT,      11,    0,  "Return Humidity Alarm Low SP"},    // default: 20, set locally on unit
-  {HR_FLOAT,      13,    0,  "Fan Speed Setpoint"},          // Receive signal from PLC
-  {HR_FLOAT,      17,    0,  "Supply Air Temp Setpoint"},    // Receive signal from PLC
-  {HR_FLOAT,      19,    0,  "Return Air Temp Setpoint"},    // set locally on unit
-  {HR_FLOAT,      21,    0,  "Fan Min Speed"},               // Send to PLC
-  {HR_FLOAT,      23,    0,  "Fan Max Speed"},               // Send to PLC
-  {HR,            25,    0,  "BMS Control Source"},          // Receive signal from PLC 0:Speed, 1:Room Temp
-  {HR,            26,    2,  "BMS Enable Source"},           // Receive signal from PLC 0:Keypad, 1:DI, 2:BMS
-  {HR_FLOAT,      28,    0,  "Fan Speed Feedback"},          
-  {HR,            95,    0,  "CRAH Heartbeat"},
-  {HR,            96,    0,  "BMS Heartbeat"},               // This will be seconds from PLC - if doesn't change for 15 seconds set BMS Enable Source to Local (0)
-  
-};
-//Size of modbus map used in FOR cycles, automatically calculated.
-
-/**
- * @brief The total number of entries in the `mb_map` array.
- * This is calculated at compile time and used for iterating over the map.
- */
-const int map_size = sizeof(mb_map) / sizeof(mb_map[0]);
-
-/** @brief The main loop update interval in milliseconds. */
-int interval = 250; 
-/** @} */ // End of ModbusMapConfig group
-
-#endif // CONFIG_H
\ No newline at end of file
diff --git a/src/BMS/CRAH/CRAH_UMAS_TCP/main.cpp b/src/BMS/CRAH/CRAH_UMAS_TCP/main.cpp
deleted file mode 100644
index 286a98c..0000000
--- a/src/BMS/CRAH/CRAH_UMAS_TCP/main.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-/**
- * @file main.cpp
- * @brief Main execution program for the CRAH Unit (TCP) Emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * @details This file contains the main execution program for an Arduino-based emulator of a CRAH unit. 
- * The program uses a Wi-Fi connection to communicate via the Modbus IP protocol.
- *
- * The setup() function initializes the following:
- * - Serial communication for debugging.
- * - Wi-Fi connection using credentials from config.h.
- * - A Modbus TCP server.
- * - Modbus points (Coils, Holding Registers, etc.) based on a predefined map in config.h.
- *
- * The loop() function continuously:
- * - Services the Modbus TCP server to handle incoming requests.
- * - Periodically calls the main update loop for the emulated equipment, which
- *   manages state transitions and behavior strategies.
- *
- * @see config.h for Wi-Fi and Modbus configuration.
- * @see Equipment.h for the main equipment logic.
- * @see State.h for different equipment states.
- * @see Strategies/Strategy_Behavior.h for value generation strategies.
- * @see Modbus_Point.h for the base class for all Modbus points.
- */
-//=================================================================================================================================
-//Libraries and declaration of variables.
-#include <WiFi.h>
-#include "config.h"
-#include "ModbusPoints/Modbus_PointFactory.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-//=================================================================================================================================
-/** 
- * @brief Initializes the application.
- * @details This function runs once at startup. It configures the serial communication, 
- * Wi-Fi, and the Modbus server. It also creates and initializes all the Modbus points 
- * based on the `mb_map` array in `config.h`.
- */
-void setup() {
-  Serial.begin(115200);                       //Serial comm start
-  WiFi.config(local_IP, gateway, subnet);     // Wifi service start
-  WiFi.begin(ssid, password);
-  while (WiFi.status() != WL_CONNECTED) {
-    delay(1000);
-    Serial.print(".");
-  }
-  Serial.println("Connected!!");
-  mb.server();                                //Modbus server start
-  Serial.println("Server Created");
-  Serial.println(map_size);
-  for(int i = 0; i < map_size; i++){
-    Modbus_Point<ModbusIP>* point = createModbus_Point(&mb, mb_map[i].category, mb_map[i].address, mb_map[i].value, mb_map[i].description);
-    if (point) {
-      point->addToModbusServer();
-      EquipmentInstance.addModbus_Point(mb_map[i].description, point);
-    }
-  }
-  Serial.println("All modbus Points created");
-  Serial.println("Setup function ended");
-}
-//=================================================================================================================================
-/** 
- * @brief The main application loop.
- * @details This function runs repeatedly after setup() has completed. It performs two main actions:
- * 1. It continuously services the Modbus server by calling `mb.task()` to handle
- *    incoming requests from a Modbus master.
- * 2. At a fixed interval (defined in `config.h`), it calls `EquipmentInstance.update()`
- *    to run the emulator's internal state machine and behavior logic.
- */
-void loop() {
-  mb.task();
-  unsigned long currentMillis = millis();
-  if (currentMillis - previousMillis >= interval) {
-    previousMillis = currentMillis;
-    unsigned long startTime = millis();
-    EquipmentInstance.update();
-    unsigned long endTime = millis();
-    unsigned long elapsedTime = endTime - startTime;
-    Serial.printf("Control Execution time: %d ms\n", elapsedTime);
-  } 
-}
diff --git a/src/BMS/CRAH/PHX3_CRAH_LIEBERT_80_SLAB_TCP/README.md b/src/BMS/CRAH/PHX3_CRAH_LIEBERT_80_SLAB_TCP/README.md
deleted file mode 100644
index db837dc..0000000
--- a/src/BMS/CRAH/PHX3_CRAH_LIEBERT_80_SLAB_TCP/README.md
+++ /dev/null
@@ -1,58 +0,0 @@
-# CRAH Liebert 80 125 SLAB TCP
-
-## Brief Introduction
-This version of the LIEBERT 80 SLAB Electrical Gallery CRAH has different registers from the existing 
-"CRAH_LIEBERT_80_125_SLAB_TCP" code, hence a new instance was created. The logic in this code is also
-unique from the existing LIEBERT_80_125 CRAH unit.
-This implementation assumes that on/off control and supply, return air temp setpoints are sent to CRAH unit
-from Ignition- there is not an associated PLC program.
-
-## List of Equipment
-This configuration has been used for these models:
-* **PHX3 Liebert CW084DC1A1SDM7 SLAB**: 10-27-25 
-
-## Hardware Prerequisites
-
-The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities.
-* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html) 
-
----
-
-## States and Strategies
-On/Off Control by Coil 25
-Supply Air Temp Setpoint used for PID control of Fluid Control Valves 1&2
-Return Air Temp Setpoint used for PID control of Fan Speed
-Unsure of difference between Fluid Control Valves 1 & 2, for this simulation they are assumed to operate the same
-We have reached out to vendor for clarification of these two valves.
-
-### Standby State
-* **Unit Status**: set to 2 (standby)
-* **Free Cool Status**: set to 1 whenever in Standby Mode - Assuming whenever in Standby Mode will operate in Free Cooling mode
-* **Fan Speed**: ramp to 0
-* **Return Humidity**: saw 0 to 80, increments of 5
-* **Return Air Temp**: single value 80 +/- 1
-* **Supply Air Temp**: single value 80 +/- 1
-* **Supply Air Flow**: ramp to 0
-* **Fluid Control Valve Position 1**: ramp to 0
-* **Fluid Control Valve Position 2**: ramp to 0
-
-### Running State
-* **Unit Status, Supply Fan Status, Cooling Status**: set to 1
-* **Return Humidity**: saw 0 to 80, increments of 5 (same as Standby Mode)
-* **Return Air Temp**: saw 62 to 110, increments of 2
-* **Supply Air Temp**: saw 64 to 86, increments of 1
-* **Supply Air Flow**: saw 7 to 10, increments of 1
-* **Fan Speed**: PID control (Return Air Temp Setpoint, Return Air Temp)
-* **Fluid Control Valve Position 1**: PID control (Supply Air Temp Setpoint, Supply Air Temp)
-* **Fluid Control Valve Position 2**: PID control (Supply Air Temp Setpoint, Supply Air Temp)
-
-### Fail State
-* **Unit Status**: set to 0 (off)
-* **Free Cool Status**: set to 0
-* **Fan Speed**: ramp to 0
-* **Return Humidity**: saw 0 to 80, increments of 5
-* **Return Air Temp**: single value 80 +/- 1
-* **Supply Air Temp**: single value 80 +/- 1
-* **Supply Air Flow**: ramp to 0
-* **Fluid Control Valve Position 1**: ramp to 0
-* **Fluid Control Valve Position 2**: ramp to 0
\ No newline at end of file
diff --git a/src/BMS/CRAH/PHX3_CRAH_LIEBERT_80_SLAB_TCP/StateUtils.cpp b/src/BMS/CRAH/PHX3_CRAH_LIEBERT_80_SLAB_TCP/StateUtils.cpp
deleted file mode 100644
index 7afd68b..0000000
--- a/src/BMS/CRAH/PHX3_CRAH_LIEBERT_80_SLAB_TCP/StateUtils.cpp
+++ /dev/null
@@ -1,227 +0,0 @@
-/**
- * @file StateUtils.cpp
- * @brief Implementation of the StateUtils class.
- * @author Robert J. Davis
- * @date 2025-10-24
- *
- * This file contains implementation of utility functions that are used in multiple States.
- */
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include "StateUtils.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/** The purpose of this function is to change the RA Temp, SA Temp, RA Humidity values for the purpose of testing alarms in Ignition.
- * There are LOW and HIGH coils, which when activated will set the analog to a low/high range.
- * The NORMAL coil will send a one-shot to set the associated analog value back into a normal range.
- * If in a RunningState, the analog value will follow it's normal function (typically a sawStrategy).
- */
-
-void updateAnalogs(Equipment<ModbusIP>* equipment){
-    if (equipment->getModbus_Point("RA Temp NORMAL")->getValue()==1){
-        equipment->setModbus_Point("Return Air Temp", 84.0f);
-        equipment->setModbus_Point("RA Temp Low Alarm ON", 0);
-        equipment->setModbus_Point("RA Temp High Alarm ON", 0);
-        equipment->setModbus_Point("RA Temp NORMAL", 0);
-    }
-    else if (equipment->getModbus_Point("RA Temp Low Alarm ON")->getValue() ==1){
-        equipment->setModbus_Point("Return Air Temp", 60.0f);
-        equipment->setModbus_Point("RA Temp High Alarm ON", 0);
-    }
-    else if (equipment->getModbus_Point("RA Temp High Alarm ON")->getValue()==1){
-        equipment->setModbus_Point("Return Air Temp", 110.0f);
-        equipment->setModbus_Point("RA Temp Low Alarm ON", 0);
-    }
-
-    if (equipment->getModbus_Point("RA Humidity NORMAL")->getValue()==1){
-        equipment->setModbus_Point("Return Humidity", 25.0f);
-        equipment->setModbus_Point("RA Humidity Low Alarm ON", 0);
-        equipment->setModbus_Point("RA Humidity High Alarm ON", 0);
-        equipment->setModbus_Point("RA Humidity NORMAL", 0);
-    }
-    else if (equipment->getModbus_Point("RA Humidity Low Alarm ON")->getValue()==1){
-        equipment->setModbus_Point("Return Humidity", 5.0f);
-        equipment->setModbus_Point("RA Humidity High Alarm ON", 0);
-    }
-    else if (equipment->getModbus_Point("RA Humidity High Alarm ON")->getValue()==1){
-        equipment->setModbus_Point("Return Humidity", 80.0f);
-        equipment->setModbus_Point("RA Humidity Low Alarm ON", 0);
-    }
-
-    if (equipment->getModbus_Point("SA Temp NORMAL")->getValue()==1){
-        equipment->setModbus_Point("Supply Air Temp", 76.0f);
-        equipment->setModbus_Point("SA Temp Low Alarm ON", 0);
-        equipment->setModbus_Point("SA Temp High Alarm ON", 0);
-        equipment->setModbus_Point("SA Temp NORMAL", 0);
-    }
-    else if (equipment->getModbus_Point("SA Temp Low Alarm ON")->getValue() ==1){
-        equipment->setModbus_Point("Supply Air Temp", 60.0f);
-        equipment->setModbus_Point("SA Temp High Alarm ON", 0);
-    }
-    else if (equipment->getModbus_Point("SA Temp High Alarm ON")->getValue()==1){
-        equipment->setModbus_Point("Supply Air Temp", 90.0f);
-        equipment->setModbus_Point("SA Temp Low Alarm ON", 0);
-    }
-}
-
-//This function updates the Alarm bit for the Return Air Temp
-void updateReturnAirTempAlarms(Equipment<ModbusIP>* equipment){
-    Modbus_Point<ModbusIP>* returnAirTemp = equipment -> getModbus_Point("Return Air Temp");
-    Modbus_Point<ModbusIP>* returnTempHighAlarmSP = equipment->getModbus_Point("Return Air Temp Alarm High SP");
-    Modbus_Point<ModbusIP>* returnTempLowAlarmSP = equipment->getModbus_Point("Return Air Temp Alarm Low SP");
-
-    if (returnAirTemp->getValue() < returnTempLowAlarmSP->getValue()) {
-        equipment->setModbus_Point("Alarm Low Return Air Temp", 1);
-        equipment->setModbus_Point("Alarm High Return Air Temp", 0);
-    }
-    else if (returnAirTemp->getValue() > returnTempHighAlarmSP->getValue()) {
-        equipment->setModbus_Point("Alarm High Return Air Temp", 1);
-        equipment->setModbus_Point("Alarm Low Return Air Temp", 0);
-    }
-    else{
-        equipment->setModbus_Point("Alarm High Return Air Temp", 0);
-        equipment->setModbus_Point("Alarm Low Return Air Temp", 0);
-    }
-}
-
-// This function updates the Alarm bit for the Supply Air Temp
-void updateSupplyAirTempAlarms(Equipment<ModbusIP>* equipment){
-    Modbus_Point<ModbusIP>* supplyAirTemp = equipment -> getModbus_Point("Supply Air Temp");
-    Modbus_Point<ModbusIP>* supplyTempHighAlarmSP = equipment->getModbus_Point("Supply Air Temp Alarm High SP");
-    Modbus_Point<ModbusIP>* supplyTempLowAlarmSP = equipment->getModbus_Point("Supply Air Temp Alarm Low SP");
-
-    if (supplyAirTemp->getValue() > supplyTempHighAlarmSP->getValue()) {
-        equipment->setModbus_Point("Alarm High Supply Temp", 1);
-        equipment->setModbus_Point("Alarm Low Supply Temp", 0);
-    }
-    else if (supplyAirTemp->getValue() < supplyTempLowAlarmSP->getValue()) {
-        equipment->setModbus_Point("Alarm Low Supply Temp", 1);
-        equipment->setModbus_Point("Alarm High Supply Temp", 0);
-    }
-    else{
-        equipment->setModbus_Point("Alarm High Supply Temp", 0);
-        equipment->setModbus_Point("Alarm Low Supply Temp", 0);
-    }
-}
-
-//This function updates the Alarm bit for the Return Humidity
-void updateReturnHumidityAlarms(Equipment<ModbusIP>* equipment){
-    Modbus_Point<ModbusIP>* returnHumidity = equipment -> getModbus_Point("Return Humidity");
-    Modbus_Point<ModbusIP>* returnHumHighAlarmSP = equipment->getModbus_Point("Return Humidity Alarm High SP");
-    Modbus_Point<ModbusIP>* returnHumLowAlarmSP = equipment->getModbus_Point("Return Humidity Alarm Low SP");
-
-    if (returnHumidity->getValue() > returnHumHighAlarmSP->getValue()) {
-        equipment->setModbus_Point("Alarm High Return Humidity", 1);
-        equipment->setModbus_Point("Alarm Low Return Humidity", 0);
-    }
-    else if (returnHumidity->getValue() < returnHumLowAlarmSP->getValue()) {
-        equipment->setModbus_Point("Alarm Low Return Humidity", 1);
-        equipment->setModbus_Point("Alarm High Return Humidity", 0);
-    }
-    else{
-        equipment->setModbus_Point("Alarm High Return Humidity", 0);
-        equipment->setModbus_Point("Alarm Low Return Humidity", 0);
-    }
-}
-
-
-/**
- * @brief This function will update the Alarm status DI bits according to the Alarm Commands from Coils (Modscan)
- * It will also update the Common Alarm: if any alarm is active, the Common alarm will also be active.
- * 
- * This is a function used in the update() of the Standby, Running, and Fail States.
- *
-*/ 
-
-void updateAlarms(Equipment<ModbusIP>* equipment){
-    const std::vector<std::string> alarmDescriptions = {
-        "Alarm Fan Overload", "Alarm Loss of Air", "Alarm Compressor 1A Overload", "Alarm Compressor 2A Overload",
-        "Alarm Smoke Detected", "Alarm Water Detected", "Alarm Standby Unit On", "Alarm CP High Water",
-        "Alarm Room Sensor Failure", "Alarm Power Loss", "Alarm High Return Air Temp", "Alarm Low Return Air Temp",
-        "Alarm High Return Humidity", "Alarm Low Return Humidity", "Alarm Clogged Filter", "Alarm Supply Sensor Failure",
-        "Alarm Unit Network Failure", "Alarm High Supply Temp", "Alarm Low Supply Temp", "Alarm Compressor 1 Short Cycle",
-        "Alarm Compressor 2 Short Cycle", "Alarm Fan Failure", "Alarm Circuit 1 Low Pressure", "Alarm Circuit 2 Low Pressure",
-        "Alarm Circuit 1 High Pressure", "Alarm Circuit 2 High Pressure", "Alarm High Return Air Dew Point",
-        "Alarm Low Return Air Dew Point", "Alarm Compressor 1 Over Temp", "Alarm Compressor 2 Over Temp",
-        "Common Alarm", "Alarm Pump Failure", "Alarm Comm Loss Condenser 1", "Alarm Comm Loss Condenser 2",
-        "Alarm Compressor 1B Overload", "Alarm Compressor 2B Overload"
-    };
-
-    const std::vector<std::string> alarmCommands = {
-        "Alarm Fan Overload ON", "Alarm Loss of Air ON", "Alarm Compressor 1A Overload ON", "Alarm Compressor 2A Overload ON",
-        "Alarm Smoke Detected ON", "Alarm Water Detected ON", "Alarm Standby Unit On ON", "Alarm High Water ON",
-        "Alarm Room Sensor Failure ON", "Alarm Power Loss ON", "Alarm High Return Air Temp ON", "Alarm Low Return Air Temp ON",
-        "Alarm High Return Humidity ON", "Alarm Low Return Humidity ON", "Alarm Clogged Filter ON", "Alarm Supply Sensor Failure ON",
-        "Alarm Unit Network Failure ON", "Alarm High Supply Temp ON", "Alarm Low Supply Temp ON", "Alarm Compressor 1 Short Cycle ON",
-        "Alarm Compressor 2 Short Cycle ON", "Alarm Fan Failure ON", "Alarm Circuit 1 Low Pressure ON", "Alarm Circuit 2 Low Pressure ON",
-        "Alarm Circuit 1 High Pressure ON", "Alarm Circuit 2 High Pressure ON", "Alarm High Return Air Dew Point ON",
-        "Alarm Low Return Air Dew Point ON", "Alarm Compressor 1 Over Temp ON", "Alarm Compressor 2 Over Temp ON",
-        "Common Alarm ON", "Alarm Pump Failure ON", "Alarm Comm Loss Condenser 1 ON", "Alarm Comm Loss Condenser 2 ON",
-        "Alarm Compressor 1B Overload ON", "Alarm Compressor 2B Overload ON"
-    };
-
-    const std::vector<std::string> alarmAnalogs = {
-        "Alarm High Return Air Temp", "Alarm Low Return Air Temp", "Alarm High Return Humidity", "Alarm Low Return Humidity",
-        "Alarm High Supply Temp", "Alarm Low Supply Temp"
-    };
-    
-    // If any Alarm Commands = 1, set the appropriate Alarm = 1 and increment counter for number of active alarms
-    int numAlarms = 0;
-    for (int i =0; i< alarmCommands.size() && i < alarmDescriptions.size(); ++i) {
-        Modbus_Point<ModbusIP>* commandPoint = equipment->getModbus_Point(alarmCommands[i]);
-        Modbus_Point<ModbusIP>* alarmPoint = equipment->getModbus_Point(alarmDescriptions[i]);
-        if (commandPoint) {
-            alarmPoint->setValue(commandPoint->getValue());
-            if (alarmPoint->getValue() == 1) numAlarms++;
-        }
-    }
-    // If any of the analog alarms = 1, increment counter for number of active alarms
-    for (int j = 0; j<alarmAnalogs.size(); ++j){
-        Modbus_Point<ModbusIP>* alarmAnalogPoint = equipment->getModbus_Point(alarmAnalogs[j]);
-        if (alarmAnalogPoint) {
-            if (alarmAnalogPoint->getValue() == 1) numAlarms++;
-        }
-    }
-    // If any alarms are active, set the Common Alarm = 1, else Common Alarm = 0.
-    if (numAlarms >= 1) equipment->setModbus_Point("Common Alarm", 1);
-    else equipment->setModbus_Point("Common Alarm", 0);
-}
-
-/**
- * @brief Updates Dehumidifier Mode
- * 
- * This function will update the Dehumidifier Mode based on Dehumidifier Mode Command (Coil 1)
- * received from Modscan. This is for simulation purposes only - in practice, the Chiller
- * will transition to Dehumidifier mode based on its own internal logic.
- * 
- * For ease of testing, this is a function used in the update() of the Standby, Running, and Fail States.
- *
-*/ 
-
-void updateDehumidifier(Equipment<ModbusIP>* equipment){
-    Modbus_Point<ModbusIP>* DehumidifierCommand = equipment->getModbus_Point("Dehumidifier Mode ON");
-    Modbus_Point<ModbusIP>* DehumidifierStatus = equipment->getModbus_Point("Dehumidifier Status");
-    if (DehumidifierCommand->getValue() == 1) {
-        DehumidifierStatus->setValue(1);
-    }
-    else {
-        DehumidifierStatus->setValue(0);
-    }
-}
\ No newline at end of file
diff --git a/src/BMS/CRAH/PHX3_CRAH_LIEBERT_80_SLAB_TCP/StateUtils.h b/src/BMS/CRAH/PHX3_CRAH_LIEBERT_80_SLAB_TCP/StateUtils.h
deleted file mode 100644
index 861ff6d..0000000
--- a/src/BMS/CRAH/PHX3_CRAH_LIEBERT_80_SLAB_TCP/StateUtils.h
+++ /dev/null
@@ -1,48 +0,0 @@
-/**
- * @file config.h
- * @brief StateUtils class
- * @author Robert J Davis
- * @date 2025-10-24
- *
- * Defines the StateUtils class, which contains utility functions used in multiple States.
- */
-
-#pragma once
-
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-template <typename T>
-class State;
-
-void updateAnalogs(Equipment<ModbusIP>* equipment);
-void updateReturnAirTempAlarms(Equipment<ModbusIP>* equipment);
-void updateSupplyAirTempAlarms(Equipment<ModbusIP>* equipment);
-void updateReturnHumidityAlarms(Equipment<ModbusIP>* equipment);
-
-/**
- * @brief Checks common alarms (non-fail alarms) and updates the Common Alarm Modbus point.
- * @param equipment Pointer to the Equipment instance.
- * @return void
- */
-void updateAlarms(Equipment<ModbusIP>* equipment);
-
-/** 
- * @brief Checks Dehumidifier Mode ON from Modscan (Coil 1) and updates the Dehumidifier Status point.
- * @param equipment Pointer to the Equipment instance.
- * @return void
- */
-void updateDehumidifier(Equipment<ModbusIP>* equipment);
\ No newline at end of file
diff --git a/src/BMS/CRAH/PHX3_CRAH_LIEBERT_80_SLAB_TCP/State_Fail.cpp b/src/BMS/CRAH/PHX3_CRAH_LIEBERT_80_SLAB_TCP/State_Fail.cpp
deleted file mode 100644
index 68a36fb..0000000
--- a/src/BMS/CRAH/PHX3_CRAH_LIEBERT_80_SLAB_TCP/State_Fail.cpp
+++ /dev/null
@@ -1,103 +0,0 @@
-/**
- * @file State_Fail.cpp
- * @brief Implementation of the FailState class.
- * @author Robert J Davis
- * @date 2025-10-24
- *
- * This file contains the implementation for the FailState, which defines
- * the behavior of the equipment when it has entered a fault condition.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "StateUtils.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new FailState object with a list of active alarms.
- *
- * This constructor ramps Fan Speed, Supply Air Flow, and Fluid Control Valves to 0.
- * Return Humidity continues to saw between 0-80 (for sake of Ignition display verification)
- * Return and Supply Air Temp is 80 +/- 1
- * 
- */
-template<>
-FailState<ModbusIP>::FailState(const std::vector<std::string>& activeAlarms) {
-    addStrategy("Fan Speed", new RampStrategy(0.0f, 10.0f, 1000)); 
-    addStrategy("Return Humidity", new SawStrategy(25.0f, 35.0f, 1.0f, 2000));
-    addStrategy("Return Air Temp", new SingleValueStrategy(80.0f, 1.0f, 3000));
-    addStrategy("Supply Air Temp", new SingleValueStrategy(76.0f, 1.0f, 3000));
-    addStrategy("Supply Air Flow", new RampStrategy(0.0f, 1.0f, 1000));
-    addStrategy("Fluid Control Valve Position 1", new RampStrategy(0.0f, 5.0f, 1000));   
-    addStrategy("Fluid Control Valve Position 2", new RampStrategy(0.0f, 5.0f, 1000));  
-}
-
-/**
- * @brief Executes the fail state's logic for one update cycle.
- *
- * My programming logic: ensure System On/Off Control is always set to 0. This will ensure
- * that after the fault is cleared, the unit will enter StandbyMode and will then be commanded
- * by Operator to starts, rather than automatically restarting. This is my assumption for the sake
- * of testing, actual implementation may be different.
- * 
- * The only way to exit FailState is for the Smoke Detect and High Water alarms to be cleared.
- * Upon exiting FailState, the unit will enter StandbyState.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* FailState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Fail update function");
-
-    setPointValue(equipment, "System On/Off Control", 0);  // my programming logic: when clear fault, should be sent to Standby Mode
-    updateAnalogs(equipment);
-    updateReturnAirTempAlarms(equipment);
-    updateSupplyAirTempAlarms(equipment);
-    updateReturnHumidityAlarms(equipment);
-    updateAlarms(equipment);
-    updateDehumidifier(equipment);  // Dehumidifier mode can be toggled while in FailState (for ease of Ignition HMI verification)
-
-    bool smokeDetectState = getPointValue(equipment, "Alarm Smoke Detected");
-    bool highWaterState = getPointValue(equipment, "Alarm CP High Water");
-    if (smokeDetectState == false && highWaterState == false){
-        return new StandbyState<ModbusIP>();
-    }
-
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the fail state.
- * Sets the Unit Status, Supply Fan Status, Cooling Status, and Free Cooling Status to 0 (off).
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    setPointValue(equipment, "Unit Status", 0);
-    setPointValue(equipment, "Supply Fan Status", 0);
-    setPointValue(equipment, "Cooling Status", 0);
-    setPointValue(equipment, "Free Cooling Status", 0);
-}
-
-/**
- * @brief Logic to execute once when exiting the fail state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Fail State...");
-}
\ No newline at end of file
diff --git a/src/BMS/CRAH/PHX3_CRAH_LIEBERT_80_SLAB_TCP/State_Running.cpp b/src/BMS/CRAH/PHX3_CRAH_LIEBERT_80_SLAB_TCP/State_Running.cpp
deleted file mode 100644
index bca9ab6..0000000
--- a/src/BMS/CRAH/PHX3_CRAH_LIEBERT_80_SLAB_TCP/State_Running.cpp
+++ /dev/null
@@ -1,140 +0,0 @@
-/**
- * @file State_Running.cpp
- * @brief Implementation of the RunningState class.
- * @author Robert J Davis
- * @date 2025-10-24
- *
- * This file contains the implementation for the RunningState, which defines
- * the behavior of the equipment when it is actively running.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "Strategies/Strategy_Totalizer.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include "StateUtils.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new RunningState object.
- *
- * This constructor initializes behavior strategies active during the running state. 
- * Return Air Temp saws between 66 and 110 to cover both low alarm and high alarm states (72 and 100).
- * Supply Air Temp saws between 68 and 86 to cover both low alarm and high alarm states (72 and 78).
- * Supply Air Flow saws between 7 to 10 (for Ignition HMI verification, no correlation to expected values).
- * Fan Speed adjusts via PID on Return Air Temp Setpoint (note: PID parameters are set in base code, can't be adjusted)
- * Fluid Control Valve Positions adjust via PID on Supply Air Temp Setpoint.
- * Unsure of the difference between FCV 1 and 2, therefore they just match for the sake of testing.
- * 
- */
-template<>
-RunningState<ModbusIP>::RunningState() {
-    addStrategy("Return Humidity", new SawStrategy(25.0f, 35.0f, 1.0f, 2000));
-    addStrategy("Return Air Temp", new SawStrategy(78.0f, 88.0f, 1.0f, 3000));
-    addStrategy("Supply Air Temp", new SawStrategy(73.0f, 77.0f, 1.0f, 5000));
-
-    addStrategy("Supply Air Flow", new SawStrategy(7.0f, 10.0f, 1.0f, 1000));
-    addStrategy("Fan Speed", new PIDStrategy("Return Air Temp Setpoint", 1000, "Return Air Temp")); 
-    addStrategy("Fluid Control Valve Position 1", new PIDStrategy("Supply Air Temp Setpoint", 1000, "Supply Air Temp"));   
-    addStrategy("Fluid Control Valve Position 2", new PIDStrategy("Supply Air Temp Setpoint", 1000, "Supply Air Temp")); 
-}
-
-/**
- * @brief Executes the running state's logic for one update cycle.
- *
- * This method first checks for state transition commands:
- * 1. Updates Alarm states
- * 2. Updates Dehumidifier mode (for ease of Ignition verification)
- * If the Smoke Detected or High Water alarms annunciate, send to FailState.
- * 
- * 3. Check if On/Off Command = 0, then send to Standby State.
- *
- * If no transition occurs, it applies the strategies defined for the running state.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* RunningState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    Serial.println("Running update function");
-
-    updateAnalogs(equipment);
-    updateReturnAirTempAlarms(equipment);
-    updateSupplyAirTempAlarms(equipment);
-    updateReturnHumidityAlarms(equipment);
-
-    updateAlarms(equipment);
-    updateDehumidifier(equipment);
-
-    bool smokeDetect = getPointValue(equipment, "Alarm Smoke Detected");
-    bool highWater = getPointValue(equipment, "Alarm CP High Water");
-    std::vector<std::string> activeFailAlarms;
-    if (smokeDetect) activeFailAlarms.push_back("Alarm Smoke Detected");
-    if (highWater) activeFailAlarms.push_back("Alarm CP High Water");
-    if (!activeFailAlarms.empty()){
-        return new FailState<ModbusIP>(activeFailAlarms);
-    }
-
-    int On_Off_Command = getPointValue(equipment, "System On/Off Control");
-    if (On_Off_Command == 0){
-        return new StandbyState<ModbusIP>();
-    }
-
-    // Due to 10x scaling of Supply and Return Air Temps, need to adjust for PID strategies
-    float returnTemp = getPointValue(equipment, "Return Air Temp")/10;
-    float supplyTemp = getPointValue(equipment, "Supply Air Temp")/10;
-    float returnTempSP = getPointValue(equipment, "Return Air Temp Setpoint");
-    float supplyTempSP = getPointValue(equipment, "Supply Air Temp Setpoint");
-
-    Strategy_Behavior* FluidControlValve1_strat = getStrategy("Fluid Control Valve Position 1");
-    Strategy_Behavior* FluidControlValve2_strat = getStrategy("Fluid Control Valve Position 2");
-    Strategy_Behavior* FanSpeed_strat = getStrategy("Fan Speed");
-    static_cast<PIDStrategy*>(FluidControlValve1_strat)->setLimits(supplyTempSP, supplyTemp);
-    static_cast<PIDStrategy*>(FluidControlValve2_strat)->setLimits(supplyTempSP, supplyTemp);
-    static_cast<PIDStrategy*>(FanSpeed_strat)->setLimits(returnTempSP, returnTemp);
-    
-
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the running state.
- * Sets the Unit Status, Supply Fan Status, Cooling Status, and Free Cooling Status to 1 to indicate they are active.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    setPointValue(equipment, "Unit Status", 1);
-    setPointValue(equipment, "Supply Fan Status", 1);
-    setPointValue(equipment, "Cooling Status", 1);
-    setPointValue(equipment, "Free Cooling Status", 0);
-}
-
-/**
- * @brief Logic to execute once when exiting the running state.
- * All State transitions are executed on enterState function, therefore
- * this exitState function is not used.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-}
\ No newline at end of file
diff --git a/src/BMS/CRAH/PHX3_CRAH_LIEBERT_80_SLAB_TCP/State_Standby.cpp b/src/BMS/CRAH/PHX3_CRAH_LIEBERT_80_SLAB_TCP/State_Standby.cpp
deleted file mode 100644
index cd0f010..0000000
--- a/src/BMS/CRAH/PHX3_CRAH_LIEBERT_80_SLAB_TCP/State_Standby.cpp
+++ /dev/null
@@ -1,122 +0,0 @@
-/**
- * @file State_Standby.cpp
- * @brief Implementation of the StandbyState class.
- * @author Robert J Davis
- * @date 2025-10-24
- *
- * This file contains the implementation for the StandbyState, which defines
- * the behavior of the equipment when it is in an idle or standby mode.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include "StateUtils.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-/**
- * @brief Constructs a new StandbyState object.
- *
- * In this state, the equipment is idle. This constructor initializes strategies
- * to bring the system to a safe, idle condition. 
- * It ramps Fan Speed, Supply Air Flow, and Fluid Control Valves to 0.
- * Return Humidity continues to saw between 0-80 (for sake of Ignition display verification)
- * Return and Supply Air Temp is 80 +/- 1.
- */
-template<>
-StandbyState<ModbusIP>::StandbyState() {
-    addStrategy("Fan Speed", new RampStrategy(0.0f, 10.0f, 1000)); 
-    addStrategy("Return Humidity", new SawStrategy(25.0f, 35.0f, 1.0f, 2000));
-    addStrategy("Return Air Temp", new SingleValueStrategy(80.0f, 1.0f, 3000));
-    addStrategy("Supply Air Temp", new SingleValueStrategy(76.0f, 1.0f, 3000));
-    addStrategy("Supply Air Flow", new RampStrategy(0.0f, 1.0f, 5000));
-    addStrategy("Fluid Control Valve Position 1", new RampStrategy(0.0f, 5.0f, 1000));   
-    addStrategy("Fluid Control Valve Position 2", new RampStrategy(0.0f, 5.0f, 1000));  
-}
-
-/**
- * @brief Executes the standby state's logic for one update cycle.
- *
- * This method first checks for state transition commands:
- * 1. Updates Alarm states
- * 2. Updates Dehumidifier mode (for ease of Ignition verification)
- * If the Smoke Detected or High Water alarms annunciate, send to FailState.
- * 
- * 3. Check if On/Off Command = 1, then send to Running State.
- *
- * If no transition occurs, it applies the strategies defined for the standby state.
- *
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* StandbyState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Standby update function");
-
-    updateAnalogs(equipment);
-    updateReturnAirTempAlarms(equipment);
-    updateSupplyAirTempAlarms(equipment);
-    updateReturnHumidityAlarms(equipment);
-
-    updateAlarms(equipment);
-    updateDehumidifier(equipment);
-    
-    bool smokeDetect = getPointValue(equipment, "Alarm Smoke Detected");
-    bool highWater = getPointValue(equipment, "Alarm CP High Water");
-    std::vector<std::string> activeFailAlarms;
-    if (smokeDetect == true) activeFailAlarms.push_back("Alarm Smoke Detected");
-    if (highWater == true) activeFailAlarms.push_back("Alarm CP High Water");
-    if (!activeFailAlarms.empty()){
-        return new FailState<ModbusIP>(activeFailAlarms);
-    }
-
-    int On_Off_Command = getPointValue(equipment, "System On/Off Control");
-    if (On_Off_Command == 1){
-        return new RunningState<ModbusIP>();
-    }
-
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the standby state.
- * Sets the Unit Status = 2 (standby) and Free Cooling Status to 1 (assume whenever in Standby Mode, runs in Free Cooling)
- * Supply Fan Status, Cooling Status, Dehumidifier Status, and On/Off Command set to 0.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Set all Unit Status to 2 (standby), ensure On Off Command also set to 0.
-    setPointValue(equipment, "Unit Status", 2);
-    setPointValue(equipment, "Supply Fan Status", 0);
-    setPointValue(equipment, "Cooling Status", 0);
-    setPointValue(equipment, "Free Cooling Status", 1);
-    setPointValue(equipment, "Dehumidifier Status", 0);
-    setPointValue(equipment, "System OnOff Control", 0);
-}
-
-/**
- * @brief Logic to execute once when exiting the standby state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Standby State...");
-}
\ No newline at end of file
diff --git a/src/BMS/CRAH/PHX3_CRAH_LIEBERT_80_SLAB_TCP/config.h b/src/BMS/CRAH/PHX3_CRAH_LIEBERT_80_SLAB_TCP/config.h
deleted file mode 100644
index 695c5ac..0000000
--- a/src/BMS/CRAH/PHX3_CRAH_LIEBERT_80_SLAB_TCP/config.h
+++ /dev/null
@@ -1,195 +0,0 @@
-/**
- * @file config.h
- * @brief Main configuration file for the Electrical Gallery CRAH Unit (TCP) emulator - Vertiv Liebert 80 Slab TCP PHX3 DC1
- * @author Robert J Davis
- * @date 2025-10-24
- *
- * This file contains two important configurations: WiFi network parameters
- * and the Modbus register map for the device.
- */
-
-#ifndef CONFIG_H
-#define CONFIG_H
-
-#include "core.h"
-#include "Equipment/Equipment.h"
-
-#if defined(USE_MODBUS_IP)
-/**
-   * @defgroup ModbusTCPConfig Modbus IP Configuration
-   * @brief Parameters for Modbus TCP communication.
-   * @{
-   */
-  #include <ModbusIP_ESP8266.h>
-  const char *ssid = "ArduinoWifiB";          /**< @brief The SSID of the WiFi network. */
-  const char *password = "123abc456";          /**< @brief The password for the WiFi network. */
-  IPAddress local_IP(172, 17, 32, 66);       /**< @brief The static IP address for the device. */
-  IPAddress gateway(172, 17, 32, 1);          /**< @brief The gateway IP address. */
-  IPAddress subnet(255, 255, 255, 0);         /**< @brief The subnet mask. */
-  
-  ModbusIP mb;
-#else
-  /**
-   * @defgroup ModbusRTUConfig Modbus RTU Configuration
-   * @brief Parameters for serial Modbus RTU communication.
-   * @{
-   */
-  #include <ModbusRTU.h>
-  const int BAUDRATE = 19200;   /**< @brief The serial communication speed in bits per second. */
-  const int RX_PIN = 17;        /**< @brief The GPIO pin used for receiving data (RX). */
-  const int TX_PIN = 16;        /**< @brief The GPIO pin used for transmitting data (TX). */
-  const int RST_PIN = 4;        /**< @brief The GPIO pin connected to the RS485 driver's DE/RE pins for direction control. */
-  const int MODBUS_ID = 1;      /**< @brief The unique slave ID for this device on the Modbus bus. */
-  /** @} */
-
-  /** @brief Global instance of the Modbus RTU server. */
-  ModbusRTU mb;
-#endif
-
-/**
- * @defgroup ModbusMapConfig Modbus Map Configuration
- * @brief Defines the Modbus register map and related parameters for the emulator.
- * @{
- */
-/**
- * @brief The Modbus map for the Equipment device.
- * This array defines all the Modbus points available on the emulated device.
- * The `description` field is crucial as it's used to look up points within the application logic.
- */
-modbusMap mb_map[] =
-{   
-  {COIL,      0,      0,      "Dehumidifier Mode ON"},              // For Arduino testing only
-  {COIL,      1,      0,      "Alarm Smoke Detected ON"},           // For Arduino testing only - will send to FailState
-  {COIL,      2,      0,      "Alarm High Water ON"},               // For Arduino testing only - will send to FailState
-
-  {COIL,      3,      0,      "Alarm Fan Overload ON"},             // For Arduino testing only
-  {COIL,      4,      0,      "Alarm Loss of Air ON"},              // For Arduino testing only
-  {COIL,      5,      0,      "Alarm Compressor 1A Overload ON"},   // For Arduino testing only
-  {COIL,      6,      0,      "Alarm Compressor 2A Overload ON"},   // For Arduino testing only
-  {COIL,      7,      0,      "Alarm Water Detected ON"},           // For Arduino testing only
-  {COIL,      8,      0,      "Alarm Standby Unit On ON"},          // For Arduino testing only
-  {COIL,      9,      0,      "Alarm Room Sensor Failure ON"},      // For Arduino testing only
-  {COIL,      10,     0,      "Alarm Power Loss ON"},               // For Arduino testing only
-  {COIL,      11,     0,      "Alarm Clogged Filter ON"},           // For Arduino testing only
-  {COIL,      12,     0,      "Alarm Supply Sensor Failure ON"},    // For Arduino testing only
-  {COIL,      13,     0,      "Alarm Unit Network Failure ON"},     // For Arduino testing only
-  {COIL,      14,     0,      "Alarm Compressor 1 Short Cycle ON"}, // For Arduino testing only
-  {COIL,      15,     0,      "Alarm Compressor 2 Short Cycle ON"}, // For Arduino testing only
-  {COIL,      16,     0,      "Alarm Fan Failure ON"},              // For Arduino testing only
-
-  {COIL,      17,     0,      "Alarm Circuit 1 Low Pressure ON"},   // For Arduino testing only
-  {COIL,      18,     0,      "Alarm Circuit 2 Low Pressure ON"},   // For Arduino testing only
-  {COIL,      19,     0,      "Alarm Circuit 1 High Pressure ON"},  // For Arduino testing only
-  {COIL,      20,     0,      "Alarm Circuit 2 High Pressure ON"},  // For Arduino testing only
-  {COIL,      21,     0,      "Alarm High Return Air Dew Point ON"},  // For Arduino testing only
-  {COIL,      22,     0,      "Alarm Low Return Air Dew Point ON"},   // For Arduino testing only
-  {COIL,      23,     0,      "Common Alarm ON"},                   // For Arduino testing only
-  {COIL,      24,     0,      "System On/Off Control"},              
-  {COIL,      25,     0,      "Alarm Compressor 1 Over Temp ON"},   // For Arduino testing only
-  {COIL,      26,     0,      "Alarm Compressor 2 Over Temp ON"},   // For Arduino testing only
-  {COIL,      27,     0,      "Alarm Pump Failure ON"},             // For Arduino testing only
-  {COIL,      28,     0,      "Alarm Comm Loss Condenser 1 ON"},    // For Arduino testing only
-  {COIL,      29,     0,      "Alarm Comm Loss Condenser 2 ON"},    // For Arduino testing only
-  {COIL,      30,     0,      "Alarm Compressor 1B Overload ON"},   // For Arduino testing only
-  {COIL,      31,     0,      "Alarm Compressor 2B Overload ON"},   // For Arduino testing only
-
-  {COIL,      32,     0,      "RA Temp Low Alarm ON"},   // For Arduino testing only - sets RA Temp = 60
-  {COIL,      33,     0,      "RA Temp NORMAL"},   // For Arduino testing only - sets RA Temp = 84
-  {COIL,      34,     0,      "RA Temp High Alarm ON"},   // For Arduino testing only - sets RA Temp = 110
-  
-  {COIL,      35,     0,      "RA Humidity Low Alarm ON"},   // For Arduino testing only - sets RA Humidity = 5
-  {COIL,      36,     0,      "RA Humidity NORMAL"},   // For Arduino testing only - sets RA Humidity = 25
-  {COIL,      37,     0,      "RA Humidity High Alarm ON"},   // For Arduino testing only - sets RA Humidity = 80
-  
-  {COIL,      38,     0,      "SA Temp Low Alarm ON"},   // For Arduino testing only - sets SA Temp = 60
-  {COIL,      39,     0,      "SA Temp NORMAL"},   // For Arduino testing only - sets SA Temp = 76
-  {COIL,      40,     0,      "SA Temp High Alarm ON"},   // For Arduino testing only - sets SA Temp = 90
-
-  {DI,        24,     0,      "Supply Fan Status"},
-  {DI,        25,     0,      "Cooling Status"},
-  {DI,        26,     0,      "Free Cooling Status"},
-  {DI,        30,     0,      "Dehumidifier Status"},
-
-  {DI,        33,     0,      "Alarm Fan Overload"},
-  {DI,        34,     0,      "Alarm Loss of Air"},
-  {DI,        38,     0,      "Alarm Compressor 1A Overload"},
-  {DI,        42,     0,      "Alarm Compressor 2A Overload"},
-  {DI,        46,     0,      "Alarm Smoke Detected"},
-  {DI,        47,     0,      "Alarm Water Detected"},
-  {DI,        50,     0,      "Alarm Standby Unit On"},
-  {DI,        51,     0,      "Alarm CP High Water"},
-  {DI,        52,     0,      "Alarm Room Sensor Failure"},
-  {DI,        60,     0,      "Alarm Power Loss"},
-  {DI,        66,     0,      "Alarm High Return Air Temp"},     // 100 set in Ignition
-  {DI,        67,     0,      "Alarm Low Return Air Temp"},      // 72 set in Ignition
-  {DI,        68,     0,      "Alarm High Return Humidity"},     // 60 set in Ignition
-  {DI,        69,     0,      "Alarm Low Return Humidity"},      // 20 set in Ignition
-  {DI,        75,     0,      "Alarm Clogged Filter"},
-  {DI,        76,     0,      "Alarm Supply Sensor Failure"},
-  {DI,        91,     0,      "Alarm Unit Network Failure"},
-  {DI,        208,     0,      "Alarm High Supply Temp"},         // 78 set in Ignition
-  {DI,        209,     0,      "Alarm Low Supply Temp"},          // 72 set in Ignition
-  {DI,        211,     0,      "Alarm Compressor 1 Short Cycle"},
-  {DI,        212,     0,      "Alarm Compressor 2 Short Cycle"},
-  {DI,        217,     0,      "Alarm Fan Failure"},
-  {DI,        239,     0,      "Alarm Circuit 1 Low Pressure"},
-  {DI,        240,     0,      "Alarm Circuit 2 Low Pressure"},
-  {DI,        241,     0,      "Alarm Circuit 1 High Pressure"},
-  {DI,        242,     0,      "Alarm Circuit 2 High Pressure"},
-  {DI,        344,     0,      "Alarm High Return Air Dew Point"},
-  {DI,        345,     0,      "Alarm Low Return Air Dew Point"},
-  {DI,        348,     0,      "Alarm Compressor 1 Over Temp"},
-  {DI,        349,     0,      "Alarm Compressor 2 Over Temp"},
-  {DI,        350,     0,      "Common Alarm"},
-  {DI,        491,     0,      "Alarm Pump Failure"},
-  {DI,        682,     0,      "Alarm Comm Loss Condenser 1"},
-  {DI,        683,     0,      "Alarm Comm Loss Condenser 2"},
-  {DI,        740,     0,      "Alarm Compressor 1B Overload"},
-  {DI,        741,     0,      "Alarm Compressor 2B Overload"},
-
-  {IR,        99,     0,       "Unit Status"},           // 0:off, 1:on, 2:standby
-  {IR,        102,     0,      "Fan Speed"},
-  {IR_10x,    129,     250,      "Return Humidity"},
-  {IR_10x,    742,     840,      "Return Air Temp"},
-  {IR_10x,    743,     760,      "Supply Air Temp"},
-  {IR,        1465,     0,     "Supply Air Flow"},
-  {IR,        2050,     0,     "Fluid Control Valve Position 1"},
-  {IR,        2051,     0,     "Fluid Control Valve Position 2"},
-
-  {HR_10x,    53,      600,     "Return Humidity Alarm High SP"},
-  {HR_10x,    54,      200,     "Return Humidity Alarm Low SP"},
-  {HR, 56, 0, "RAHum Value"},
-  {HR, 57, 0, "RAHumHighAlm Value"},
-  {HR, 58, 0, "RAHumLowAlm Value"},
-
-  {HR,        732,     73,     "Supply Air Temp Setpoint"},
-
-  {HR_10x,    738,     1000,    "Return Air Temp Alarm High SP"},
-  {HR_10x,    739,     720,     "Return Air Temp Alarm Low SP"},
-  {HR, 741, 0, "RATemp Value"},
-  {HR, 742, 0, "RATempHighAlm Value"},
-  {HR, 743, 0, "RATempLowAlm Value"},
-
-
-  {HR,        753,     80,     "Return Air Temp Setpoint"},
-  {HR_10x,    754,     780,     "Supply Air Temp Alarm High SP"},
-  {HR_10x,    755,     720,     "Supply Air Temp Alarm Low SP"},
-  {HR, 757, 0, "SATemp Value"},
-  {HR, 758, 0, "SATempHighAlm Value"},
-  {HR, 759, 0, "SATempLowAlm Value"},
-  
-
-};
-//Size of modbus map used in FOR cycles, automatically calculated.
-
-/**
- * @brief The total number of entries in the `mb_map` array.
- * This is calculated at compile time and used for iterating over the map.
- */
-const int map_size = sizeof(mb_map) / sizeof(mb_map[0]);
-
-/** @brief The main loop update interval in milliseconds. */
-int interval = 250; 
-/** @} */ // End of ModbusMapConfig group
-
-#endif // CONFIG_H
diff --git a/src/BMS/CRAH/PHX3_CRAH_LIEBERT_80_SLAB_TCP/main.cpp b/src/BMS/CRAH/PHX3_CRAH_LIEBERT_80_SLAB_TCP/main.cpp
deleted file mode 100644
index 286a98c..0000000
--- a/src/BMS/CRAH/PHX3_CRAH_LIEBERT_80_SLAB_TCP/main.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-/**
- * @file main.cpp
- * @brief Main execution program for the CRAH Unit (TCP) Emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * @details This file contains the main execution program for an Arduino-based emulator of a CRAH unit. 
- * The program uses a Wi-Fi connection to communicate via the Modbus IP protocol.
- *
- * The setup() function initializes the following:
- * - Serial communication for debugging.
- * - Wi-Fi connection using credentials from config.h.
- * - A Modbus TCP server.
- * - Modbus points (Coils, Holding Registers, etc.) based on a predefined map in config.h.
- *
- * The loop() function continuously:
- * - Services the Modbus TCP server to handle incoming requests.
- * - Periodically calls the main update loop for the emulated equipment, which
- *   manages state transitions and behavior strategies.
- *
- * @see config.h for Wi-Fi and Modbus configuration.
- * @see Equipment.h for the main equipment logic.
- * @see State.h for different equipment states.
- * @see Strategies/Strategy_Behavior.h for value generation strategies.
- * @see Modbus_Point.h for the base class for all Modbus points.
- */
-//=================================================================================================================================
-//Libraries and declaration of variables.
-#include <WiFi.h>
-#include "config.h"
-#include "ModbusPoints/Modbus_PointFactory.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-//=================================================================================================================================
-/** 
- * @brief Initializes the application.
- * @details This function runs once at startup. It configures the serial communication, 
- * Wi-Fi, and the Modbus server. It also creates and initializes all the Modbus points 
- * based on the `mb_map` array in `config.h`.
- */
-void setup() {
-  Serial.begin(115200);                       //Serial comm start
-  WiFi.config(local_IP, gateway, subnet);     // Wifi service start
-  WiFi.begin(ssid, password);
-  while (WiFi.status() != WL_CONNECTED) {
-    delay(1000);
-    Serial.print(".");
-  }
-  Serial.println("Connected!!");
-  mb.server();                                //Modbus server start
-  Serial.println("Server Created");
-  Serial.println(map_size);
-  for(int i = 0; i < map_size; i++){
-    Modbus_Point<ModbusIP>* point = createModbus_Point(&mb, mb_map[i].category, mb_map[i].address, mb_map[i].value, mb_map[i].description);
-    if (point) {
-      point->addToModbusServer();
-      EquipmentInstance.addModbus_Point(mb_map[i].description, point);
-    }
-  }
-  Serial.println("All modbus Points created");
-  Serial.println("Setup function ended");
-}
-//=================================================================================================================================
-/** 
- * @brief The main application loop.
- * @details This function runs repeatedly after setup() has completed. It performs two main actions:
- * 1. It continuously services the Modbus server by calling `mb.task()` to handle
- *    incoming requests from a Modbus master.
- * 2. At a fixed interval (defined in `config.h`), it calls `EquipmentInstance.update()`
- *    to run the emulator's internal state machine and behavior logic.
- */
-void loop() {
-  mb.task();
-  unsigned long currentMillis = millis();
-  if (currentMillis - previousMillis >= interval) {
-    previousMillis = currentMillis;
-    unsigned long startTime = millis();
-    EquipmentInstance.update();
-    unsigned long endTime = millis();
-    unsigned long elapsedTime = endTime - startTime;
-    Serial.printf("Control Execution time: %d ms\n", elapsedTime);
-  } 
-}
diff --git a/src/BMS/HUM/HUM_DriSteem_RTS_RX36_TCP/README.md b/src/BMS/HUM/HUM_DriSteem_RTS_RX36_TCP/README.md
deleted file mode 100644
index 59b4aaa..0000000
--- a/src/BMS/HUM/HUM_DriSteem_RTS_RX36_TCP/README.md
+++ /dev/null
@@ -1,51 +0,0 @@
-# Humidifier Dri-Steem RTS RX-36-1 TCP
-
-## Brief Introduction
-This humidifier receives on/off commands and RH Setpoint from the PLC.
-The Space RH register is not used, since there will not be a Space RH sensor wired to the HUM unit.
-The RH Setpoint will be determined based on dewpoints in the datahall. See QTS SOO for details.
-
-## List of Equipment
-This configuration has been used for these models:
-* **RTS RX-36-1**: 10-28-2025
-
-## Hardware Prerequisites
-
-The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities.
-* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html) 
-
----
-
-## States and Strategies
-Provide a brief description of what variables and strategies were used in this configuraiton
-
-### Standby State
-Run Mode = 3 (system standby)
-Duct RH = 35 +/- 5
-Fill Valve, Drain Valve = 0
-Steam Demand Mass/Pct = 0
-Steam Output Mass/Pct = 0
-If any alarms active or safety interlock = 0 --> FailState
-Checks for Run Mode = 1 AND Air Proving Switch = 1 --> RunningState
-
-### Running State
-Run Mode = 1 (auto)
-If any alarms active or safety interlock = 0 --> FailState
-If Run Mode = 3 or loss of airflow --> StandbyState
-Reads RH Setpoint from PLC
-DuctRH will dynamically ramp to RH Setpoint
-Fill Valve and Drain Valve switch between 0 and 1 (squareStrategy)
-Steam Demand Mass between 3-6 (sawStrategy)
-Steam Demand Percent between 50-80% (sawStrategy)
-Tank Temp = 80 +/- 3
-Steam Output Mass = 4 +/- 1
-Steam Output Percent = 65 +/- 10
-Water Until ADS/Service will ramp down to 0 (initializes at 1500 and 10000)
-
-### Fail State
-Run Mode = 3 (system standby)
-Duct RH = 35 +/- 5
-Fill Valve, Drain Valve = 0
-Steam Demand Mass/Pct = 0
-Steam Output Mass/Pct = 0
-When all alarms are cleared and safety interlock = 1 --> StandbyState
\ No newline at end of file
diff --git a/src/BMS/HUM/HUM_DriSteem_RTS_RX36_TCP/StateUtils.cpp b/src/BMS/HUM/HUM_DriSteem_RTS_RX36_TCP/StateUtils.cpp
deleted file mode 100644
index 424f2c1..0000000
--- a/src/BMS/HUM/HUM_DriSteem_RTS_RX36_TCP/StateUtils.cpp
+++ /dev/null
@@ -1,91 +0,0 @@
-/**
- * @file StateUtils.cpp
- * @brief Implementation of the StateUtils class.
- * @author Robert J. Davis
- * @date 2025-10-28
- *
- * This file contains implementation of utility functions that are used in multiple States.
- */
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include "StateUtils.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief This function will update the Alarm bits and Safety Interlock state (based on Safety Interlock ON coil - for testing only)
- * If the "Clear All Active Alarms" coil is activate, all alarms will be cleared, the Safety Interlock will be set to 1 (ready to operate),
- * and the "Manual Clear Alarm Exists" bit will be set to 1.
- * The "Alarms Present" (DI 10) will be set to 1 if any alarm is active (or Safety Interlock = 0). This is a register used for
- * testing only, and will be used in Standby and Running States to send to FailState.
- * 
- * This function is used in the update() of the Standby, Running, and Fail States.
- *
-*/ 
-
-void updateAlarms(Equipment<ModbusIP>* equipment){
-    const std::vector<std::string> alarmDescriptions = {
-        "Tank Temp Sensor Fail", "Tank Overtemp", "Input RH Out of Range", "Duct RH Out of Range", 
-        "Water Probe Check", "Water Probe Faulty", "Fill Time Excessive", "Refill Time Excessive", 
-        "Tank Not Draining", "Boil Time Excessive"
-    };
-
-    // update Safety Interlock state (note: Safety Interlock = 0 means the equipment cannot run- fail safe)
-    if (equipment->getModbus_Point("Safety Interlock ON")->getValue() == 1){
-        equipment->setModbus_Point("Safety Interlock", 0);
-    }
-    else equipment->setModbus_Point("Safety Interlock", 1);
-
-    // if "Clear All Active Alarms" bit is 1 --> clear all alarms as well as safety interlock
-    // if "Clear All Active Alarms" bit is 0 --> if any alarms present set "Alarms Present" register to 1
-    if (equipment->getModbus_Point("Clear All Active Alarms")->getValue() == 1){
-        for (int i =0; i < alarmDescriptions.size(); ++i) {
-            equipment->setModbus_Point(alarmDescriptions[i], 0);
-        }
-        equipment->setModbus_Point("Safety Interlock ON", 0);
-        equipment->setModbus_Point("Safety Interlock", 1);
-        equipment->setModbus_Point("Alarms Present", 0);
-        equipment->setModbus_Point("Manual Clear Alarm Exists", 1);  // the only way to set this back to 0 is manually via Modscan
-    }
-    else {
-        int numAlarms = 0;
-        for (int i =0; i < alarmDescriptions.size(); ++i) {
-            Modbus_Point<ModbusIP>* alarmPoint = equipment->getModbus_Point(alarmDescriptions[i]);
-            if (alarmPoint->getValue() == 1) numAlarms++;
-        }
-        if (equipment->getModbus_Point("Safety Interlock")->getValue() == 0) numAlarms++;
-        if (numAlarms >= 1) equipment->setModbus_Point("Alarms Present", 1);
-        else equipment->setModbus_Point("Alarms Present", 0);
-    }
-}
-
-/** 
- * @brief This function is used to update the Airflow Proving Switch state (DI 1)
- * based on the Safety Interlock ON coil (Coil 2) - this is used for testing purposes only.
- * 
- * This function is used in the update() of the Standby, Running, and Fail States.
- *
-*/ 
-
-void updateAirflow(Equipment<ModbusIP>* equipment){
-    if (equipment->getModbus_Point("Airflow ON")->getValue() == 1){
-        equipment->setModbus_Point("Airflow Proving Switch", 1);
-    }
-    else equipment->setModbus_Point("Airflow Proving Switch", 0);
-}
\ No newline at end of file
diff --git a/src/BMS/HUM/HUM_DriSteem_RTS_RX36_TCP/StateUtils.h b/src/BMS/HUM/HUM_DriSteem_RTS_RX36_TCP/StateUtils.h
deleted file mode 100644
index e836ae5..0000000
--- a/src/BMS/HUM/HUM_DriSteem_RTS_RX36_TCP/StateUtils.h
+++ /dev/null
@@ -1,43 +0,0 @@
-/**
- * @file config.h
- * @brief StateUtils class
- * @author Robert J Davis
- * @date 2025-10-28
- *
- * Defines the StateUtils class, which contains utility functions used in multiple States.
- */
-
-#pragma once
-
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-template <typename T>
-class State;
-
-/**
- * @brief Updates all alarms, safety interlock, alarms present register.
- * @param equipment Pointer to the Equipment instance.
- * @return void
- */
-void updateAlarms(Equipment<ModbusIP>* equipment);
-
-/**
- * @brief Updates the Airflow Proving Switch state based on Airflow ON state.
- * @param equipment Pointer to the Equipment instance.
- * @return void
- */
-void updateAirflow(Equipment<ModbusIP>* equipment);
\ No newline at end of file
diff --git a/src/BMS/HUM/HUM_DriSteem_RTS_RX36_TCP/State_Fail.cpp b/src/BMS/HUM/HUM_DriSteem_RTS_RX36_TCP/State_Fail.cpp
deleted file mode 100644
index d9910a0..0000000
--- a/src/BMS/HUM/HUM_DriSteem_RTS_RX36_TCP/State_Fail.cpp
+++ /dev/null
@@ -1,91 +0,0 @@
-/**
- * @file State_Fail.cpp
- * @brief Implementation of the FailState class.
- * @author Robert J Davis
- * @date 2025-10-28
- *
- * This file contains the implementation for the FailState, which defines
- * the behavior of the equipment when it has entered a fault condition.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "StateUtils.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new FailState object with a list of active alarms.
- *
- * This constructor will have the Duct RH fluctuate around 35% (for visualization purposes).
- * 
- * @param activeAlarms A vector of strings, where each string is the
- *                     description of a Modbus point to be set as an active alarm.
- * This parameter is not used in this implementation of the Fail State.
- */
-template<>
-FailState<ModbusIP>::FailState(const std::vector<std::string>& activeAlarms) {
-    addStrategy("Duct RH", new SingleValueStrategy(35.0f, 5.0f, 1000));          
-    addStrategy("Tank Temp", new SingleValueStrategy(80.0f, 1.0f, 3000));           
-}
-
-/**
- * @brief Executes the fail state's logic for one update cycle.
- *
- * Update Alarms states. Stays in FailState until all alarms are cleared --> Standby State.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* FailState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Fail update function");
-
-    updateAlarms(equipment);
-
-    bool alarmsPresent = getPointValue(equipment, "Alarms Present");
-    if (!alarmsPresent){
-        return new StandbyState<ModbusIP>();
-    }
-    
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the fail state.
- * Sets the Run Mode to 3 (system standby), and appropriate analogs to 0.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Fail State...");
-    // Ensure Run Mode set to 3 (standby)
-    setPointValue(equipment, "Run Mode", 3);
-    setPointValue(equipment, "Fill Valve", 0);
-    setPointValue(equipment, "Drain Valve", 0);
-    setPointValue(equipment, "Steam Demand Mass", 0);
-    setPointValue(equipment, "Steam Demand Percent", 0);
-    setPointValue(equipment, "Steam Output Mass", 0);
-    setPointValue(equipment, "Steam Output Percent", 0);
-}
-
-/**
- * @brief Logic to execute once when exiting the fail state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Fail State...");
-}
\ No newline at end of file
diff --git a/src/BMS/HUM/HUM_DriSteem_RTS_RX36_TCP/State_Running.cpp b/src/BMS/HUM/HUM_DriSteem_RTS_RX36_TCP/State_Running.cpp
deleted file mode 100644
index bafc992..0000000
--- a/src/BMS/HUM/HUM_DriSteem_RTS_RX36_TCP/State_Running.cpp
+++ /dev/null
@@ -1,123 +0,0 @@
-/**
- * @file State_Running.cpp
- * @brief Implementation of the RunningState class.
- * @author Robert J Davis
- * @date 2025-10-28
- *
- * This file contains the implementation for the RunningState, which defines
- * the behavior of the equipment when it is actively running.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "Strategies/Strategy_Totalizer.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include "StateUtils.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new RunningState object.
- *
- * This constructor initializes behavior strategies active during the running
- * state including various analog values. Fill and Drain Valves switch between 0 and 1.
- * Water Until ADS/Service will ramp down to 0, initialized at 1500 and 10000, respectively.
- */
-template<>
-RunningState<ModbusIP>::RunningState() {
-    addStrategy("Duct RH", new RampStrategy(40.0f, 1.0f, 2000));
-
-    addStrategy("Fill Valve", new SquareStrategy(1.0f, 0.0f, 5000));
-    addStrategy("Drain Valve", new SquareStrategy(0.0f, 1.0f, 4500));
-
-    addStrategy("Steam Demand Mass", new SawStrategy(3.0f, 6.0f, 1.0f, 2000));      // these values are semi-random for visualization
-    addStrategy("Steam Demand Percent", new SawStrategy(50.0f, 80.0f, 5.0f, 1000)); // these values are semi-random for visualization
-    addStrategy("Tank Temp", new SingleValueStrategy(80.0f, 3.0f, 1000));           // these values are semi-random for visualization
-    addStrategy("Steam Output Mass", new SingleValueStrategy(4.0f, 1.0f, 1000));    // these values are semi-random for visualization
-    addStrategy("Steam Output Percent", new SingleValueStrategy(65.0f, 10.0f, 1000));   // these values are semi-random for visualization
-    addStrategy("Water Until ADS", new RampStrategy(0.0f, 1.0f, 2000));             // ramping down to 0 from 1500
-    addStrategy("Water Until Service", new RampStrategy(0.0f, 1.0f, 2000));         // ramping down to 0 from 10000
-}
-
-/**
- * @brief Executes the running state's logic for one update cycle.
- * 
- * This method first checks if there are any active alarms --> FailState.
- * Also updates Airflow state according to Airflow ON (Coil 1- for testing use only).
- * If no alarms are active, checks for loss of airflow or "Run Mode" = 3 (Modscan, but will be from PLC) 
- * to transition to the Standby state. If no transition is triggered, it updates the
- * rampStrategy targetValue of the Duct RH to dynamically ramp up to the Space RH Setpoint (sent from PLC).
- * 
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* RunningState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // Update alarms states and airflow switch state
-    updateAlarms(equipment);
-    updateAirflow(equipment);
-
-    // if Alarms are present (as updated in updateAlarms function) --> FailState
-    bool alarmsPresent = getPointValue(equipment, "Alarms Present");
-    if (alarmsPresent){
-        std::vector<std::string> activeAlarmsDesc = {}; // sending a blank string to FailState, b/c that parameter not used in FailState implementation.
-        return new FailState<ModbusIP>(activeAlarmsDesc);
-    }
-
-    // Check for Run Mode and Airflow. If Run Mode = 3 OR Airflow stopped --> StandbyState
-    int runMode_Command = getPointValue(equipment, "Run Mode");    // Set by PLC
-    int airflow = getPointValue(equipment, "Airflow Proving Switch"); 
-    if (runMode_Command == 3 || airflow == 0) {
-        return new StandbyState<ModbusIP>();
-    }
-
-    // Set the Duct RH ramp target value equal to the Space RH Setpoint
-    float Space_RH_Setpoint = getPointValue(equipment, "Space RH Setpoint");
-    float ductRH = getPointValue(equipment, "Duct RH");
-    Strategy_Behavior* DuctRH_strat = getStrategy("Duct RH");
-    if (DuctRH_strat){
-        static_cast<RampStrategy*>(DuctRH_strat)->setTarget(Space_RH_Setpoint);      
-    }
-
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the running state.
- * 
- * Note: do not need to set Run Mode = 1 (auto) since that is required to 
- * send the unit to Run Mode in the first place. Run Mode will already = 1.
- * 
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Running State...");
-}
-
-/**
- * @brief Logic to execute once when exiting the running state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Running State...");
-}
\ No newline at end of file
diff --git a/src/BMS/HUM/HUM_DriSteem_RTS_RX36_TCP/State_Standby.cpp b/src/BMS/HUM/HUM_DriSteem_RTS_RX36_TCP/State_Standby.cpp
deleted file mode 100644
index d47cd2d..0000000
--- a/src/BMS/HUM/HUM_DriSteem_RTS_RX36_TCP/State_Standby.cpp
+++ /dev/null
@@ -1,110 +0,0 @@
-/**
- * @file State_Standby.cpp
- * @brief Implementation of the StandbyState class.
- * @author Robert J Davis
- * @date 2025-10-28
- *
- * This file contains the implementation for the StandbyState, which defines
- * the behavior of the equipment when it is in an idle or standby mode.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include "StateUtils.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-/**
- * @brief Constructs a new StandbyState object.
- *
- * In this state, the equipment is idle. This constructor will have
- * Duct RH fluctuate around 35% for visualization purposes only.
- * 
- */
-template<>
-StandbyState<ModbusIP>::StandbyState() {
-    addStrategy("Duct RH", new SingleValueStrategy(35.0f, 5.0f, 1000));       
-    addStrategy("Tank Temp", new SingleValueStrategy(80.0f, 1.0f, 3000));              
-}
-
-/**
- * @brief Executes the standby state's logic for one update cycle.
- *
- * This method first checks for state transition commands:
- * 1. Updates Alarm states
- * 2. Updates Airflow Switch state (based on Airflow ON command - used just for simulation purposes)
- * If any Alarms are active or Safety Interlock = 0, send to FailState.
- * 
- * 3. Check if Run Mode = 1 and Airflow Switch = 1, then send to Running State.
- *
- * If no transition occurs, it applies the strategies defined for the standby state.
- *
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* StandbyState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Standby update function");
-
-    updateAlarms(equipment);
-    updateAirflow(equipment);
-
-    // if Alarms are present (as updated in updateAlarms function) --> FailState
-    bool alarmsPresent = getPointValue(equipment, "Alarms Present");
-    if (alarmsPresent){
-        std::vector<std::string> activeAlarmsDesc = {}; // sending a blank string to FailState, b/c that parameter not used in FailState implementation.
-        return new FailState<ModbusIP>(activeAlarmsDesc);
-    }
-
-    // Check for Run Mode and Airflow Proving Switch. If Run Mode = 1 and there is Airflow --> RunningState
-    int runMode_Command = getPointValue(equipment, "Run Mode");    // Set by PLC
-    int airflow = getPointValue(equipment, "Airflow Proving Switch");   
-    if (airflow == 1 && runMode_Command == 1) {
-        return new RunningState<ModbusIP>();
-    }
-
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the standby state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    Serial.println("Enter Standby State...");
-    // Set Run Mode to 3 (standby), just in case entered Standby on loss of airflow
-    setPointValue(equipment, "Run Mode", 3);
-    setPointValue(equipment, "Fill Valve", 0);
-    setPointValue(equipment, "Drain Valve", 0);
-    setPointValue(equipment, "Steam Demand Mass", 0);
-    setPointValue(equipment, "Steam Demand Percent", 0);
-    setPointValue(equipment, "Steam Output Mass", 0);
-    setPointValue(equipment, "Steam Output Percent", 0);
-}
-
-/**
- * @brief Logic to execute once when exiting the standby state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Standby State...");
-}
\ No newline at end of file
diff --git a/src/BMS/HUM/HUM_DriSteem_RTS_RX36_TCP/config.h b/src/BMS/HUM/HUM_DriSteem_RTS_RX36_TCP/config.h
deleted file mode 100644
index b78c910..0000000
--- a/src/BMS/HUM/HUM_DriSteem_RTS_RX36_TCP/config.h
+++ /dev/null
@@ -1,108 +0,0 @@
-/**
- * @file config.h
- * @brief Main configuration file for the DriSteem Humidifier (TCP) emulator.
- * @author Robert J Davis
- * @date 2025-10-27
- *
- * This file contains two important configurations: WiFi network parameters
- * and the Modbus register map for the device.
- */
-
-#ifndef CONFIG_H
-#define CONFIG_H
-
-#include "core.h"
-#include "Equipment/Equipment.h"
-
-#if defined(USE_MODBUS_IP)
-/**
-   * @defgroup ModbusTCPConfig Modbus IP Configuration
-   * @brief Parameters for Modbus TCP communication.
-   * @{
-   */
-  #include <ModbusIP_ESP8266.h>
-  const char *ssid = "ArduinoWifiB";          /**< @brief The SSID of the WiFi network. */
-  const char *password = "123abc456";          /**< @brief The password for the WiFi network. */
-  IPAddress local_IP(172, 17, 32, 68);       /**< @brief The static IP address for the device. */
-  IPAddress gateway(172, 17, 32, 1);          /**< @brief The gateway IP address. */
-  IPAddress subnet(255, 255, 255, 0);         /**< @brief The subnet mask. */
-  
-  ModbusIP mb;
-#else
-  /**
-   * @defgroup ModbusRTUConfig Modbus RTU Configuration
-   * @brief Parameters for serial Modbus RTU communication.
-   * @{
-   */
-  #include <ModbusRTU.h>
-  const int BAUDRATE = 19200;   /**< @brief The serial communication speed in bits per second. */
-  const int RX_PIN = 17;        /**< @brief The GPIO pin used for receiving data (RX). */
-  const int TX_PIN = 16;        /**< @brief The GPIO pin used for transmitting data (TX). */
-  const int RST_PIN = 4;        /**< @brief The GPIO pin connected to the RS485 driver's DE/RE pins for direction control. */
-  const int MODBUS_ID = 1;      /**< @brief The unique slave ID for this device on the Modbus bus. */
-  /** @} */
-
-  /** @brief Global instance of the Modbus RTU server. */
-  ModbusRTU mb;
-#endif
-
-/**
- * @defgroup ModbusMapConfig Modbus Map Configuration
- * @brief Defines the Modbus register map and related parameters for the emulator.
- * @{
- */
-/**
- * @brief The Modbus map for the Equipment device.
- * This array defines all the Modbus points available on the emulated device.
- * The `description` field is crucial as it's used to look up points within the application logic.
- */
-modbusMap mb_map[] =
-{   
-  {COIL,      0,      0,      "Airflow ON"},                           // Used for Modscan testing only to set Airflow Proving Switch
-  {COIL,      1,      0,      "Safety Interlock ON"},                  // Used for Modscan testing only to trip Safety Interlock
-  {COIL,      2,      0,      "Manual Clear Alarm Exists"},              
-  {COIL,      3,      0,      "Clear All Active Alarms"},              // OCmd_Reset
-  {COIL,      4,      0,      "Tank Temp Sensor Fail"},              
-  {COIL,      5,      0,      "Tank Overtemp"},              
-  {COIL,      6,      0,      "Input RH Out of Range"},              
-  {COIL,      7,      0,      "Duct RH Out of Range"},              
-  {COIL,      9,      0,      "Water Probe Check"},             
-  {COIL,      10,     0,      "Water Probe Faulty"},              
-  {COIL,      11,     0,      "Fill Time Excessive"},              
-  {COIL,      12,     0,      "Refill Time Excessive"},              
-  {COIL,      13,     0,      "Tank Not Draining"},              
-  {COIL,      14,     0,      "Boil Time Excessive"},              
-
-  {DI,        0,      0,      "Airflow Proving Switch"},                // 0:open, 1:closed
-  {DI,        2,      1,      "Safety Interlock"},                      // 0:open, 1:closed
-  {DI,        7,      0,      "Fill Valve"},                            // 0:closed, 1:open
-  {DI,        8,      0,      "Drain Valve"},                           // 0:not draining, 1:draining
-  {DI,        9,      0,      "Alarms Present"},                        // Used for Modscan testing only - not part of vendor Modbus table
-
-  {IR,        0,      0,      "Space RH"},                              // Relative_Humidity  --> NOT USED, sensor not connected to HUM
-  {IR,        2,      0,      "Duct RH"},                               // OSet_CV
-  {IR,        3,      0,      "Steam Demand Mass"},
-  {IR,        4,      0,      "Steam Demand Percent"},
-  {IR,        6,      0,      "Tank Temp"},
-  {IR,        7,      0,      "Steam Output Mass"},
-  {IR,        8,      0,      "Steam Output Percent"},
-  {IR_10x,    9,      1500,    "Water Until ADS"},                       // 1 = 100 lbs (I know this is 10x function only)
-  {IR_10x,    10,     10000,   "Water Until Service"},                   // 1 = 100 lbs (I know this is 10x function only)
-
-  {HR,        0,      3,      "Run Mode"},                               // Operation_Mode, 1:auto, 2:local standby, 3:system standby, 4:manual drain
-  {HR,        1,      0,      "Space RH Setpoint"},                     // Relative_Humidity_SP
-  {HR,        3,      85,     "Duct High Limit Setpoint"},              
-}; 
-//Size of modbus map used in FOR cycles, automatically calculated.
-
-/**
- * @brief The total number of entries in the `mb_map` array.
- * This is calculated at compile time and used for iterating over the map.
- */
-const int map_size = sizeof(mb_map) / sizeof(mb_map[0]);
-
-/** @brief The main loop update interval in milliseconds. */
-int interval = 250; 
-/** @} */ // End of ModbusMapConfig group
-
-#endif // CONFIG_H
\ No newline at end of file
diff --git a/src/BMS/HUM/HUM_DriSteem_RTS_RX36_TCP/main.cpp b/src/BMS/HUM/HUM_DriSteem_RTS_RX36_TCP/main.cpp
deleted file mode 100644
index a38c2d0..0000000
--- a/src/BMS/HUM/HUM_DriSteem_RTS_RX36_TCP/main.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-/**
- * @file main.cpp
- * @brief Main execution program for the DriSteem Humidifier (TCP) Emulator.
- * @author Emmanuel Hernandez Cruz, Robert J Davis
- * @date 2025-09-02
- *
- * @details This file contains the main execution program for an Arduino-based emulator of the DriSteem Humidifier unit. 
- * The program uses a Wi-Fi connection to communicate via the Modbus IP protocol.
- *
- * The setup() function initializes the following:
- * - Serial communication for debugging.
- * - Wi-Fi connection using credentials from config.h.
- * - A Modbus TCP server.
- * - Modbus points (Coils, Holding Registers, etc.) based on a predefined map in config.h.
- *
- * The loop() function continuously:
- * - Services the Modbus TCP server to handle incoming requests.
- * - Periodically calls the main update loop for the emulated equipment, which
- *   manages state transitions and behavior strategies.
- *
- * @see config.h for Wi-Fi and Modbus configuration.
- * @see Equipment.h for the main equipment logic.
- * @see State.h for different equipment states.
- * @see Strategies/Strategy_Behavior.h for value generation strategies.
- * @see Modbus_Point.h for the base class for all Modbus points.
- */
-//=================================================================================================================================
-//Libraries and declaration of variables.
-#include <WiFi.h>
-#include "config.h"
-#include "ModbusPoints/Modbus_PointFactory.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-//=================================================================================================================================
-/** 
- * @brief Initializes the application.
- * @details This function runs once at startup. It configures the serial communication, 
- * Wi-Fi, and the Modbus server. It also creates and initializes all the Modbus points 
- * based on the `mb_map` array in `config.h`.
- */
-void setup() {
-  Serial.begin(115200);                       //Serial comm start
-  WiFi.config(local_IP, gateway, subnet);     // Wifi service start
-  WiFi.begin(ssid, password);
-  while (WiFi.status() != WL_CONNECTED) {
-    delay(1000);
-    Serial.print(".");
-  }
-  Serial.println("Connected!!");
-  mb.server();                                //Modbus server start
-  Serial.println("Server Created");
-  Serial.println(map_size);
-  for(int i = 0; i < map_size; i++){
-    Modbus_Point<ModbusIP>* point = createModbus_Point(&mb, mb_map[i].category, mb_map[i].address, mb_map[i].value, mb_map[i].description);
-    if (point) {
-      point->addToModbusServer();
-      EquipmentInstance.addModbus_Point(mb_map[i].description, point);
-    }
-  }
-  Serial.println("All modbus Points created");
-  Serial.println("Setup function ended");
-}
-//=================================================================================================================================
-/** 
- * @brief The main application loop.
- * @details This function runs repeatedly after setup() has completed. It performs two main actions:
- * 1. It continuously services the Modbus server by calling `mb.task()` to handle
- *    incoming requests from a Modbus master.
- * 2. At a fixed interval (defined in `config.h`), it calls `EquipmentInstance.update()`
- *    to run the emulator's internal state machine and behavior logic.
- */
-void loop() {
-  mb.task();
-  unsigned long currentMillis = millis();
-  if (currentMillis - previousMillis >= interval) {
-    previousMillis = currentMillis;
-    unsigned long startTime = millis();
-    EquipmentInstance.update();
-    unsigned long endTime = millis();
-    unsigned long elapsedTime = endTime - startTime;
-    Serial.printf("Control Execution time: %d ms\n", elapsedTime);
-  } 
-}
diff --git a/src/BMS/HUM/HUM_Munters_HM3_TCP/README.md b/src/BMS/HUM/HUM_Munters_HM3_TCP/README.md
deleted file mode 100644
index 355156f..0000000
--- a/src/BMS/HUM/HUM_Munters_HM3_TCP/README.md
+++ /dev/null
@@ -1,33 +0,0 @@
-# EQUIPMENT_TYPE MANUFACTURER MODEL TCP
-
-## Brief Introduction
-Equipment specifc details that make it different from other devices
-
-## List of Equipmentt
-This cofiguration has been used for these models:
-* **Model**: 09-15-22 
-* **Model**: 09-15-23 
-* **Model**: 09-15-25 
-
-## Hardware Prerequisites
-
-The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities.
-* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html) 
-
----
-
-## States and Strategies
-Provide a brief description of what variables and strategies were used in this configuraiton
-
-### Standby State
-* **Equipment running**: set to 0
-* **Common Alarm**: set to 0
-* **SAT temperature**: set to 85
-
-### Running State
-* **Equipment running**: set to 1
-* **SAT temperature**: **Ramp Strategy** set to 65 deg setpoint
-
-### Fail State
-* **Commong Alarm**: set to 1
-* **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset
diff --git a/src/BMS/HUM/HUM_Munters_HM3_TCP/State_Fail.cpp b/src/BMS/HUM/HUM_Munters_HM3_TCP/State_Fail.cpp
deleted file mode 100644
index 8bc0385..0000000
--- a/src/BMS/HUM/HUM_Munters_HM3_TCP/State_Fail.cpp
+++ /dev/null
@@ -1,81 +0,0 @@
-/**
- * @file State_Fail.cpp
- * @brief Implementation of the FailState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the FailState, which defines
- * the behavior of the equipment when it has entered a fault condition.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new FailState object with a list of active alarms.
- *
- * This constructor receives a list of alarm descriptions and creates strategies
- * to set the corresponding Modbus points to a value of 1, indicating an
- * active alarm. It also initializes a PID strategy for the 'CW Valve Position'
- * to maintain its state during the fault.
- * @param activeAlarms A vector of strings, where each string is the
- *                     description of a Modbus point to be set as an active alarm.
- */
-template<>
-FailState<ModbusIP>::FailState(const std::vector<std::string>& activeAlarms) {
-    // Simulate a failure: set common alarm and a specific fan alarm.
-
-    
-}
-
-/**
- * @brief Executes the fail state's logic for one update cycle.
- *
- * This method checks the "Alarm Reset" Modbus point for a command to
- * transition back to Standby, which would typically happen after a fault
- * is cleared by a user. If no transition is requested, it continues to apply
- * the failure strategies (e.g., keeping alarm bits active).
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* FailState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Fail update function");
-    
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the fail state.
- * Sets the "Alarm Common" point to 1 to indicate a general fault condition.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Fail State...");
-}
-
-/**
- * @brief Logic to execute once when exiting the fail state.
- * Clears the "Alarm Common" point to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Fail State...");
-}
\ No newline at end of file
diff --git a/src/BMS/HUM/HUM_Munters_HM3_TCP/State_Running.cpp b/src/BMS/HUM/HUM_Munters_HM3_TCP/State_Running.cpp
deleted file mode 100644
index b9e4a99..0000000
--- a/src/BMS/HUM/HUM_Munters_HM3_TCP/State_Running.cpp
+++ /dev/null
@@ -1,89 +0,0 @@
-/**
- * @file State_Running.cpp
- * @brief Implementation of the RunningState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the RunningState, which defines
- * the behavior of the equipment when it is actively running.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "Strategies/Strategy_Totalizer.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new RunningState object.
- *
- * This constructor initializes behavior strategies active during the running
- * state, such as a PID controller for the 'CW Valve Position' and totalizers
- * for the run-hours of each EC fan.
- */
-template<>
-RunningState<ModbusIP>::RunningState() {
-}
-
-/**
- * @brief Executes the running state's logic for one update cycle.
- *
- * This method first checks for state transition commands:
- * 1. It reads the "ON/OFF Command By BMS" point. If it's 0, it transitions to StandbyState.
- * 2. It reads the "Fault Code" point. If it's non-zero, it transitions to FailState,
- *    passing the corresponding alarm description.
- *
- * If no transition occurs, it applies the strategies defined for the running state.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* RunningState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Running update function");
-    
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the running state.
- * Sets the "Run Status" for all EC fans to 1 to indicate they are active.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Running State...");
-    // You could also update a Modbus register to show the "standby" state
-
-}
-
-/**
- * @brief Logic to execute once when exiting the running state.
- * Sets the "Run Status" for all EC fans to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Running State...");
-   
-}
\ No newline at end of file
diff --git a/src/BMS/HUM/HUM_Munters_HM3_TCP/State_Standby.cpp b/src/BMS/HUM/HUM_Munters_HM3_TCP/State_Standby.cpp
deleted file mode 100644
index 20029d1..0000000
--- a/src/BMS/HUM/HUM_Munters_HM3_TCP/State_Standby.cpp
+++ /dev/null
@@ -1,85 +0,0 @@
-/**
- * @file State_Standby.cpp
- * @brief Implementation of the StandbyState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the StandbyState, which defines
- * the behavior of the equipment when it is in an idle or standby mode.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-/**
- * @brief Constructs a new StandbyState object.
- *
- * In this state, the equipment is idle. This constructor initializes strategies
- * to bring the system to a safe, idle condition. It sets a stable value for
- * the SAT reading and creates ramp strategies to bring the CW valve and all
- * EC fan speeds down to zero.
- */
-template<>
-StandbyState<ModbusIP>::StandbyState() {
-    // You can add initialization code here if needed
-    
-
-}
-
-/**
- * @brief Executes the standby state's logic for one update cycle.
- *
- * This method applies the strategies defined for the standby state (e.g.,
- * ramping values to zero).
- *
- * @warning This method currently does not check for a command to transition to the
- *          Running state. This logic needs to be added to allow the unit to start.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* StandbyState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Standby update function");
-    
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the standby state.
- * This method performs cleanup by setting all alarm points and all EC fan
- * run status points to 0.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Standby State...");
-}
-
-/**
- * @brief Logic to execute once when exiting the standby state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Standby State...");
-}
\ No newline at end of file
diff --git a/src/BMS/HUM/HUM_Munters_HM3_TCP/config.h b/src/BMS/HUM/HUM_Munters_HM3_TCP/config.h
deleted file mode 100644
index cf47221..0000000
--- a/src/BMS/HUM/HUM_Munters_HM3_TCP/config.h
+++ /dev/null
@@ -1,84 +0,0 @@
-/**
- * @file config.h
- * @brief Main configuration file for the Humidifier Munters HM3
- * @author Zach Gutierrez
- * @date 2025-09-02
- *
- * This file contains two important configurations: WiFi network parameters
- * and the Modbus register map for the device.
- */
-
-#ifndef CONFIG_H
-#define CONFIG_H
-
-#include "core.h"
-#include "Equipment/Equipment.h"
-
-#if defined(USE_MODBUS_IP)
-/**
-   * @defgroup ModbusTCPConfig Modbus IP Configuration
-   * @brief Parameters for Modbus TCP communication.
-   * @{
-   */
-  #include <ModbusIP_ESP8266.h>
-  const char *ssid = "wifi_name";       /**< @brief The SSID of the WiFi network. */
-  const char *password = "wifi_password";   /**< @brief The password for the WiFi network. */
-  IPAddress local_IP(172, 17, 22, 172);       /**< @brief The static IP address for the device. */
-  IPAddress gateway(172, 17, 22, 1);          /**< @brief The gateway IP address. */
-  IPAddress subnet(255, 255, 255, 0);         /**< @brief The subnet mask. */
-  
-  ModbusIP mb;
-#else
-  /**
-   * @defgroup ModbusRTUConfig Modbus RTU Configuration
-   * @brief Parameters for serial Modbus RTU communication.
-   * @{
-   */
-  #include <ModbusRTU.h>
-  const int BAUDRATE = 19200;   /**< @brief The serial communication speed in bits per second. */
-  const int RX_PIN = 17;        /**< @brief The GPIO pin used for receiving data (RX). */
-  const int TX_PIN = 16;        /**< @brief The GPIO pin used for transmitting data (TX). */
-  const int RST_PIN = 4;        /**< @brief The GPIO pin connected to the RS485 driver's DE/RE pins for direction control. */
-  const int MODBUS_ID = 1;      /**< @brief The unique slave ID for this device on the Modbus bus. */
-  /** @} */
-
-  /** @brief Global instance of the Modbus RTU server. */
-  ModbusRTU mb;
-#endif
-
-
-
-/**
- * @defgroup ModbusMapConfig Modbus Map Configuration
- * @brief Defines the Modbus register map and related parameters for the emulator.
- * @{
- */
-/**
- * @brief The Modbus map for the Equipment device.
- * This array defines all the Modbus points available on the emulated device.
- * The `description` field is crucial as it's used to look up points within the application logic.
- */
-modbusMap mb_map[] = {
-
-  // DISCRETE ALARMS (COILS - 1x)
-  // 00000
-  {HR, 0, 0, "Unit Status" },
-  {HR, 1, 0, "Air Temp SP" },
-  {HR, 2, 0, "Space Temp" },
-  {HR, 3, 0, "System Mode" },
-  {HR, 4, 0, "Fan Speed" },
-
-};
-//Size of modbus map used in FOR cycles, automatically calculated.
-
-/**
- * @brief The total number of entries in the `mb_map` array.
- * This is calculated at compile time and used for iterating over the map.
- */
-const int map_size = sizeof(mb_map) / sizeof(mb_map[0]);
-
-/** @brief The main loop update interval in milliseconds. */
-int interval = 250; 
-/** @} */ // End of ModbusMapConfig group
-
-#endif // CONFIG_H
diff --git a/src/BMS/HUM/HUM_Munters_HM3_TCP/main.cpp b/src/BMS/HUM/HUM_Munters_HM3_TCP/main.cpp
deleted file mode 100644
index 286a98c..0000000
--- a/src/BMS/HUM/HUM_Munters_HM3_TCP/main.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-/**
- * @file main.cpp
- * @brief Main execution program for the CRAH Unit (TCP) Emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * @details This file contains the main execution program for an Arduino-based emulator of a CRAH unit. 
- * The program uses a Wi-Fi connection to communicate via the Modbus IP protocol.
- *
- * The setup() function initializes the following:
- * - Serial communication for debugging.
- * - Wi-Fi connection using credentials from config.h.
- * - A Modbus TCP server.
- * - Modbus points (Coils, Holding Registers, etc.) based on a predefined map in config.h.
- *
- * The loop() function continuously:
- * - Services the Modbus TCP server to handle incoming requests.
- * - Periodically calls the main update loop for the emulated equipment, which
- *   manages state transitions and behavior strategies.
- *
- * @see config.h for Wi-Fi and Modbus configuration.
- * @see Equipment.h for the main equipment logic.
- * @see State.h for different equipment states.
- * @see Strategies/Strategy_Behavior.h for value generation strategies.
- * @see Modbus_Point.h for the base class for all Modbus points.
- */
-//=================================================================================================================================
-//Libraries and declaration of variables.
-#include <WiFi.h>
-#include "config.h"
-#include "ModbusPoints/Modbus_PointFactory.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-//=================================================================================================================================
-/** 
- * @brief Initializes the application.
- * @details This function runs once at startup. It configures the serial communication, 
- * Wi-Fi, and the Modbus server. It also creates and initializes all the Modbus points 
- * based on the `mb_map` array in `config.h`.
- */
-void setup() {
-  Serial.begin(115200);                       //Serial comm start
-  WiFi.config(local_IP, gateway, subnet);     // Wifi service start
-  WiFi.begin(ssid, password);
-  while (WiFi.status() != WL_CONNECTED) {
-    delay(1000);
-    Serial.print(".");
-  }
-  Serial.println("Connected!!");
-  mb.server();                                //Modbus server start
-  Serial.println("Server Created");
-  Serial.println(map_size);
-  for(int i = 0; i < map_size; i++){
-    Modbus_Point<ModbusIP>* point = createModbus_Point(&mb, mb_map[i].category, mb_map[i].address, mb_map[i].value, mb_map[i].description);
-    if (point) {
-      point->addToModbusServer();
-      EquipmentInstance.addModbus_Point(mb_map[i].description, point);
-    }
-  }
-  Serial.println("All modbus Points created");
-  Serial.println("Setup function ended");
-}
-//=================================================================================================================================
-/** 
- * @brief The main application loop.
- * @details This function runs repeatedly after setup() has completed. It performs two main actions:
- * 1. It continuously services the Modbus server by calling `mb.task()` to handle
- *    incoming requests from a Modbus master.
- * 2. At a fixed interval (defined in `config.h`), it calls `EquipmentInstance.update()`
- *    to run the emulator's internal state machine and behavior logic.
- */
-void loop() {
-  mb.task();
-  unsigned long currentMillis = millis();
-  if (currentMillis - previousMillis >= interval) {
-    previousMillis = currentMillis;
-    unsigned long startTime = millis();
-    EquipmentInstance.update();
-    unsigned long endTime = millis();
-    unsigned long elapsedTime = endTime - startTime;
-    Serial.printf("Control Execution time: %d ms\n", elapsedTime);
-  } 
-}
diff --git a/src/BMS/HUM/HUM_NEPTRONICS_SKE4_TCP/README.md b/src/BMS/HUM/HUM_NEPTRONICS_SKE4_TCP/README.md
deleted file mode 100644
index 355156f..0000000
--- a/src/BMS/HUM/HUM_NEPTRONICS_SKE4_TCP/README.md
+++ /dev/null
@@ -1,33 +0,0 @@
-# EQUIPMENT_TYPE MANUFACTURER MODEL TCP
-
-## Brief Introduction
-Equipment specifc details that make it different from other devices
-
-## List of Equipmentt
-This cofiguration has been used for these models:
-* **Model**: 09-15-22 
-* **Model**: 09-15-23 
-* **Model**: 09-15-25 
-
-## Hardware Prerequisites
-
-The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities.
-* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html) 
-
----
-
-## States and Strategies
-Provide a brief description of what variables and strategies were used in this configuraiton
-
-### Standby State
-* **Equipment running**: set to 0
-* **Common Alarm**: set to 0
-* **SAT temperature**: set to 85
-
-### Running State
-* **Equipment running**: set to 1
-* **SAT temperature**: **Ramp Strategy** set to 65 deg setpoint
-
-### Fail State
-* **Commong Alarm**: set to 1
-* **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset
diff --git a/src/BMS/HUM/HUM_NEPTRONICS_SKE4_TCP/State_Fail.cpp b/src/BMS/HUM/HUM_NEPTRONICS_SKE4_TCP/State_Fail.cpp
deleted file mode 100644
index 046bf00..0000000
--- a/src/BMS/HUM/HUM_NEPTRONICS_SKE4_TCP/State_Fail.cpp
+++ /dev/null
@@ -1,92 +0,0 @@
-/**
- * @file State_Fail.cpp
- * @brief Implementation of the FailState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the FailState, which defines
- * the behavior of the equipment when it has entered a fault condition.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new FailState object with a list of active alarms.
- *
- * This constructor receives a list of alarm descriptions and creates strategies
- * to set the corresponding Modbus points to a value of 1, indicating an
- * active alarm. It also initializes a PID strategy for the 'CW Valve Position'
- * to maintain its state during the fault.
- * @param activeAlarms A vector of strings, where each string is the
- *                     description of a Modbus point to be set as an active alarm.
- */
-template<>
-FailState<ModbusIP>::FailState(const std::vector<std::string>& activeAlarms) {
-    // Simulate a failure: set common alarm and a specific fan alarm.
-
-    for (const auto& alarmName : activeAlarms){
-        addStrategy(alarmName, new SingleValueStrategy(1.0f, 0.0f, 1000));
-    }
-    addStrategy("CW Valve Position", new PIDStrategy("RAT Setpoint", 1000, "RAT"));
-}
-
-/**
- * @brief Executes the fail state's logic for one update cycle.
- *
- * This method checks the "Alarm Reset" Modbus point for a command to
- * transition back to Standby, which would typically happen after a fault
- * is cleared by a user. If no transition is requested, it continues to apply
- * the failure strategies (e.g., keeping alarm bits active).
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* FailState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Fail update function");
-    Modbus_Point<ModbusIP>* alarmReset = equipment->getModbus_Point("Alarm Reset");
-    int nextStateId = alarmReset ? alarmReset->getValue() : 0;
-    if (nextStateId == 1){
-        return new StandbyState<ModbusIP>();
-    }
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the fail state.
- * Sets the "Alarm Common" point to 1 to indicate a general fault condition.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Fail State...");
-    Modbus_Point<ModbusIP>* alarm_common = equipment->getModbus_Point("Alarm Common");
-    alarm_common->setValue(1);
-}
-
-/**
- * @brief Logic to execute once when exiting the fail state.
- * Clears the "Alarm Common" point to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Fail State...");
-    Modbus_Point<ModbusIP>* alarm_common = equipment->getModbus_Point("Alarm Common");
-    alarm_common->setValue(0);
-}
\ No newline at end of file
diff --git a/src/BMS/HUM/HUM_NEPTRONICS_SKE4_TCP/State_Running.cpp b/src/BMS/HUM/HUM_NEPTRONICS_SKE4_TCP/State_Running.cpp
deleted file mode 100644
index b0f5399..0000000
--- a/src/BMS/HUM/HUM_NEPTRONICS_SKE4_TCP/State_Running.cpp
+++ /dev/null
@@ -1,187 +0,0 @@
-/**
- * @file State_Running.cpp
- * @brief Implementation of the RunningState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the RunningState, which defines
- * the behavior of the equipment when it is actively running.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "Strategies/Strategy_Totalizer.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new RunningState object.
- *
- * This constructor initializes behavior strategies active during the running
- * state, such as a PID controller for the 'CW Valve Position' and totalizers
- * for the run-hours of each EC fan.
- */
-template<>
-RunningState<ModbusIP>::RunningState() {
-    addStrategy("CW Valve Position", new PIDStrategy("RAT Setpoint", 1000, "RAT"));
-    addStrategy("Operating Hours EC Fan #1", new TotalizerStrategy(10000));
-    addStrategy("Operating Hours EC Fan #2", new TotalizerStrategy(10000));
-    addStrategy("Operating Hours EC Fan #3", new TotalizerStrategy(10000));
-    addStrategy("Operating Hours EC Fan #4", new TotalizerStrategy(10000));
-    addStrategy("Operating Hours EC Fan #5", new TotalizerStrategy(10000));
-    addStrategy("Operating Hours EC Fan #6", new TotalizerStrategy(10000));
-    addStrategy("Operating Hours EC Fan #7", new TotalizerStrategy(10000));
-    addStrategy("Operating Hours EC Fan #8", new TotalizerStrategy(10000));
-    addStrategy("Operating Hours EC Fan #9", new TotalizerStrategy(10000));
-}
-
-/**
- * @brief Executes the running state's logic for one update cycle.
- *
- * This method first checks for state transition commands:
- * 1. It reads the "ON/OFF Command By BMS" point. If it's 0, it transitions to StandbyState.
- * 2. It reads the "Fault Code" point. If it's non-zero, it transitions to FailState,
- *    passing the corresponding alarm description.
- *
- * If no transition occurs, it applies the strategies defined for the running state.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* RunningState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Running update function");
-    Modbus_Point<ModbusIP>* On_Off_Command = equipment->getModbus_Point("ON/OFF Command By BMS");
-    int nextStateId = On_Off_Command ? On_Off_Command->getValue() : 0;
-    Serial.println(nextStateId);
-    if (nextStateId == 0){
-        return new StandbyState<ModbusIP>();
-    }
-
-    Modbus_Point<ModbusIP>* faultCode = equipment->getModbus_Point("Fault Code");
-    int faultCodeValue = faultCode ? faultCode->getValue() : 0;
-    switch (faultCodeValue){
-        case 1:
-            return new FailState<ModbusIP>({"Alarm SAT Sensor Fault"});
-        case 2:
-            return new FailState<ModbusIP>({"Alarm RAH Sensor Fault"});
-        case 3:
-            return new FailState<ModbusIP>({"Alarm RAT Sensor Fault"}); 
-        case 4:
-            return new FailState<ModbusIP>({"Alarm Filter DP Sensor Fault"});
-        case 5:
-            return new FailState<ModbusIP>({"Alarm Flooding"});
-        case 6:
-            return new FailState<ModbusIP>({"Alarm Dirty Filter"});
-        case 7:
-            return new FailState<ModbusIP>({"Alarm High RAT"});
-        case 8:
-            return new FailState<ModbusIP>({"Alarm Low RAT"});
-        case 9:
-            return new FailState<ModbusIP>({"Alarm High SAT"});
-        case 10:
-            return new FailState<ModbusIP>({"Alarm Low SAT"});
-        case 11:
-            return new FailState<ModbusIP>({"Alarm High RAH"});
-        case 12:
-            return new FailState<ModbusIP>({"Alarm Low RAH"});
-        case 13:
-            return new FailState<ModbusIP>({"Alarm Phase Failure"});
-        case 14:
-            return new FailState<ModbusIP>({"Alarm Condensate Pump"});
-        case 15:
-            return new FailState<ModbusIP>({"Alarm Smoke"});
-        case 16:
-            return new FailState<ModbusIP>({"Alarm Fire"});
-        case 17:
-            return new FailState<ModbusIP>({"Alarm EC Fan #1"});
-        case 18:
-            return new FailState<ModbusIP>({"Alarm EC Fan #2"});
-        case 19:
-            return new FailState<ModbusIP>({"Alarm EC Fan #3"});
-        case 20:
-            return new FailState<ModbusIP>({"Alarm EC Fan #4"});
-        case 21:
-            return new FailState<ModbusIP>({"Alarm EC Fan #5"});
-        case 22:
-            return new FailState<ModbusIP>({"Alarm EC Fan #6"});
-        case 23:
-            return new FailState<ModbusIP>({"Alarm EC Fan #7"});
-        case 24:
-            return new FailState<ModbusIP>({"Alarm EC Fan #8"});
-        case 25:
-            return new FailState<ModbusIP>({"Alarm EC Fan #9"});
-        default:
-            break;
-    }
-
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the running state.
- * Sets the "Run Status" for all EC fans to 1 to indicate they are active.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Running State...");
-    // You could also update a Modbus register to show the "standby" state
-
-    const std::vector<std::string> motorStatusDescriptions = {
-        "Run Status EC Fan #1", "Run Status EC Fan #2", "Run Status EC Fan #3",
-        "Run Status EC Fan #4", "Run Status EC Fan #5", "Run Status EC Fan #6",
-        "Run Status EC Fan #7", "Run Status EC Fan #8", "Run Status EC Fan #9"
-    };
-
-    // Loop through and set all motor statuses to 0
-    for (const auto& desc : motorStatusDescriptions) {
-        Modbus_Point<ModbusIP>* point = equipment->getModbus_Point(desc);
-        if (point) {
-            point->setValue(1);
-        }
-    }
-}
-
-/**
- * @brief Logic to execute once when exiting the running state.
- * Sets the "Run Status" for all EC fans to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Running State...");
-    const std::vector<std::string> motorStatusDescriptions = {
-        "Run Status EC Fan #1", "Run Status EC Fan #2", "Run Status EC Fan #3",
-        "Run Status EC Fan #4", "Run Status EC Fan #5", "Run Status EC Fan #6",
-        "Run Status EC Fan #7", "Run Status EC Fan #8", "Run Status EC Fan #9"
-    };
-
-    // Loop through and set all motor statuses to 0
-    for (const auto& desc : motorStatusDescriptions) {
-        Modbus_Point<ModbusIP>* point = equipment->getModbus_Point(desc);
-        if (point) {
-            point->setValue(0);
-        }
-    }
-}
\ No newline at end of file
diff --git a/src/BMS/HUM/HUM_NEPTRONICS_SKE4_TCP/State_Standby.cpp b/src/BMS/HUM/HUM_NEPTRONICS_SKE4_TCP/State_Standby.cpp
deleted file mode 100644
index 1ee0de6..0000000
--- a/src/BMS/HUM/HUM_NEPTRONICS_SKE4_TCP/State_Standby.cpp
+++ /dev/null
@@ -1,135 +0,0 @@
-/**
- * @file State_Standby.cpp
- * @brief Implementation of the StandbyState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the StandbyState, which defines
- * the behavior of the equipment when it is in an idle or standby mode.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-/**
- * @brief Constructs a new StandbyState object.
- *
- * In this state, the equipment is idle. This constructor initializes strategies
- * to bring the system to a safe, idle condition. It sets a stable value for
- * the SAT reading and creates ramp strategies to bring the CW valve and all
- * EC fan speeds down to zero.
- */
-template<>
-StandbyState<ModbusIP>::StandbyState() {
-    // You can add initialization code here if needed
-    addStrategy("SAT Reading", new SingleValueStrategy(100.0f, 0.1f, 1000));
-    addStrategy("CW Valve Position", new RampStrategy(0.0f, 5.0f, 1000));
-    addStrategy("Speed EC Fan #1", new RampStrategy(0.0f, 5.0f, 1000));
-    addStrategy("Speed EC Fan #2", new RampStrategy(0.0f, 5.0f, 1000));
-    addStrategy("Speed EC Fan #3", new RampStrategy(0.0f, 5.0f, 1000));
-    addStrategy("Speed EC Fan #4", new RampStrategy(0.0f, 5.0f, 1000));
-    addStrategy("Speed EC Fan #5", new RampStrategy(0.0f, 5.0f, 1000));
-    addStrategy("Speed EC Fan #6", new RampStrategy(0.0f, 5.0f, 1000));
-    addStrategy("Speed EC Fan #7", new RampStrategy(0.0f, 5.0f, 1000));
-    addStrategy("Speed EC Fan #8", new RampStrategy(0.0f, 5.0f, 1000));
-    addStrategy("Speed EC Fan #9", new RampStrategy(0.0f, 5.0f, 1000));
-
-}
-
-/**
- * @brief Executes the standby state's logic for one update cycle.
- *
- * This method applies the strategies defined for the standby state (e.g.,
- * ramping values to zero).
- *
- * @warning This method currently does not check for a command to transition to the
- *          Running state. This logic needs to be added to allow the unit to start.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* StandbyState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Standby update function");
-    int On_Off_Command = getPointValue(equipment, "ON/OFF Command By BMS");
-    Serial.printf("ON_OFF COmmand %f. \n", On_Off_Command);
-    if (On_Off_Command == 1){
-        return new RunningState<ModbusIP>();
-    }
-
-    
-
-    
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the standby state.
- * This method performs cleanup by setting all alarm points and all EC fan
- * run status points to 0.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-// A list of all alarm descriptions
-    const std::vector<std::string> alarmDescriptions = {
-        "Alarm SAT Sensor Fault", "Alarm RAH Sensor Fault", "Alarm RAT Sensor Fault",
-        "Alarm Filter DP Sensor Fault", "Alarm Flooding", "Alarm Dirty Filter",
-        "Alarm High RAT", "Alarm Low RAT", "Alarm High SAT", "Alarm Low SAT",
-        "Alarm High RAH", "Alarm Low RAH", "Alarm Common", "Alarm Phase Failure",
-        "Alarm Condensate Pump", "Alarm Smoke", "Alarm Fire", "Alarm EC Fan #1",
-        "Alarm EC Fan #2", "Alarm EC Fan #3", "Alarm EC Fan #4", "Alarm EC Fan #5",
-        "Alarm EC Fan #6", "Alarm EC Fan #7", "Alarm EC Fan #8", "Alarm EC Fan #9"
-    };
-
-    // A list of all motor run status descriptions
-    const std::vector<std::string> motorStatusDescriptions = {
-        "Run Status EC Fan #1", "Run Status EC Fan #2", "Run Status EC Fan #3",
-        "Run Status EC Fan #4", "Run Status EC Fan #5", "Run Status EC Fan #6",
-        "Run Status EC Fan #7", "Run Status EC Fan #8", "Run Status EC Fan #9"
-    };
-
-    // Loop through and set all alarms to 0
-    for (const auto& desc : alarmDescriptions) {
-        Modbus_Point<ModbusIP>* point = equipment->getModbus_Point(desc);
-        if (point) {
-            point->setValue(0);
-        }
-    }
-
-    // Loop through and set all motor statuses to 0
-    for (const auto& desc : motorStatusDescriptions) {
-        Modbus_Point<ModbusIP>* point = equipment->getModbus_Point(desc);
-        if (point) {
-            point->setValue(0);
-        }
-    }
-}
-
-/**
- * @brief Logic to execute once when exiting the standby state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Standby State...");
-}
\ No newline at end of file
diff --git a/src/BMS/HUM/HUM_NEPTRONICS_SKE4_TCP/config.h b/src/BMS/HUM/HUM_NEPTRONICS_SKE4_TCP/config.h
deleted file mode 100644
index af4ac2c..0000000
--- a/src/BMS/HUM/HUM_NEPTRONICS_SKE4_TCP/config.h
+++ /dev/null
@@ -1,142 +0,0 @@
-/**
- * @file config.h
- * @brief Main configuration file for the CRAH Unit (TCP) emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * This file contains two important configurations: WiFi network parameters
- * and the Modbus register map for the device.
- */
-
-#ifndef CONFIG_H
-#define CONFIG_H
-
-#include "core.h"
-#include "Equipment/Equipment.h"
-
-#if defined(USE_MODBUS_IP)
-/**
-   * @defgroup ModbusTCPConfig Modbus IP Configuration
-   * @brief Parameters for Modbus TCP communication.
-   * @{
-   */
-  #include <ModbusIP_ESP8266.h>
-  const char *ssid = "wifi_name";       /**< @brief The SSID of the WiFi network. */
-  const char *password = "wifi_password";   /**< @brief The password for the WiFi network. */
-  IPAddress local_IP(192, 168, 1, 234);       /**< @brief The static IP address for the device. */
-  IPAddress gateway(192, 168, 1, 1);          /**< @brief The gateway IP address. */
-  IPAddress subnet(255, 255, 255, 0);         /**< @brief The subnet mask. */
-  
-  ModbusIP mb;
-#else
-  /**
-   * @defgroup ModbusRTUConfig Modbus RTU Configuration
-   * @brief Parameters for serial Modbus RTU communication.
-   * @{
-   */
-  #include <ModbusRTU.h>
-  const int BAUDRATE = 19200;   /**< @brief The serial communication speed in bits per second. */
-  const int RX_PIN = 17;        /**< @brief The GPIO pin used for receiving data (RX). */
-  const int TX_PIN = 16;        /**< @brief The GPIO pin used for transmitting data (TX). */
-  const int RST_PIN = 4;        /**< @brief The GPIO pin connected to the RS485 driver's DE/RE pins for direction control. */
-  const int MODBUS_ID = 1;      /**< @brief The unique slave ID for this device on the Modbus bus. */
-  /** @} */
-
-  /** @brief Global instance of the Modbus RTU server. */
-  ModbusRTU mb;
-#endif
-
-
-
-/**
- * @defgroup ModbusMapConfig Modbus Map Configuration
- * @brief Defines the Modbus register map and related parameters for the emulator.
- * @{
- */
-/**
- * @brief The Modbus map for the Equipment device.
- * This array defines all the Modbus points available on the emulated device.
- * The `description` field is crucial as it's used to look up points within the application logic.
- */
-modbusMap mb_map[] =
-{   
-  {HR,          2014,    0,     "Main Power Supply"},                   //Read Only, Value x 10 (e.g. 2V = 20)  
-  {HR,          4002,    0,     "Heater SSR Stage"},                    //Read Only, Value x 100 (e.g. 10% = 1000) 
-  {HR,          6001,    0,     "Control Input"},                       //Read Only, Value x 100 (e.g. 10% = 1000) 
-  {HR,          6005,    0,     "Room RH"},                             //Read Only, Value x 100 (e.g. 10% RH = 1000) 
-  {HR,          6009,    0,     "Supply High Limit RH"},                //Read Only, Value x 100 (e.g. 10% RH = 1000) 
-  {HR,          6013,    0,     "Water Temperature"},                   //Read Only, Value x 100 (10ºF = 1000)
-  {HR,          6015,    0,     "SSR Temperature"},                     //Read Only, Value x 100 (10ºF = 1000)
-  {HR,          6016,    0,     "Cabinet Temperature"},                 //Read Only, Value x 100 (10ºF = 1000)
-  {HR,          6017,    0,     "Current Sensor 1"},                    //Read Only, Value x 100 (e.g. 10A = 1000)
-  {HR,          6018,    0,     "Current Sensor 2"},                    //Read Only, Value x 100 (e.g. 10A = 1000)
-  {HR,          6023,    0,     "Power Output Feedback"},               //Read Only, Value x 100 (e.g. 10% = 1000) 
-  {HR,          6024,    7800,  "Water Level"},                         //Read Only, Value x 100 (e.g. 10% = 1000) 
-  {HR,          6029,    0,     "Room RH Network Reading"},             //*Writable, Value x 100 (e.g. 10% RH= 1000) Room RH reading from PLC
-  {HR,          6030,    0,     "Room RH Setpoint"},                    //*Writable, Value x 100 (e.g. 10% RH= 1000) Room disired RH from PLC
-  {HR,          6036,    0,     "Room Demand"},                         //Read Only, Value x 100 (e.g. 10% RH = 1000) 
-  {HR,          6037,    0,     "Supply High Limit Network Reading"},   //Writable, Value x 100 (e.g. 10% RH= 1000) 
-  {HR,          6038,    8000,  "Supply High Limit Setpoint"},          //Writable, Value x 100 (e.g. 10% RH = 1000) 
-  {HR,          6042,    0,     "Supply High Limit Demand"},            //Read Only, Value x 100 (e.g. 10% RH = 1000) 
-  {HR,          6043,    0,     "Humidity Control Network Demand"},     //Writable, Value x 100 (e.g. 10% = 1000) 
-  {HR,          6045,    0,     "Humidity Demand"},                     //Read Only, Value x 100 (e.g. 10% = 1000) 
-  {HR,          6047,    0,     "System Power Output"},                 //Read Only, Value x 100 (e.g. 10% = 1000) 
-  {HR,          6049,    0,     "Boiler Demand"},                       //Writable, Value x 100 (e.g. 10% = 1000) 
-  {HR,          6051,    0,     "Boiler Power Output"},                 //*Read Only, Value x 100 (e.g. 10% = 1000) 
-  {HR,          6052,    0,     "Boiler Run Time"},                     //Read Only, Hours (h), Value x 100 (e.g. 10 h = 1000)
-  {HR,          6056,    0,     "Boiler On Time"},                      //Read Only, Hours (h), Value x 100 (e.g. 10 h = 1000)
-  {HR,          6060,    0,     "Boiler Service Run Time"},             //Read Only, Hours (h), Value x 100 (e.g. 10 h = 1000)
-  {HR,          6064,    0,     "Boiler Service On Time"},              //Read Only, Hours (h), Value x 100 (e.g. 10 h = 1000)
-  {HR,          6084,    0,     "Boiler Manual Cal Time"},              //Read Only, Hours (h), Value x 100 (e.g. 10 h = 1000)
-  {HR_10x,      1,       0,     "Air Flow"},                            //Read Only, 0=Closed, 1=Open 
-  {HR_10x,      2,       0,     "Supply High Limit"},                   //Read Only, 0=Closed, 1=Open 
-  {HR_10x,      3,       0,     "Interlock"},                           //Read Only, 0=Closed, 1=Open 
-  {HR_10x,      5,       0,     "Water Leak Detection"},                //Read Only, 0=Ok, 1=Leak 
-  {HR_10x,      6,       0,     "Thermal Cutout"},                      //Read Only, 0=Closed, 1=Open 
-  {HR_10x,      9,       0,     "Contactors PCB Fuse"},                 //Read Only, 0=Normal, 1=Blown Fuse  
-  {HR_10x,      10,      0,     "Control PCB Fuse"},                    //Read Only, 0=Normal, 1=Blown Fuse 
-  {HR_10x,      1001,    0,     "Alarm Warning Relay"},                 //Read Only, 0=Off, 1=On 
-  {HR_10x,      1002,    0,     "Service Warning Relay"},               //Read Only, 0=Off, 1=On 
-  {HR_10x,      1003,    0,     "Water Level Valve"},                   //Read Only, 0=Off, 1=On 
-  {HR_10x,      1004,    0,     "Tank Water Valve"},                    //Read Only, 0=Off, 1=On 
-  {HR_10x,      1005,    0,     "Drain Cooler Valve"},                  //Read Only, 0=Off, 1=On 
-  {HR_10x,      1006,    0,     "Drain Pump"},                          //Read Only, 0=Off, 1=On 
-  {HR_10x,      1007,    0,     "Drain Valve"},                         //Read Only, 0=Off, 1=On 
-  {HR_10x,      1008,    0,     "Main Contactor"},                      //Read Only, 0=Off, 1=On 
-  {HR_10x,      1009,    0,     "Heater Stage 1"},                      //Read Only, 0=Off, 1=On 
-  {HR_10x,      1010,    0,     "Heater Stage 2"},                      //Read Only, 0=Off, 1=On 
-  {HR_10x,      1011,    0,     "Heater Stage 3"},                      //Read Only, 0=Off, 1=On 
-  {HR_10x,      1012,    0,     "SDU Fan"},                             //Read Only, 0=Off, 1=On 
-  {HR_10x,      1013,    0,     "Alarm LED"},                           //Read Only, 0=Off, 1=On 
-  {HR_10x,      1014,    0,     "Power LED"},                           //Read Only, 0=Off, 1=On 
-  {HR_10x,      1015,    0,     "Buzzer"},                              //Read Only, 0=Off, 1=On
-  {HR_10x,      2001,    0,     "Manual Water Cal State"},              //Read Only, 0=Ok, 1=Required 
-  {HR_10x,      2002,    0,     "Water Level Low"},                     //Read Only, 0=Inactive, 1=Active 
-  {HR_10x,      2003,    0,     "Water Level High"},                    //Read Only, 0=Inactive, 1=Active 
-  {HR_10x,      2004,    0,     "Foam Sensor"},                         //Read Only, 0=NoFoam, 1=Foam 
-  {HR_10x,      2005,    0,     "SDU Fan Fault"},                       //Read Only, 0=Off, 1=On
-  {HR_10x,      2007,    0,     "Boiler Service Due"},                  //Read Only, 0=No, 1=Yes  
-  {HR_10x,      2008,    0,     "Foam"},                                //Read Only, 0=Ok, 1=Detected
-  {HR_10x,      2016,    0,     "AntiFreeze Warning"},                  //Read Only, 0=Inactive, 1=Drain
-  {HR_10x,      5016,    0,     "Humidity Control Cutout State"},       //Read Only, 0=Off, 1=Normal, 2=LowLimit, 3=HighLimit, 4=NoAirFlow, 5=Interlock     
-  {HR_10x,      5018,    0,     "Boiler Request"},                      //Writable, 0=None, 1=Reset Alarms, 2=Drain, 3=Reset Counters, 4=Filling, 5=WaterCalib    
-  {HR_10x,      5019,    0,     "Boiler State"},                        //Read Only, 0=Off, 1=Idle, 2=LineRinse, 3=TankRinse, 4=Filling, 5=Draining, 6=Heating, 7=Boiling, 8=Alarm    
-  {HR_10x,      5021,    0,     "Boiler Alarm"},                        //Read Only, 0=Normal, 1=FailedPump, 2=FillTimeout, 3=BlockedPiping, 4=HeatTimeout, 5=Overheat, 6=WaterLeak, 7=Service,  9=TankBlocked, 10=RefillDelay  
-  {HR_10x,      5025,    1,     "System Power State"},                  //*Writable, 0=Off, 1=On   
-  {HR_10x,      5026,    0,     "Water Level Probe Warning"},           //Read Only, 0=OK, 1=Replace     
-  {HR_10x,      5027,    0,     "Water Level Probe Failure"},           //Read Only, 0=None, 1=Capacitive, 2=Resistive, 3=Both
-  {HR_10x,      5028,    0,     "Water Level Probe Alarm"}              //Read Only, 0=OK, 1=Defect, 2=NoCalib                               
-};
-//Size of modbus map used in FOR cycles, automatically calculated.
-
-/**
- * @brief The total number of entries in the `mb_map` array.
- * This is calculated at compile time and used for iterating over the map.
- */
-const int map_size = sizeof(mb_map) / sizeof(mb_map[0]);
-
-/** @brief The main loop update interval in milliseconds. */
-int interval = 250; 
-/** @} */ // End of ModbusMapConfig group
-
-#endif // CONFIG_H
diff --git a/src/BMS/HUM/HUM_NEPTRONICS_SKE4_TCP/main.cpp b/src/BMS/HUM/HUM_NEPTRONICS_SKE4_TCP/main.cpp
deleted file mode 100644
index 286a98c..0000000
--- a/src/BMS/HUM/HUM_NEPTRONICS_SKE4_TCP/main.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-/**
- * @file main.cpp
- * @brief Main execution program for the CRAH Unit (TCP) Emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * @details This file contains the main execution program for an Arduino-based emulator of a CRAH unit. 
- * The program uses a Wi-Fi connection to communicate via the Modbus IP protocol.
- *
- * The setup() function initializes the following:
- * - Serial communication for debugging.
- * - Wi-Fi connection using credentials from config.h.
- * - A Modbus TCP server.
- * - Modbus points (Coils, Holding Registers, etc.) based on a predefined map in config.h.
- *
- * The loop() function continuously:
- * - Services the Modbus TCP server to handle incoming requests.
- * - Periodically calls the main update loop for the emulated equipment, which
- *   manages state transitions and behavior strategies.
- *
- * @see config.h for Wi-Fi and Modbus configuration.
- * @see Equipment.h for the main equipment logic.
- * @see State.h for different equipment states.
- * @see Strategies/Strategy_Behavior.h for value generation strategies.
- * @see Modbus_Point.h for the base class for all Modbus points.
- */
-//=================================================================================================================================
-//Libraries and declaration of variables.
-#include <WiFi.h>
-#include "config.h"
-#include "ModbusPoints/Modbus_PointFactory.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-//=================================================================================================================================
-/** 
- * @brief Initializes the application.
- * @details This function runs once at startup. It configures the serial communication, 
- * Wi-Fi, and the Modbus server. It also creates and initializes all the Modbus points 
- * based on the `mb_map` array in `config.h`.
- */
-void setup() {
-  Serial.begin(115200);                       //Serial comm start
-  WiFi.config(local_IP, gateway, subnet);     // Wifi service start
-  WiFi.begin(ssid, password);
-  while (WiFi.status() != WL_CONNECTED) {
-    delay(1000);
-    Serial.print(".");
-  }
-  Serial.println("Connected!!");
-  mb.server();                                //Modbus server start
-  Serial.println("Server Created");
-  Serial.println(map_size);
-  for(int i = 0; i < map_size; i++){
-    Modbus_Point<ModbusIP>* point = createModbus_Point(&mb, mb_map[i].category, mb_map[i].address, mb_map[i].value, mb_map[i].description);
-    if (point) {
-      point->addToModbusServer();
-      EquipmentInstance.addModbus_Point(mb_map[i].description, point);
-    }
-  }
-  Serial.println("All modbus Points created");
-  Serial.println("Setup function ended");
-}
-//=================================================================================================================================
-/** 
- * @brief The main application loop.
- * @details This function runs repeatedly after setup() has completed. It performs two main actions:
- * 1. It continuously services the Modbus server by calling `mb.task()` to handle
- *    incoming requests from a Modbus master.
- * 2. At a fixed interval (defined in `config.h`), it calls `EquipmentInstance.update()`
- *    to run the emulator's internal state machine and behavior logic.
- */
-void loop() {
-  mb.task();
-  unsigned long currentMillis = millis();
-  if (currentMillis - previousMillis >= interval) {
-    previousMillis = currentMillis;
-    unsigned long startTime = millis();
-    EquipmentInstance.update();
-    unsigned long endTime = millis();
-    unsigned long elapsedTime = endTime - startTime;
-    Serial.printf("Control Execution time: %d ms\n", elapsedTime);
-  } 
-}
diff --git a/src/BMS/STU/STU_UMP_STU_2_0_CAH_IDR_60_TCP_PHXA7/README.md b/src/BMS/STU/STU_UMP_STU_2_0_CAH_IDR_60_TCP_PHXA7/README.md
deleted file mode 100644
index 355156f..0000000
--- a/src/BMS/STU/STU_UMP_STU_2_0_CAH_IDR_60_TCP_PHXA7/README.md
+++ /dev/null
@@ -1,33 +0,0 @@
-# EQUIPMENT_TYPE MANUFACTURER MODEL TCP
-
-## Brief Introduction
-Equipment specifc details that make it different from other devices
-
-## List of Equipmentt
-This cofiguration has been used for these models:
-* **Model**: 09-15-22 
-* **Model**: 09-15-23 
-* **Model**: 09-15-25 
-
-## Hardware Prerequisites
-
-The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities.
-* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html) 
-
----
-
-## States and Strategies
-Provide a brief description of what variables and strategies were used in this configuraiton
-
-### Standby State
-* **Equipment running**: set to 0
-* **Common Alarm**: set to 0
-* **SAT temperature**: set to 85
-
-### Running State
-* **Equipment running**: set to 1
-* **SAT temperature**: **Ramp Strategy** set to 65 deg setpoint
-
-### Fail State
-* **Commong Alarm**: set to 1
-* **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset
diff --git a/src/BMS/STU/STU_UMP_STU_2_0_CAH_IDR_60_TCP_PHXA7/State_Fail.cpp b/src/BMS/STU/STU_UMP_STU_2_0_CAH_IDR_60_TCP_PHXA7/State_Fail.cpp
deleted file mode 100644
index 8bc0385..0000000
--- a/src/BMS/STU/STU_UMP_STU_2_0_CAH_IDR_60_TCP_PHXA7/State_Fail.cpp
+++ /dev/null
@@ -1,81 +0,0 @@
-/**
- * @file State_Fail.cpp
- * @brief Implementation of the FailState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the FailState, which defines
- * the behavior of the equipment when it has entered a fault condition.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new FailState object with a list of active alarms.
- *
- * This constructor receives a list of alarm descriptions and creates strategies
- * to set the corresponding Modbus points to a value of 1, indicating an
- * active alarm. It also initializes a PID strategy for the 'CW Valve Position'
- * to maintain its state during the fault.
- * @param activeAlarms A vector of strings, where each string is the
- *                     description of a Modbus point to be set as an active alarm.
- */
-template<>
-FailState<ModbusIP>::FailState(const std::vector<std::string>& activeAlarms) {
-    // Simulate a failure: set common alarm and a specific fan alarm.
-
-    
-}
-
-/**
- * @brief Executes the fail state's logic for one update cycle.
- *
- * This method checks the "Alarm Reset" Modbus point for a command to
- * transition back to Standby, which would typically happen after a fault
- * is cleared by a user. If no transition is requested, it continues to apply
- * the failure strategies (e.g., keeping alarm bits active).
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* FailState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Fail update function");
-    
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the fail state.
- * Sets the "Alarm Common" point to 1 to indicate a general fault condition.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Fail State...");
-}
-
-/**
- * @brief Logic to execute once when exiting the fail state.
- * Clears the "Alarm Common" point to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Fail State...");
-}
\ No newline at end of file
diff --git a/src/BMS/STU/STU_UMP_STU_2_0_CAH_IDR_60_TCP_PHXA7/State_Running.cpp b/src/BMS/STU/STU_UMP_STU_2_0_CAH_IDR_60_TCP_PHXA7/State_Running.cpp
deleted file mode 100644
index b9e4a99..0000000
--- a/src/BMS/STU/STU_UMP_STU_2_0_CAH_IDR_60_TCP_PHXA7/State_Running.cpp
+++ /dev/null
@@ -1,89 +0,0 @@
-/**
- * @file State_Running.cpp
- * @brief Implementation of the RunningState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the RunningState, which defines
- * the behavior of the equipment when it is actively running.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "Strategies/Strategy_Totalizer.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new RunningState object.
- *
- * This constructor initializes behavior strategies active during the running
- * state, such as a PID controller for the 'CW Valve Position' and totalizers
- * for the run-hours of each EC fan.
- */
-template<>
-RunningState<ModbusIP>::RunningState() {
-}
-
-/**
- * @brief Executes the running state's logic for one update cycle.
- *
- * This method first checks for state transition commands:
- * 1. It reads the "ON/OFF Command By BMS" point. If it's 0, it transitions to StandbyState.
- * 2. It reads the "Fault Code" point. If it's non-zero, it transitions to FailState,
- *    passing the corresponding alarm description.
- *
- * If no transition occurs, it applies the strategies defined for the running state.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* RunningState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Running update function");
-    
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the running state.
- * Sets the "Run Status" for all EC fans to 1 to indicate they are active.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Running State...");
-    // You could also update a Modbus register to show the "standby" state
-
-}
-
-/**
- * @brief Logic to execute once when exiting the running state.
- * Sets the "Run Status" for all EC fans to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Running State...");
-   
-}
\ No newline at end of file
diff --git a/src/BMS/STU/STU_UMP_STU_2_0_CAH_IDR_60_TCP_PHXA7/State_Standby.cpp b/src/BMS/STU/STU_UMP_STU_2_0_CAH_IDR_60_TCP_PHXA7/State_Standby.cpp
deleted file mode 100644
index 20029d1..0000000
--- a/src/BMS/STU/STU_UMP_STU_2_0_CAH_IDR_60_TCP_PHXA7/State_Standby.cpp
+++ /dev/null
@@ -1,85 +0,0 @@
-/**
- * @file State_Standby.cpp
- * @brief Implementation of the StandbyState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the StandbyState, which defines
- * the behavior of the equipment when it is in an idle or standby mode.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-/**
- * @brief Constructs a new StandbyState object.
- *
- * In this state, the equipment is idle. This constructor initializes strategies
- * to bring the system to a safe, idle condition. It sets a stable value for
- * the SAT reading and creates ramp strategies to bring the CW valve and all
- * EC fan speeds down to zero.
- */
-template<>
-StandbyState<ModbusIP>::StandbyState() {
-    // You can add initialization code here if needed
-    
-
-}
-
-/**
- * @brief Executes the standby state's logic for one update cycle.
- *
- * This method applies the strategies defined for the standby state (e.g.,
- * ramping values to zero).
- *
- * @warning This method currently does not check for a command to transition to the
- *          Running state. This logic needs to be added to allow the unit to start.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* StandbyState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Standby update function");
-    
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the standby state.
- * This method performs cleanup by setting all alarm points and all EC fan
- * run status points to 0.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Standby State...");
-}
-
-/**
- * @brief Logic to execute once when exiting the standby state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Standby State...");
-}
\ No newline at end of file
diff --git a/src/BMS/STU/STU_UMP_STU_2_0_CAH_IDR_60_TCP_PHXA7/config.h b/src/BMS/STU/STU_UMP_STU_2_0_CAH_IDR_60_TCP_PHXA7/config.h
deleted file mode 100644
index 431537f..0000000
--- a/src/BMS/STU/STU_UMP_STU_2_0_CAH_IDR_60_TCP_PHXA7/config.h
+++ /dev/null
@@ -1,120 +0,0 @@
-/**
- * @file config.h
- * @brief Main configuration file for the CRAH Unit (TCP) emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * This file contains two important configurations: WiFi network parameters
- * and the Modbus register map for the device.
- */
-
-#ifndef CONFIG_H
-#define CONFIG_H
-
-#include "core.h"
-#include "Equipment/Equipment.h"
-
-#if defined(USE_MODBUS_IP)
-/**
-   * @defgroup ModbusTCPConfig Modbus IP Configuration
-   * @brief Parameters for Modbus TCP communication.
-   * @{
-   */
-  #include <ModbusIP_ESP8266.h>
-  const char *ssid = "Prime Guest";       /**< @brief The SSID of the WiFi network. */
-  const char *password = "Pr1meguest#";   /**< @brief The password for the WiFi network. */
-  IPAddress local_IP(192, 168, 103, 91);       /**< @brief The static IP address for the device. */
-  IPAddress gateway(192, 168, 103, 65);          /**< @brief The gateway IP address. */
-  IPAddress subnet(255, 255, 255, 0);         /**< @brief The subnet mask. */
-  
-  ModbusIP mb;
-#else
-  /**
-   * @defgroup ModbusRTUConfig Modbus RTU Configuration
-   * @brief Parameters for serial Modbus RTU communication.
-   * @{
-   */
-  #include <ModbusRTU.h>
-  const int BAUDRATE = 19200;   /**< @brief The serial communication speed in bits per second. */
-  const int RX_PIN = 17;        /**< @brief The GPIO pin used for receiving data (RX). */
-  const int TX_PIN = 16;        /**< @brief The GPIO pin used for transmitting data (TX). */
-  const int RST_PIN = 4;        /**< @brief The GPIO pin connected to the RS485 driver's DE/RE pins for direction control. */
-  const int MODBUS_ID = 1;      /**< @brief The unique slave ID for this device on the Modbus bus. */
-  /** @} */
-
-  /** @brief Global instance of the Modbus RTU server. */
-  ModbusRTU mb;
-#endif
-
-
-
-/**
- * @defgroup ModbusMapConfig Modbus Map Configuration
- * @brief Defines the Modbus register map and related parameters for the emulator.
- * @{
- */
-/**
- * @brief The Modbus map for the Equipment device.
- * This array defines all the Modbus points available on the emulated device.
- * The `description` field is crucial as it's used to look up points within the application logic.
- */
-modbusMap mb_map[] =
-{   
-  {COIL,      0,    0,  "Fn_Enable"},
-  {COIL,      1,    0,  "Fn_Manual"},
-  {COIL,      2,    0,  "Reset_Cmd"},
-  {DI,        0,    0,  "Sts_Enabled"},
-  {DI,        1,    0,  "Sts_MANUAL"},
-  {DI,        2,    0,  "Alm_Actuator1"},
-  {DI,        11,    0,  "Alm_Actuator2"},
-  {DI,        3,    0,  "Alm_Fn_Fault"},
-  {DI,        4,    0,  "Alm_Smoke"},
-  {DI,        5,    0,  "Alm_Leak"},
-  {DI,        6,    0,  "Alm_DA_Sensor_Fault"},
-  {DI,        7,    0,  "Alm_CHWS_HiTemp"},
-  {DI,        8,    0,  "Alm_CHWR_HiTemp"},
-  {DI,        9,    0,  "Alm_CHWS_LoTemp"},
-  {DI,        10,    0,  "Alm_CHWR_LoTemp"},
-  {HR,        0,    0,  "Cfg_DischargeAir"},
-  {HR,        2,    0,  "Cfg_Fn_Speed"},
-  {HR,        4,    0,  "Cfg_CHWV_ManualCmd"},
-  {HR,        6,    0,  "Cfg_CHWS_HiTemp"},
-  {HR,        8,    0,  "Cfg_CHWS_LoTemp"},
-  {HR,        10,    0,  "Cfg_CHWR_HiTemp"},
-  {HR,        12,    0,  "Cfg_CHWR_LoTemp"},
-  {IR,        0,    0,  "Sts_DischargeAir_Avg"},
-  {IR,        2,    0,  "Sts_DischargeAir_1"},
-  {IR,        4,    0,  "Sts_DischargeAir_2"},
-  {IR,        6,    0,  ""},
-  {IR,        8,    0,  "Sts_CHWS_Temp"},
-  {IR,        10,    0,  "Sts_CHWR_Temp1"},
-  {IR,        12,    0,  "Sts_RAT"},
-  {IR,        14,    0,  "Sts_CHWV_PositionCmd"},
-  {IR,        15,    0,  "Sts_CHWR_Temp2"},
-  {IR,        16,    0,  "Sts_CHWV1_PositionFb"},
-  {IR,        17,    0,  "Sts_CHWV2_PositionFb"},
-  {IR,        18,    0,  "Sts_Fn1"},
-  {IR,        20,    0,  "Sts_Fn2"},
-  {IR,        22,    0,  "Sts_Fn3"},
-  {IR,        24,    0,  "Sts_Fn4"},
-  {IR,        26,    0,  "Sts_Fn5"},
-  {IR,        28,    0,  "Sts_Fn6"},
-  {IR,        30,    0,  "Sts_Fn7"},
-  {IR,        32,    0,  "Sts_Fn8"},
-  {IR,        34,    0,  "Sts_Fn9"},
-  {IR,        35,    0,  "Sts_Runtime_1"},
-  {IR,        36,    0,  "Sts_Runtime_2"},
-}; 
-//Size of modbus map used in FOR cycles, automatically calculated.
-
-/**
- * @brief The total number of entries in the `mb_map` array.
- * This is calculated at compile time and used for iterating over the map.
- */
-const int map_size = sizeof(mb_map) / sizeof(mb_map[0]);
-
-/** @brief The main loop update interval in milliseconds. */
-int interval = 250; 
-/** @} */ // End of ModbusMapConfig group
-
-#endif // CONFIG_H
diff --git a/src/BMS/STU/STU_UMP_STU_2_0_CAH_IDR_60_TCP_PHXA7/main.cpp b/src/BMS/STU/STU_UMP_STU_2_0_CAH_IDR_60_TCP_PHXA7/main.cpp
deleted file mode 100644
index 286a98c..0000000
--- a/src/BMS/STU/STU_UMP_STU_2_0_CAH_IDR_60_TCP_PHXA7/main.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-/**
- * @file main.cpp
- * @brief Main execution program for the CRAH Unit (TCP) Emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * @details This file contains the main execution program for an Arduino-based emulator of a CRAH unit. 
- * The program uses a Wi-Fi connection to communicate via the Modbus IP protocol.
- *
- * The setup() function initializes the following:
- * - Serial communication for debugging.
- * - Wi-Fi connection using credentials from config.h.
- * - A Modbus TCP server.
- * - Modbus points (Coils, Holding Registers, etc.) based on a predefined map in config.h.
- *
- * The loop() function continuously:
- * - Services the Modbus TCP server to handle incoming requests.
- * - Periodically calls the main update loop for the emulated equipment, which
- *   manages state transitions and behavior strategies.
- *
- * @see config.h for Wi-Fi and Modbus configuration.
- * @see Equipment.h for the main equipment logic.
- * @see State.h for different equipment states.
- * @see Strategies/Strategy_Behavior.h for value generation strategies.
- * @see Modbus_Point.h for the base class for all Modbus points.
- */
-//=================================================================================================================================
-//Libraries and declaration of variables.
-#include <WiFi.h>
-#include "config.h"
-#include "ModbusPoints/Modbus_PointFactory.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-//=================================================================================================================================
-/** 
- * @brief Initializes the application.
- * @details This function runs once at startup. It configures the serial communication, 
- * Wi-Fi, and the Modbus server. It also creates and initializes all the Modbus points 
- * based on the `mb_map` array in `config.h`.
- */
-void setup() {
-  Serial.begin(115200);                       //Serial comm start
-  WiFi.config(local_IP, gateway, subnet);     // Wifi service start
-  WiFi.begin(ssid, password);
-  while (WiFi.status() != WL_CONNECTED) {
-    delay(1000);
-    Serial.print(".");
-  }
-  Serial.println("Connected!!");
-  mb.server();                                //Modbus server start
-  Serial.println("Server Created");
-  Serial.println(map_size);
-  for(int i = 0; i < map_size; i++){
-    Modbus_Point<ModbusIP>* point = createModbus_Point(&mb, mb_map[i].category, mb_map[i].address, mb_map[i].value, mb_map[i].description);
-    if (point) {
-      point->addToModbusServer();
-      EquipmentInstance.addModbus_Point(mb_map[i].description, point);
-    }
-  }
-  Serial.println("All modbus Points created");
-  Serial.println("Setup function ended");
-}
-//=================================================================================================================================
-/** 
- * @brief The main application loop.
- * @details This function runs repeatedly after setup() has completed. It performs two main actions:
- * 1. It continuously services the Modbus server by calling `mb.task()` to handle
- *    incoming requests from a Modbus master.
- * 2. At a fixed interval (defined in `config.h`), it calls `EquipmentInstance.update()`
- *    to run the emulator's internal state machine and behavior logic.
- */
-void loop() {
-  mb.task();
-  unsigned long currentMillis = millis();
-  if (currentMillis - previousMillis >= interval) {
-    previousMillis = currentMillis;
-    unsigned long startTime = millis();
-    EquipmentInstance.update();
-    unsigned long endTime = millis();
-    unsigned long elapsedTime = endTime - startTime;
-    Serial.printf("Control Execution time: %d ms\n", elapsedTime);
-  } 
-}
diff --git a/src/BMS/Split_System/SS_Daiken_TCP/README.md b/src/BMS/Split_System/SS_Daiken_TCP/README.md
deleted file mode 100644
index 355156f..0000000
--- a/src/BMS/Split_System/SS_Daiken_TCP/README.md
+++ /dev/null
@@ -1,33 +0,0 @@
-# EQUIPMENT_TYPE MANUFACTURER MODEL TCP
-
-## Brief Introduction
-Equipment specifc details that make it different from other devices
-
-## List of Equipmentt
-This cofiguration has been used for these models:
-* **Model**: 09-15-22 
-* **Model**: 09-15-23 
-* **Model**: 09-15-25 
-
-## Hardware Prerequisites
-
-The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities.
-* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html) 
-
----
-
-## States and Strategies
-Provide a brief description of what variables and strategies were used in this configuraiton
-
-### Standby State
-* **Equipment running**: set to 0
-* **Common Alarm**: set to 0
-* **SAT temperature**: set to 85
-
-### Running State
-* **Equipment running**: set to 1
-* **SAT temperature**: **Ramp Strategy** set to 65 deg setpoint
-
-### Fail State
-* **Commong Alarm**: set to 1
-* **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset
diff --git a/src/BMS/Split_System/SS_Daiken_TCP/State_Fail.cpp b/src/BMS/Split_System/SS_Daiken_TCP/State_Fail.cpp
deleted file mode 100644
index 8bc0385..0000000
--- a/src/BMS/Split_System/SS_Daiken_TCP/State_Fail.cpp
+++ /dev/null
@@ -1,81 +0,0 @@
-/**
- * @file State_Fail.cpp
- * @brief Implementation of the FailState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the FailState, which defines
- * the behavior of the equipment when it has entered a fault condition.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new FailState object with a list of active alarms.
- *
- * This constructor receives a list of alarm descriptions and creates strategies
- * to set the corresponding Modbus points to a value of 1, indicating an
- * active alarm. It also initializes a PID strategy for the 'CW Valve Position'
- * to maintain its state during the fault.
- * @param activeAlarms A vector of strings, where each string is the
- *                     description of a Modbus point to be set as an active alarm.
- */
-template<>
-FailState<ModbusIP>::FailState(const std::vector<std::string>& activeAlarms) {
-    // Simulate a failure: set common alarm and a specific fan alarm.
-
-    
-}
-
-/**
- * @brief Executes the fail state's logic for one update cycle.
- *
- * This method checks the "Alarm Reset" Modbus point for a command to
- * transition back to Standby, which would typically happen after a fault
- * is cleared by a user. If no transition is requested, it continues to apply
- * the failure strategies (e.g., keeping alarm bits active).
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* FailState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Fail update function");
-    
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the fail state.
- * Sets the "Alarm Common" point to 1 to indicate a general fault condition.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Fail State...");
-}
-
-/**
- * @brief Logic to execute once when exiting the fail state.
- * Clears the "Alarm Common" point to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Fail State...");
-}
\ No newline at end of file
diff --git a/src/BMS/Split_System/SS_Daiken_TCP/State_Running.cpp b/src/BMS/Split_System/SS_Daiken_TCP/State_Running.cpp
deleted file mode 100644
index b9e4a99..0000000
--- a/src/BMS/Split_System/SS_Daiken_TCP/State_Running.cpp
+++ /dev/null
@@ -1,89 +0,0 @@
-/**
- * @file State_Running.cpp
- * @brief Implementation of the RunningState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the RunningState, which defines
- * the behavior of the equipment when it is actively running.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "Strategies/Strategy_Totalizer.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new RunningState object.
- *
- * This constructor initializes behavior strategies active during the running
- * state, such as a PID controller for the 'CW Valve Position' and totalizers
- * for the run-hours of each EC fan.
- */
-template<>
-RunningState<ModbusIP>::RunningState() {
-}
-
-/**
- * @brief Executes the running state's logic for one update cycle.
- *
- * This method first checks for state transition commands:
- * 1. It reads the "ON/OFF Command By BMS" point. If it's 0, it transitions to StandbyState.
- * 2. It reads the "Fault Code" point. If it's non-zero, it transitions to FailState,
- *    passing the corresponding alarm description.
- *
- * If no transition occurs, it applies the strategies defined for the running state.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* RunningState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Running update function");
-    
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the running state.
- * Sets the "Run Status" for all EC fans to 1 to indicate they are active.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Running State...");
-    // You could also update a Modbus register to show the "standby" state
-
-}
-
-/**
- * @brief Logic to execute once when exiting the running state.
- * Sets the "Run Status" for all EC fans to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Running State...");
-   
-}
\ No newline at end of file
diff --git a/src/BMS/Split_System/SS_Daiken_TCP/State_Standby.cpp b/src/BMS/Split_System/SS_Daiken_TCP/State_Standby.cpp
deleted file mode 100644
index 20029d1..0000000
--- a/src/BMS/Split_System/SS_Daiken_TCP/State_Standby.cpp
+++ /dev/null
@@ -1,85 +0,0 @@
-/**
- * @file State_Standby.cpp
- * @brief Implementation of the StandbyState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the StandbyState, which defines
- * the behavior of the equipment when it is in an idle or standby mode.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-/**
- * @brief Constructs a new StandbyState object.
- *
- * In this state, the equipment is idle. This constructor initializes strategies
- * to bring the system to a safe, idle condition. It sets a stable value for
- * the SAT reading and creates ramp strategies to bring the CW valve and all
- * EC fan speeds down to zero.
- */
-template<>
-StandbyState<ModbusIP>::StandbyState() {
-    // You can add initialization code here if needed
-    
-
-}
-
-/**
- * @brief Executes the standby state's logic for one update cycle.
- *
- * This method applies the strategies defined for the standby state (e.g.,
- * ramping values to zero).
- *
- * @warning This method currently does not check for a command to transition to the
- *          Running state. This logic needs to be added to allow the unit to start.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* StandbyState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Standby update function");
-    
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the standby state.
- * This method performs cleanup by setting all alarm points and all EC fan
- * run status points to 0.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Standby State...");
-}
-
-/**
- * @brief Logic to execute once when exiting the standby state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Standby State...");
-}
\ No newline at end of file
diff --git a/src/BMS/Split_System/SS_Daiken_TCP/config.h b/src/BMS/Split_System/SS_Daiken_TCP/config.h
deleted file mode 100644
index 8f822e8..0000000
--- a/src/BMS/Split_System/SS_Daiken_TCP/config.h
+++ /dev/null
@@ -1,152 +0,0 @@
-/**
- * @file config.h
- * @brief Main configuration file for the Split Sytstem Daiken
- * @author Zach Gutierrez
- * @date 2025-09-02
- *
- * This file contains two important configurations: WiFi network parameters
- * and the Modbus register map for the device.
- */
-
-#ifndef CONFIG_H
-#define CONFIG_H
-
-#include "core.h"
-#include "Equipment/Equipment.h"
-
-#if defined(USE_MODBUS_IP)
-/**
-   * @defgroup ModbusTCPConfig Modbus IP Configuration
-   * @brief Parameters for Modbus TCP communication.
-   * @{
-   */
-  #include <ModbusIP_ESP8266.h>
-  const char *ssid = "wifi_name";       /**< @brief The SSID of the WiFi network. */
-  const char *password = "wifi_password";   /**< @brief The password for the WiFi network. */
-  IPAddress local_IP(192, 168, 1, 234);       /**< @brief The static IP address for the device. */
-  IPAddress gateway(192, 168, 1, 1);          /**< @brief The gateway IP address. */
-  IPAddress subnet(255, 255, 255, 0);         /**< @brief The subnet mask. */
-  
-  ModbusIP mb;
-#else
-  /**
-   * @defgroup ModbusRTUConfig Modbus RTU Configuration
-   * @brief Parameters for serial Modbus RTU communication.
-   * @{
-   */
-  #include <ModbusRTU.h>
-  const int BAUDRATE = 19200;   /**< @brief The serial communication speed in bits per second. */
-  const int RX_PIN = 17;        /**< @brief The GPIO pin used for receiving data (RX). */
-  const int TX_PIN = 16;        /**< @brief The GPIO pin used for transmitting data (TX). */
-  const int RST_PIN = 4;        /**< @brief The GPIO pin connected to the RS485 driver's DE/RE pins for direction control. */
-  const int MODBUS_ID = 1;      /**< @brief The unique slave ID for this device on the Modbus bus. */
-  /** @} */
-
-  /** @brief Global instance of the Modbus RTU server. */
-  ModbusRTU mb;
-#endif
-
-
-
-/**
- * @defgroup ModbusMapConfig Modbus Map Configuration
- * @brief Defines the Modbus register map and related parameters for the emulator.
- * @{
- */
-/**
- * @brief The Modbus map for the Equipment device.
- * This array defines all the Modbus points available on the emulated device.
- * The `description` field is crucial as it's used to look up points within the application logic.
- */
-modbusMap mb_map[] =
-{   
-  {HR,        15,     0,  "State Control"},  //Internal to control from Modscan
-  {HR,        16,     0,  "Fault Code"},
-  {HR_FLOAT,  18,     0,  "RAT"},     //Internal Fault code from Modscan  
-  {HR_FLOAT,  1,      0,  "SAT Setpoint"},                     
-  {HR_FLOAT,  681,    0,  "RAT Setpoint"},                   
-  {HR_FLOAT,  111,    0,  "High RAT Limit"},                 
-  {HR_FLOAT,  114,    0,  "Low RAT Limit"},                  
-  {HR_FLOAT,  118,    0,  "High SAT Limit"},                 
-  {HR_FLOAT,  122,    0,  "Low SAT Limit"},                  
-  {HR_FLOAT,  685,    0,  "High RAH Limit"},                 
-  {HR_FLOAT,  689,    0,  "Low RAH Limit"},                  
-  {HR,        5,      0,  "Setting the EC Fan Max Speed"},   
-  {HR,        695,    0,  "Setting the EC Fan Min Speed"},   
-  {HR_FLOAT,  693,    0,  "Setting Room Temp"},              
-  {HR,        691,    0,  "Setting EC Fan Speed "},          
-  {DI,        146,    0,  "Alarm SAT Sensor Fault"},         
-  {DI,        1246,   0,  "Alarm RAH Sensor Fault"},        
-  {DI,        1245,   0,  "Alarm RAT Sensor Fault"},        
-  {DI,        1250,   0,  "Alarm Filter DP Sensor Fault"},  
-  {DI,        51,     0,  "Alarm Flooding"},                  
-  {DI,        1096,   0,  "Alarm Dirty Filter"},            
-  {DI,        1367,   0,  "Alarm High RAT"},                
-  {DI,        1099,   0,  "Alarm Low RAT"},                 
-  {DI,        118,    0,  "Alarm High SAT"},                 
-  {DI,        122,    0,  "Alarm Low SAT"},                  
-  {DI,        1307,   0,  "Alarm High RAH"},                
-  {DI,        1308,   0,  "Alarm Low RAH"},                 
-  {DI,        1342,   0,  "Alarm Common"},                  
-  {DI,        148,    0,  "Alarm Phase Failure"},            
-  {DI,        1370,   0,  "Alarm Condensate Pump"},         
-  {DI,        1368,   0,  "Alarm Smoke"},                   
-  {DI,        1369,   0,  "Alarm Fire"},                    
-  {DI,        131,    0,  "Alarm EC Fan #1"},                
-  {DI,        132,    0,  "Alarm EC Fan #2"},                
-  {DI,        133,    0,  "Alarm EC Fan #3"},                
-  {DI,        134,    0,  "Alarm EC Fan #4"},                
-  {DI,        135,    0,  "Alarm EC Fan #5"},                
-  {DI,        136,    0,  "Alarm EC Fan #6"},                
-  {DI,        1360,   0,  "Alarm EC Fan #7"},               
-  {DI,        1361,   0,  "Alarm EC Fan #8"},               
-  {DI,        1362,   0,  "Alarm EC Fan #9"},               
-  {DI,        138,    0,  "Run Status EC Fan #1"},           
-  {DI,        139,    0,  "Run Status EC Fan #2"},           
-  {DI,        140,    0,  "Run Status EC Fan #3"},           
-  {DI,        141,    0,  "Run Status EC Fan #4"},           
-  {DI,        142,    0,  "Run Status EC Fan #5"},           
-  {DI,        143,    0,  "Run Status EC Fan #6"},           
-  {DI,        1363,   0,  "Run Status EC Fan #7"},          
-  {DI,        1364,   0,  "Run Status EC Fan #8"},          
-  {DI,        1365,   0,  "Run Status EC Fan #9"},          
-  {IR_FLOAT,  99,     0,  "SAT Reading"},                     
-  {IR_FLOAT,  70,     0,  "RAH Reading"},                     
-  {IR_FLOAT,  101,    0,  "RAT Reading"},                    
-  {IR_FLOAT,  106,    0,  "Filter DP Reading"},              
-  {IR_FLOAT,  496,    0,  "CW Valve Position"},              
-  {IR,        53,     0,  "Speed EC Fan #1"},                 
-  {IR,        228,    0,  "Speed EC Fan #2"},                
-  {IR,        229,    0,  "Speed EC Fan #3"},                
-  {IR,        230,    0,  "Speed EC Fan #4"},                
-  {IR,        231,    0,  "Speed EC Fan #5"},                
-  {IR,        232,    0,  "Speed EC Fan #6"},                
-  {IR,        678,    0,  "Speed EC Fan #7"},                
-  {IR,        679,    0,  "Speed EC Fan #8"},                
-  {IR,        680,    0,  "Speed EC Fan #9"},                
-  {IR,        274,    0,  "Operating Hours EC Fan #1"},      
-  {IR,        233,    0,  "Operating Hours EC Fan #2"},      
-  {IR,        244,    0,  "Operating Hours EC Fan #3"},      
-  {IR,        235,    0,  "Operating Hours EC Fan #4"},      
-  {IR,        236,    0,  "Operating Hours EC Fan #5"},      
-  {IR,        245,    0,  "Operating Hours EC Fan #6"},      
-  {IR,        486,    0,  "Operating Hours EC Fan #7"},      
-  {IR,        487,    0,  "Operating Hours EC Fan #8"},      
-  {IR,        488,    0,  "Operating Hours EC Fan #9"},      
-  {COIL,      301,    0,  "ON/OFF Command By BMS"},        
-  {COIL,      302,    0,  "Enable Off By Supervisory"},    
-  {COIL,      264,    0,  "Alarm Reset"}                                  
-};
-//Size of modbus map used in FOR cycles, automatically calculated.
-
-/**
- * @brief The total number of entries in the `mb_map` array.
- * This is calculated at compile time and used for iterating over the map.
- */
-const int map_size = sizeof(mb_map) / sizeof(mb_map[0]);
-
-/** @brief The main loop update interval in milliseconds. */
-int interval = 250; 
-/** @} */ // End of ModbusMapConfig group
-
-#endif // CONFIG_H
diff --git a/src/BMS/Split_System/SS_Daiken_TCP/main.cpp b/src/BMS/Split_System/SS_Daiken_TCP/main.cpp
deleted file mode 100644
index 286a98c..0000000
--- a/src/BMS/Split_System/SS_Daiken_TCP/main.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-/**
- * @file main.cpp
- * @brief Main execution program for the CRAH Unit (TCP) Emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * @details This file contains the main execution program for an Arduino-based emulator of a CRAH unit. 
- * The program uses a Wi-Fi connection to communicate via the Modbus IP protocol.
- *
- * The setup() function initializes the following:
- * - Serial communication for debugging.
- * - Wi-Fi connection using credentials from config.h.
- * - A Modbus TCP server.
- * - Modbus points (Coils, Holding Registers, etc.) based on a predefined map in config.h.
- *
- * The loop() function continuously:
- * - Services the Modbus TCP server to handle incoming requests.
- * - Periodically calls the main update loop for the emulated equipment, which
- *   manages state transitions and behavior strategies.
- *
- * @see config.h for Wi-Fi and Modbus configuration.
- * @see Equipment.h for the main equipment logic.
- * @see State.h for different equipment states.
- * @see Strategies/Strategy_Behavior.h for value generation strategies.
- * @see Modbus_Point.h for the base class for all Modbus points.
- */
-//=================================================================================================================================
-//Libraries and declaration of variables.
-#include <WiFi.h>
-#include "config.h"
-#include "ModbusPoints/Modbus_PointFactory.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-//=================================================================================================================================
-/** 
- * @brief Initializes the application.
- * @details This function runs once at startup. It configures the serial communication, 
- * Wi-Fi, and the Modbus server. It also creates and initializes all the Modbus points 
- * based on the `mb_map` array in `config.h`.
- */
-void setup() {
-  Serial.begin(115200);                       //Serial comm start
-  WiFi.config(local_IP, gateway, subnet);     // Wifi service start
-  WiFi.begin(ssid, password);
-  while (WiFi.status() != WL_CONNECTED) {
-    delay(1000);
-    Serial.print(".");
-  }
-  Serial.println("Connected!!");
-  mb.server();                                //Modbus server start
-  Serial.println("Server Created");
-  Serial.println(map_size);
-  for(int i = 0; i < map_size; i++){
-    Modbus_Point<ModbusIP>* point = createModbus_Point(&mb, mb_map[i].category, mb_map[i].address, mb_map[i].value, mb_map[i].description);
-    if (point) {
-      point->addToModbusServer();
-      EquipmentInstance.addModbus_Point(mb_map[i].description, point);
-    }
-  }
-  Serial.println("All modbus Points created");
-  Serial.println("Setup function ended");
-}
-//=================================================================================================================================
-/** 
- * @brief The main application loop.
- * @details This function runs repeatedly after setup() has completed. It performs two main actions:
- * 1. It continuously services the Modbus server by calling `mb.task()` to handle
- *    incoming requests from a Modbus master.
- * 2. At a fixed interval (defined in `config.h`), it calls `EquipmentInstance.update()`
- *    to run the emulator's internal state machine and behavior logic.
- */
-void loop() {
-  mb.task();
-  unsigned long currentMillis = millis();
-  if (currentMillis - previousMillis >= interval) {
-    previousMillis = currentMillis;
-    unsigned long startTime = millis();
-    EquipmentInstance.update();
-    unsigned long endTime = millis();
-    unsigned long elapsedTime = endTime - startTime;
-    Serial.printf("Control Execution time: %d ms\n", elapsedTime);
-  } 
-}
diff --git a/src/BMS/VFD/PHX3_VFD_ABB_ACH580_RTU/README.md b/src/BMS/VFD/PHX3_VFD_ABB_ACH580_RTU/README.md
deleted file mode 100644
index 4a7c8ed..0000000
--- a/src/BMS/VFD/PHX3_VFD_ABB_ACH580_RTU/README.md
+++ /dev/null
@@ -1,40 +0,0 @@
-# VFD ABB ACH580 RTU
-
-## Brief Introduction
-This is based on a 50hp motor, 480V, 65 FLA, 60Hz, 1800 rpm (PHX3 DC1/2).
-Modbus addresses are based on 32-bit registers.
-
-## List of Equipment
-This configuration has been used for these models:
-* **ACH580**: 10-23-2025 (PHX3)
-
-## Hardware Prerequisites
-
-The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities and at least one hardware serial port for RS485 communication.
-
-* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html) 
-* **RS485 Transceiver**: [RS485 Shield for Arduino.](https://www.dfrobot.com/product-1024.html)
-
----
-
-## States and Strategies
-The hardwire IO signals to/from VFD/PLC are Start Cmd, Stop Cmd, Speed Command, Speed Feedback, Run Status, Fault Status.
-User needs to set the speed command (HR 150) in RPM from the PLC
-User needs to set the Start command (HR 151) from the PLC
-It appears these hard IO registers were arbitrarily chosen for the purpose of this Arduino simulation.
-The registers selected are based on FS Config file from CDR project. Run Status and Fault Status registers were added for simulation.
-
-### Standby State
-* **Equipment**: Equipment parameters go back to 0
-
-### Running State
-* **Ramp Strategy**: The following regisers will dynamically ramp based upon the Speed Cmd:
-* Motor Speed Used, Motor Speed estimated, Output Frequency, Motor Current, Motor Torque, DC Voltage, Output Voltage, Output Power
-* The logic is based on Affinity laws and nominal motor values stated in the Introduction section.
-* **Square Strategy**: Inverter Temperature switches between 40 and 80 based on inherited code.
-* **Totalizers Strategy**: Inverter kWh cnt, Hours Run
-
-### Fail State
-* Enters Fail State if Fault Status is set to 0.
-While in Fail State, the Start/Stop command is reset to 0.
-The only way to exit Fail State is if Fault Status = 1 --> Standby State.
\ No newline at end of file
diff --git a/src/BMS/VFD/PHX3_VFD_ABB_ACH580_RTU/State_Fail.cpp b/src/BMS/VFD/PHX3_VFD_ABB_ACH580_RTU/State_Fail.cpp
deleted file mode 100644
index f5c2588..0000000
--- a/src/BMS/VFD/PHX3_VFD_ABB_ACH580_RTU/State_Fail.cpp
+++ /dev/null
@@ -1,101 +0,0 @@
-/**
- * @file State_Fail.cpp
- * @brief Implementation of the FailState class.
- * @author Robert J Davis
- * @date 2025-10-30
- *
- * This file contains the implementation for the FailState, which defines
- * the behavior of the equipment when it has entered a fault condition.
- * 
- */
-#include "States/State_Standby.h"
-#include "States/State_Fail.h"
-#include "ModbusPoints/Modbus_Point.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_PID.h"
-
-#include <vector>
-#include <string>
-
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new FailState object.
- *
- * This constructor sets the associated analog signals to the same values as Standby.
- */
-template<>
-FailState<ModbusRTU>::FailState(const std::vector<std::string>& activeAlarms) {
-    addStrategy("Speed Feedback", new RampStrategy(0.0f, 200.0f, 1000 ));
-    addStrategy("Motor Current", new RampStrategy(0.0f, 20.0f, 1000 ));
-    addStrategy("Motor Torque", new RampStrategy(0.0f, 20.0f, 1000 ));
-    addStrategy("Inverter Temperature", new RampStrategy(0.0f, 1.0f, 1000 ));
-
-    addStrategy("Output Frequency", new SingleValueStrategy(0.1f, 0.2f, 1000 ));
-    addStrategy("Output Voltage", new SingleValueStrategy(0.1f, 0.1f, 1000 ));
-    addStrategy("DC Voltage", new SingleValueStrategy(0.1f, 0.1f, 1000 ));
-    addStrategy("Motor Shaft Power", new SingleValueStrategy(0.1f, 0.1f, 1000 ));
-
-    addStrategy("AI1 Scaled", new RampStrategy(0.0f, 2.0f, 1000 ));
-    addStrategy("AI2 Scaled", new RampStrategy(0.0f, 5.0f, 1000 ));
-    addStrategy("AO1 Actual", new RampStrategy(0.0f, 2.0f, 1000 ));
-}
-
-/**
- * @brief Executes the fail state's logic for one update cycle.
- *
- * While in FailState, the Unit cannot be started and the Start/Stop command is reset to 0.
- * When the fault is cleared --> Standby State.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusRTU>* FailState<ModbusRTU>::update(Equipment<ModbusRTU>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Fail update function");
-
-    int faultNotPresent = getPointValue(equipment, "Fault Status");
-    if(faultNotPresent == 1){
-        return new StandbyState<ModbusRTU>();
-    }
-    setPointValue(equipment, "Start/Stop", 0);
-    
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the fail state. Sets the Run Status to 0.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusRTU>::enterState(Equipment<ModbusRTU>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Fail State...");
-    setPointValue(equipment, "Speed Scaling", 1800);
-    setPointValue(equipment, "Frequency Scaling", 60);
-    setPointValue(equipment, "Nominal Current", 65);
-    setPointValue(equipment, "Nominal Voltage", 480);
-    setPointValue(equipment, "Nominal Frequency", 60);
-    setPointValue(equipment, "Nominal Speed", 1800);
-    setPointValue(equipment, "Nominal Power", 50);
-    setPointValue(equipment, "Run Status", 0);
-    setPointValue(equipment, "DI Status", 0);
-}
-
-/**
- * @brief Logic to execute once when exiting the fail state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusRTU>::exitState(Equipment<ModbusRTU>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Fail State...");
-}
\ No newline at end of file
diff --git a/src/BMS/VFD/PHX3_VFD_ABB_ACH580_RTU/State_Running.cpp b/src/BMS/VFD/PHX3_VFD_ABB_ACH580_RTU/State_Running.cpp
deleted file mode 100644
index 83dfa41..0000000
--- a/src/BMS/VFD/PHX3_VFD_ABB_ACH580_RTU/State_Running.cpp
+++ /dev/null
@@ -1,188 +0,0 @@
-/**
- * @file State_Running.cpp
- * @brief Implementation of the RunningState class.
- * @author Robert J Davis
- * @date 2025-10-22
- *
- * This file contains the implementation for the RunningState, which defines
- * the behavior of the equipment when it is actively running.
- */
-
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "Strategies/Strategy_Behavior.h"
-#include "Strategies/Strategy_PID.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Totalizer.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_Square.h"
-#include "Equipment/Equipment.h"
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-
-#include <vector>
-#include <string>
-
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new RunningState object.
- *
- * This constructor initializes behavior strategies active during the running
- * state, such as speed feedback, current, torque, hours run, etc.
- * These values are based on a 50hp motor, 480V, 65 FLA, 60Hz, 1800 rpm (PHX3 DC1/2)
- */
-template<>
-RunningState<ModbusRTU>::RunningState() {
-    addStrategy("Speed Feedback", new RampStrategy(1800.0f, 100.0f, 1000));
-    addStrategy("Motor Current", new RampStrategy(65.0f, 7.0f, 1000));
-    addStrategy("Motor Torque", new RampStrategy(90.0f, 10.0f, 1000));
-    addStrategy("Inverter Temperature", new RampStrategy(70.0f, 1.0f, 1000));
-
-    addStrategy("Output Frequency", new RampStrategy(60.0f, 3.0f, 1000 ));
-    addStrategy("Output Voltage", new RampStrategy(480.0f, 15.0f, 1000 ));
-    addStrategy("DC Voltage", new RampStrategy(678.0f, 20.0f, 1000 ));
-    addStrategy("Motor Shaft Power", new RampStrategy(36.7f, 2.0f, 1000 ));
-    addStrategy("Inverter MWh counter", new TotalizerStrategy(5000));
-    addStrategy("Inverter kWh counter", new TotalizerStrategy(5000));
-
-    addStrategy("AI1 Scaled", new RampStrategy(10.0f, 1.0f, 1000 ));
-    addStrategy("AI2 Scaled", new RampStrategy(20.0f, 1.0f, 1000 ));
-    addStrategy("AO1 Actual", new RampStrategy(10.0f, 1.0f, 1000 ));
-}
-
-/**
- * @brief Executes the running state's logic for one update cycle.
- *
- * This method first checks for state transition commands:
- * 1. If Fault is 0 (there is a fault present) --> FailState
- * 2. It reads the "Stop/Start" command point (from PLC). If it's 0, it transitions to StandbyState.
- *
- * If no transition occurs, it updates values according to speed setpoint sent from PLC.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusRTU>* RunningState<ModbusRTU>::update(Equipment<ModbusRTU>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Running update function");
-
-    // If Fault Status = 0, there is a fault --> FailState
-    int faultNotPresent = getPointValue(equipment, "Fault Status");
-    if(faultNotPresent == 0){
-        return new FailState<ModbusRTU>({"Fault Status"});
-    }
-
-    int VFD_Start_Stop = getPointValue(equipment, "Start/Stop");
-    if (VFD_Start_Stop == 0){
-        return new StandbyState<ModbusRTU>();
-    }
-
-    float speed_pct = getPointValue(equipment, "Speed Cmd") / 1800.0f;
-    // Based on Affinity Laws. Motor: 65 FLA, 480V, 60Hz, 1800 rpm, 50hp
-    float voltage_update = speed_pct * 480;
-    float dc_voltage_update = speed_pct * 678;
-    float current_update = speed_pct * speed_pct * 65;
-    float torque_update = speed_pct * speed_pct * 100 * 10;       // This is a % of nominal motor torque, x10 b/c is scaled by 100 in actual equipment, this register is only 10x
-    float freq_update = speed_pct * 60;
-    float power_update = speed_pct * speed_pct * speed_pct * 36.77f;    // 50 hp ~ 36.77kW
-    
-    float currentSP = getPointValue(equipment, "Speed Cmd");
-    float AI1_update = speed_pct *10;
-    float AI2_update = speed_pct *20;
-    float AO1_update = speed_pct *10;
-
-    Strategy_Behavior* speedFeedback = getStrategy("Speed Feedback");
-    if (speedFeedback) {
-        static_cast<RampStrategy*>(speedFeedback)->setTarget(currentSP);
-    }
-
-    Strategy_Behavior* frequencystrategy = getStrategy("Output Frequency");
-    if (frequencystrategy) {
-        static_cast<RampStrategy*>(frequencystrategy)->setTarget(freq_update);
-    }
-
-    Strategy_Behavior* currentstrategy = getStrategy("Motor Current");
-    if (currentstrategy) {
-        static_cast<RampStrategy*>(currentstrategy)->setTarget(current_update);
-    }
-    
-    Strategy_Behavior* torquestrategy = getStrategy("Motor Torque");
-    if (torquestrategy) {
-        static_cast<RampStrategy*>(torquestrategy)->setTarget(torque_update);
-    }
-
-    Strategy_Behavior* dcvoltagestrategy = getStrategy("DC Voltage");
-    if (dcvoltagestrategy) {
-        static_cast<RampStrategy*>(dcvoltagestrategy)->setTarget(dc_voltage_update);
-    }
-
-    Strategy_Behavior* voltagestrategy = getStrategy("Output Voltage");
-    if (voltagestrategy) {
-        static_cast<RampStrategy*>(voltagestrategy)->setTarget(voltage_update);
-    }
-
-    Strategy_Behavior* powerstrategy = getStrategy("Motor Shaft Power");
-    if (powerstrategy) {
-        static_cast<RampStrategy*>(powerstrategy)->setTarget(power_update);
-    }
-
-    Strategy_Behavior* AI1strategy = getStrategy("AI1 Scaled");
-    if (AI1strategy) {
-        static_cast<RampStrategy*>(AI1strategy)->setTarget(AI1_update);
-    }
-
-    Strategy_Behavior* AI2strategy = getStrategy("AI2 Scaled");
-    if (AI2strategy) {
-        static_cast<RampStrategy*>(AI2strategy)->setTarget(AI2_update);
-    }
-
-    Strategy_Behavior* AO1strategy = getStrategy("AO1 Actual");
-    if (AO1strategy) {
-        static_cast<RampStrategy*>(AO1strategy)->setTarget(AO1_update);
-    }
-    
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the running state.
- * Sets the Run Status" point to indicate the unit is running.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusRTU>::enterState(Equipment<ModbusRTU>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Running State...");
-    setPointValue(equipment, "Speed Scaling", 1800);
-    setPointValue(equipment, "Frequency Scaling", 60);
-    setPointValue(equipment, "Nominal Current", 65);
-    setPointValue(equipment, "Nominal Voltage", 480);
-    setPointValue(equipment, "Nominal Frequency", 60);
-    setPointValue(equipment, "Nominal Speed", 1800);
-    setPointValue(equipment, "Nominal Power", 50);
-    setPointValue(equipment, "Run Status", 1);
-    setPointValue(equipment, "DI Status", 1);
-}
-
-/**
- * @brief Logic to execute once when exiting the running state.
- * Sets the "Output Frequency" to 0.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusRTU>::exitState(Equipment<ModbusRTU>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Running State...");
-    setPointValue(equipment, "Output Frequency", 0.0f);
-}
\ No newline at end of file
diff --git a/src/BMS/VFD/PHX3_VFD_ABB_ACH580_RTU/State_Standby.cpp b/src/BMS/VFD/PHX3_VFD_ABB_ACH580_RTU/State_Standby.cpp
deleted file mode 100644
index 3b5185f..0000000
--- a/src/BMS/VFD/PHX3_VFD_ABB_ACH580_RTU/State_Standby.cpp
+++ /dev/null
@@ -1,108 +0,0 @@
-/**
- * @file State_Standby.cpp
- * @brief Implementation of the StandbyState class.
- * @author Robert J Davis
- * @date 2025-10-23
- *
- * This file contains the implementation for the StandbyState, which defines
- * the behavior of the equipment when it is in an idle or standby mode.
- */
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new StandbyState object.
- *
- * In this state, the equipment is idle. This constructor initializes several
- * strategies to simulate a live but non-operational unit. Most values are ramped down to 0.
- */
-template<>
-StandbyState<ModbusRTU>::StandbyState() {
-    addStrategy("Speed Feedback", new RampStrategy(0.0f, 200.0f, 1000 ));
-    addStrategy("Motor Current", new RampStrategy(0.0f, 20.0f, 1000 ));
-    addStrategy("Motor Torque", new RampStrategy(0.0f, 20.0f, 1000 ));
-    addStrategy("Inverter Temperature", new RampStrategy(0.0f, 1.0f, 1000 ));
-    
-    addStrategy("Output Frequency", new SingleValueStrategy(0.1f, 0.2f, 1000 ));
-    addStrategy("Output Voltage", new SingleValueStrategy(0.1f, 0.1f, 1000 ));
-    addStrategy("DC Voltage", new SingleValueStrategy(0.1f, 0.1f, 1000 ));
-    addStrategy("Motor Shaft Power", new SingleValueStrategy(0.1f, 0.1f, 1000 ));
-
-    addStrategy("AI1 Scaled", new RampStrategy(0.0f, 2.0f, 1000 ));
-    addStrategy("AI2 Scaled", new RampStrategy(0.0f, 5.0f, 1000 ));
-    addStrategy("AO1 Actual", new RampStrategy(0.0f, 2.0f, 1000 ));
-}
-
-/**
- * @brief Executes the standby state's logic for one update cycle.
- *
- * This method first checks for state transition commands:
- * 1. If Fault is 0 (there is a fault present) --> FailState
- * 2. It reads the "Start/Stop" point (from PLC). If it's 1 --> RunningState
- * 
- * If no transition is requested, it applies the strategies defined for the standby state.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusRTU>* StandbyState<ModbusRTU>::update(Equipment<ModbusRTU>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Standby update function");
-
-    // If Fault Status = 0, there is a fault --> FailState
-    int faultNotPresent = getPointValue(equipment, "Fault Status");
-    if(faultNotPresent == 0){
-        return new FailState<ModbusRTU>({"Fault Status"});
-    }
-
-    int VFD_Start_Stop = getPointValue(equipment, "Start/Stop");
-    if (VFD_Start_Stop == 1){
-        return new RunningState<ModbusRTU>();
-    }
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the standby state.
- * Sets the "Run Status" point to indicate the unit is not running.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusRTU>::enterState(Equipment<ModbusRTU>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Standby State...");
-    setPointValue(equipment, "Speed Scaling", 1800);
-    setPointValue(equipment, "Frequency Scaling", 60);
-    setPointValue(equipment, "Nominal Current", 65);
-    setPointValue(equipment, "Nominal Voltage", 480);
-    setPointValue(equipment, "Nominal Frequency", 60);
-    setPointValue(equipment, "Nominal Speed", 1800);
-    setPointValue(equipment, "Nominal Power", 50);
-    setPointValue(equipment, "Run Status", 0);
-    setPointValue(equipment, "DI Status", 0);
-}
-
-/**
- * @brief Logic to execute once when exiting the standby state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusRTU>::exitState(Equipment<ModbusRTU>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-   
-}
\ No newline at end of file
diff --git a/src/BMS/VFD/PHX3_VFD_ABB_ACH580_RTU/config.h b/src/BMS/VFD/PHX3_VFD_ABB_ACH580_RTU/config.h
deleted file mode 100644
index 9aaac3f..0000000
--- a/src/BMS/VFD/PHX3_VFD_ABB_ACH580_RTU/config.h
+++ /dev/null
@@ -1,104 +0,0 @@
-/**
- * @file config.h
- * @brief Main configuration file for the ABB ACH580 VFD (RTU) emulator.
- * @author Robert J Davis
- * @date 2025-10-22
- *
- * This file contains important configurations for the Modbus RTU communication
- * and the specific register map for the emulated device.
- * These are 16-bit modbus registers.
- * Added "Run Status" and "Fault Status" to simulated hard IO points and send feedback to PLC during simulation.
- */
-
-#ifndef CONFIG_H
-#define CONFIG_H
-#include <ModbusRTU.h>
-#include "core.h"
-#include "Equipment/Equipment.h"
-
-
-#if defined(USE_MODBUS_IP)
-/**
-   * @defgroup ModbusTCPConfig Modbus IP Configuration
-   * @brief Parameters for Modbus TCP communication.
-   * @{
-   */
-  #include <ModbusIP_ESP8266.h>
-  const char *ssid = "wifi_name";       /**< @brief The SSID of the WiFi network. */
-  const char *password = "wifi_password";   /**< @brief The password for the WiFi network. */
-  IPAddress local_IP(192, 168, 1, 234);       /**< @brief The static IP address for the device. */
-  IPAddress gateway(192, 168, 1, 1);          /**< @brief The gateway IP address. */
-  IPAddress subnet(255, 255, 255, 0);         /**< @brief The subnet mask. */
-  
-  ModbusIP mb;
-#else
-  /**
-   * @defgroup ModbusRTUConfig Modbus RTU Configuration
-   * @brief Parameters for serial Modbus RTU communication.
-   * @{
-   */
-  #include <ModbusRTU.h>
-  const int BAUDRATE = 19200;   /**< @brief The serial communication speed in bits per second. */
-  const int RX_PIN = 17;        /**< @brief The GPIO pin used for receiving data (RX). */
-  const int TX_PIN = 16;        /**< @brief The GPIO pin used for transmitting data (TX). */
-  const int RST_PIN = 4;        /**< @brief The GPIO pin connected to the RS485 driver's DE/RE pins for direction control. */
-  const int MODBUS_ID = 1;      /**< @brief The unique slave ID for this device on the Modbus bus. */
-  /** @} */
-
-  /** @brief Global instance of the Modbus RTU server. */
-  ModbusRTU mb;
-#endif
-
-/**
- * @brief The Modbus map for the Equipment device.
- * This array defines all the Modbus points available on the emulated device.
- * The `description` field is crucial as it's used to look up points within the application logic.
- */
-modbusMap mb_map[] =
-{           
-  {HR,        149,    1650,   "Speed Cmd"},                       // arbitrary register number - receive signal from PLC (hardwire IO in field); expecting rpm (1800 rpm max)
-  {HR,        151,    1,      "Start/Stop"},                      // arbitrary register number - receive signal from PLC (hardwire IO in practice)
-  {HR,        152,    0,      "HOA Command"},                     // arbitrary register number - not used in program
-  {HR,        154,    0,      "Run Status"},                      // arbitrary register number - 0:off, 1:on (simulated hardwire IO) sending feedback to PLC during simulation.
-  {HR,        155,    1,      "Fault Status"},                    // arbitrary register number - 0:faulted, 1:not faulted (simulated hardwire IO). When = 0, will turn off VFD.
-  // {HR,        156,    0,      "Speed Feedback"},                  // arbitrary register number - send signal to PLC (simulated hardwire IO). Will be equal to Motor Speed Used register
-
-  {HR,        100,    0,  "Speed Feedback"},                  // 1800 rpm max
-  {HR,        105,    0,  "Output Frequency"},                // 60 Hz @100% speed
-  {HR,        106,    0,  "Motor Current"},                   // 65 FLA
-  {HR_10x,    109,    0,  "Motor Torque"},                    // % of nominal torque
-  {HR_10x,    110,    0,  "DC Voltage"},                      // approx 678 VDC @100% speed
-  {HR,        112,    0,  "Output Voltage"},                  // 480 VAC
-  {HR_10x,    116,    0,  "Motor Shaft Power"},               // 50 hp ~ 36.77 kW              
-  {HR,        118,    0,  "Inverter MWh counter"},
-  {HR,        119,    0,  "Inverter kWh counter"},  
-  {HR,        510,    0,  "Inverter Temperature"},            // RJD: Changed from HR_10x to HR, % of fault limit  
-  {HR,        519,    0,  "Diagnostic Word"},                 // not used in program. Bit 9:Drive Over-Temp Alarm
-  
-  {HR,        1000,   0,  "DI Status"},                       // Bit 0: input 1, Bit 1: Input 2
-  {HR,        1211,   0,  "AI1 Scaled"},                      // output frequency/speed reference, 0-10V
-  {HR,        1221,   0,  "AI2 Scaled"},                      // actual feedback 0-20mA
-  {HR,        1310,   0,  "AO1 Actual"},                      // output frequency 0-10V
-  {HR,        1910,   0,  "External Control Location"},       // not used in program. Bit 13, 0:false, 1:true
-  {HR,        4600,   1800,  "Speed Scaling"},                // 1800 rpm
-  {HR,        4601,   60,  "Frequency Scaling"},              // 60 Hz
-  {HR,        9905,   65,  "Nominal Current"},                // 65 A
-  {HR_10x,    9906,   4800,  "Nominal Voltage"},               // 480 V
-  {HR_10x,    9907,   600,  "Nominal Frequency"},              // 60 Hz
-  {HR,        9908,   1800,  "Nominal Speed"},                // 1800 rpm
-  {HR_10x,    9909,   500,  "Nominal Power"},                  // 50 hp
-
-};
-//Size of modbus map used in FOR cycles, automatically calculated.
-/**
- * @brief The total number of entries in the `mb_map` array.
- * This is calculated at compile time and used for iterating over the map.
- */
-const int map_size = sizeof(mb_map) / sizeof(mb_map[0]);
-
-/**
- * @brief The main loop update interval in milliseconds.
- */
-int interval = 250; 
-
-#endif // CONFIG_H
diff --git a/src/BMS/VFD/PHX3_VFD_ABB_ACH580_RTU/main.cpp b/src/BMS/VFD/PHX3_VFD_ABB_ACH580_RTU/main.cpp
deleted file mode 100644
index a77f9b2..0000000
--- a/src/BMS/VFD/PHX3_VFD_ABB_ACH580_RTU/main.cpp
+++ /dev/null
@@ -1,78 +0,0 @@
-/**
- * @file main.cpp
- * @brief Main execution program for the ABB ACH580 VFD (RTU) Emulator.
- * @author Emmanuel Hernandez Cruz, Robert J Davis
- * @date 2025-09-02
- *
- * @details This file contains the main execution program for an Arduino-based
- * emulator of a ABB ACH580 VFD unit. The program communicates via the
- * Modbus RTU protocol over a serial connection.
- *
- * The setup() function initializes the following:
- * - Serial communication for debugging.
- * - A Modbus RTU server with parameters from config.h.
- * - Modbus points (Coils, Holding Registers, etc.) based on a predefined map in config.h.
- *
- * The loop() function continuously:
- * - Services the Modbus RTU server to handle incoming requests.
- * - Periodically calls the main update loop for the emulated equipment, which
- *   manages state transitions and behavior strategies.
- *
- * @see config.h for Modbus RTU and register map configuration.
- * @see Equipment.h for the main equipment logic.
- * @see State.h for different equipment states.
- * @see Strategies/Strategy_Behavior.h for value generation strategies.
- * @see Modbus_Point.h for the base class for all Modbus points.
- */
-//=================================================================================================================================
-//Libraries and declaration of variables.
-#include <Arduino.h>
-#include "config.h"
-#include "ModbusPoints/Modbus_PointFactory.h"
-
-//=================================================================================================================================
-/** 
- * @brief Initializes the application.
- * @details This function runs once at startup. It configures the serial communication
- * for debugging and the Modbus RTU server. It then creates and initializes all
- * the Modbus points based on the `mb_map` array in `config.h`.
- */
-const int rtsPin = 4;
-void setup() {
-  Serial.begin(115200);
-  Serial.println("Setup function started");
-
-  Serial2.begin(BAUDRATE, SERIAL_8N1, RX_PIN, TX_PIN);
-  mb.begin(&Serial2, RST_PIN); // Start the server
-  mb.slave(MODBUS_ID); // Set the slave ID
-   
-  for(int i = 0; i < map_size; i++){
-    Modbus_Point<ModbusRTU>* point = createModbus_Point(&mb, mb_map[i].category, mb_map[i].address, mb_map[i].value, mb_map[i].description);
-    if (point) {
-      point->addToModbusServer();
-      EquipmentInstance.addModbus_Point(mb_map[i].description, point);
-    }
-  }
-  Serial.println("Setup function ended"); 
-}
-//=================================================================================================================================
-/** 
- * @brief The main application loop.
- * @details This function runs repeatedly after setup() has completed. It performs two main actions:
- * 1. It continuously services the Modbus server by calling `mb.task()` to handle
- *    incoming requests from a Modbus master.
- * 2. At a fixed interval (defined in `config.h`), it calls `EquipmentInstance.update()`
- *    to run the emulator's internal state machine and behavior logic.
- */
-void loop() {
-  mb.task();
-  unsigned long currentMillis = millis();
-  if (currentMillis - previousMillis >= interval) {
-    previousMillis = currentMillis;
-    unsigned long startTime = millis();
-    EquipmentInstance.update();
-    unsigned long endTime = millis();
-    unsigned long elapsedTime = endTime - startTime;
-    Serial.printf("Control Execution time: %d ms\n", elapsedTime);
-  } 
-}
diff --git a/src/BMS/VFD/VFD_ABB_ACH580_RTU/README.md b/src/BMS/VFD/VFD_ABB_ACH580_RTU/README.md
deleted file mode 100644
index 630cf02..0000000
--- a/src/BMS/VFD/VFD_ABB_ACH580_RTU/README.md
+++ /dev/null
@@ -1,35 +0,0 @@
-# EQUIPMENT_TYPE MANUFACTURER MODEL RTU
-
-## Brief Introduction
-Equipment specifc details that make it different from other devices
-
-## List of Equipmentt
-This cofiguration has been used for these models:
-* **Model**: 09-15-22 
-* **Model**: 09-15-23 
-* **Model**: 09-15-25 
-
-## Hardware Prerequisites
-
-The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities and at least one hardware serial port for RS485 communication.
-
-* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html) 
-* **RS485 Transceiver**: [RS485 Shield for Arduino.](https://www.dfrobot.com/product-1024.html)
-
----
-
-## States and Strategies
-Provide a brief description of what variables and strategies were used in this configuraiton
-
-### Standby State
-* **Equipment running**: set to 0
-* **Common Alarm**: set to 0
-* **SAT temperature**: set to 85
-
-### Running State
-* **Equipment running**: set to 1
-* **SAT temperature**: **Ramp Strategy** set to 65 deg setpoint
-
-### Fail State
-* **Commong Alarm**: set to 1
-* **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset
diff --git a/src/BMS/VFD/VFD_ABB_ACH580_RTU/State_Fail.cpp b/src/BMS/VFD/VFD_ABB_ACH580_RTU/State_Fail.cpp
deleted file mode 100644
index 6d85f9a..0000000
--- a/src/BMS/VFD/VFD_ABB_ACH580_RTU/State_Fail.cpp
+++ /dev/null
@@ -1,77 +0,0 @@
-/**
- * @file State_Fail.cpp
- * @brief Implementation of the FailState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the FailState, which defines
- * the behavior of the equipment when it has entered a fault condition.
- */
-#include "States/State_Standby.h"
-#include "States/State_Fail.h"
-#include "ModbusPoints/Modbus_Point.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_PID.h"
-
-#include <vector>
-#include <string>
-
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new FailState object.
- *
- * This constructor receives a list of alarm descriptions and creates strategies
- * to set the corresponding Modbus points to a value of 1, indicating an
- * active alarm. It also initializes a PID strategy for the valve position.
- */
-template<>
-FailState<ModbusRTU>::FailState(const std::vector<std::string>& activeAlarms) {
-    // Simulate a failure: set common alarm and a specific fan alarm.
-}
-
-/**
- * @brief Executes the fail state's logic for one update cycle.
- *
- * This method checks the "Clear Alm" Modbus point for a command to transition
- * back to Standby, which would typically happen after a fault is cleared by a
- * user. If no transition is requested, it continues to apply the failure strategies.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusRTU>* FailState<ModbusRTU>::update(Equipment<ModbusRTU>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Fail update function");
-    
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the fail state. Sets the main alarm bit.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusRTU>::enterState(Equipment<ModbusRTU>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Fail State...");
-    
-}
-
-/**
- * @brief Logic to execute once when exiting the fail state. Clears the main alarm bit.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusRTU>::exitState(Equipment<ModbusRTU>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Fail State...");
-    
-}
\ No newline at end of file
diff --git a/src/BMS/VFD/VFD_ABB_ACH580_RTU/State_Running.cpp b/src/BMS/VFD/VFD_ABB_ACH580_RTU/State_Running.cpp
deleted file mode 100644
index b94536c..0000000
--- a/src/BMS/VFD/VFD_ABB_ACH580_RTU/State_Running.cpp
+++ /dev/null
@@ -1,128 +0,0 @@
-/**
- * @file State_Running.cpp
- * @brief Implementation of the RunningState class.
- * @author Emmanuel Hernandez Cruz, Robert J Davis
- * @date 2025-10-22
- *
- * This file contains the implementation for the RunningState, which defines
- * the behavior of the equipment when it is actively running.
- */
-
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "Strategies/Strategy_Behavior.h"
-#include "Strategies/Strategy_PID.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Totalizer.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_Square.h"
-#include "Equipment/Equipment.h"
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-
-#include <vector>
-#include <string>
-
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new RunningState object.
- *
- * This constructor initializes behavior strategies active during the running
- * state, such as a PID controller for the 'CW Valve Position' and totalizers
- * for the run-hours of each EC fan.
- */
-template<>
-RunningState<ModbusRTU>::RunningState() {
-    addStrategy("Inverter Temperature", new SquareStrategy(40.0f, 80.0f, 1000));
-    addStrategy("Motor Speed Used", new RampStrategy(100.0f, 10.0f, 1000));
-    addStrategy("Motor Speed Estimated", new RampStrategy(80.0f, 10.0f, 1000));
-    addStrategy("Motor Current", new RampStrategy(65.0f, 2.0f, 1000));
-    addStrategy("Motor Torque", new RampStrategy(200.0f, 10.0f, 1000));
-}
-
-/**
- * @brief Executes the running state's logic for one update cycle.
- *
- * This method first checks for state transition commands:
- * 1. It reads the "ON/OFF Command By BMS" point. If it's 0, it transitions to StandbyState.
- * 2. It reads the "Fault Code" point. If it's non-zero, it transitions to FailState,
- *    passing the corresponding alarm description.
- *
- * If no transition occurs, it applies the strategies defined for the running state.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusRTU>* RunningState<ModbusRTU>::update(Equipment<ModbusRTU>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Running update function");
-    int VFD_Start_Stop = getPointValue(equipment, "Start/Stop");
-    if (VFD_Start_Stop == 0){
-        return new StandbyState<ModbusRTU>();
-    }
-    float currentSP = getPointValue(equipment, "Speed Cmd");
-    Strategy_Behavior* motorstrategy = getStrategy("Motor Speed Used");
-    // 2. Check if the strategy exists and is a PID type.
-    if (motorstrategy) {
-        // 3. Cast it to a PIDStrategy pointer and call setSetpoint.
-        static_cast<RampStrategy*>(motorstrategy)->setTarget(currentSP);
-    }
-    float rpm = currentSP *200;
-    Strategy_Behavior* speedstrategy = getStrategy("Motor Speed estimated");
-    // 2. Check if the strategy exists and is a PID type.
-    if (speedstrategy) {
-        // 3. Cast it to a PIDStrategy pointer and call setSetpoint.
-        static_cast<RampStrategy*>(speedstrategy)->setTarget(rpm);
-    }
-    float current = currentSP *0.9;
-    Strategy_Behavior* currentstrategy = getStrategy("Motor Current");
-    // 2. Check if the strategy exists and is a PID type.
-    if (currentstrategy) {
-        // 3. Cast it to a PIDStrategy pointer and call setSetpoint.
-        static_cast<RampStrategy*>(currentstrategy)->setTarget(current);
-    }
-    float torque = currentSP * 372.85f;
-    Strategy_Behavior* torquestrategy = getStrategy("Motor Torque");
-    // 2. Check if the strategy exists and is a PID type.
-    if (torquestrategy) {
-        // 3. Cast it to a PIDStrategy pointer and call setSetpoint.
-        static_cast<RampStrategy*>(torquestrategy)->setTarget(torque);
-    }
-    
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the running state.
- * Sets the "Chiller Sts" point to indicate the unit is running.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusRTU>::enterState(Equipment<ModbusRTU>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Running State...");
-    
-}
-
-/**
- * @brief Logic to execute once when exiting the running state.
- * Sets the "Chiller Sts" point to indicate the unit is no longer running.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusRTU>::exitState(Equipment<ModbusRTU>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Running State...");
-    setPointValue(equipment, "Output Frequency", 0.0f);
-}
\ No newline at end of file
diff --git a/src/BMS/VFD/VFD_ABB_ACH580_RTU/State_Standby.cpp b/src/BMS/VFD/VFD_ABB_ACH580_RTU/State_Standby.cpp
deleted file mode 100644
index 50a13d1..0000000
--- a/src/BMS/VFD/VFD_ABB_ACH580_RTU/State_Standby.cpp
+++ /dev/null
@@ -1,88 +0,0 @@
-/**
- * @file State_Standby.cpp
- * @brief Implementation of the StandbyState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the StandbyState, which defines
- * the behavior of the equipment when it is in an idle or standby mode.
- */
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new StandbyState object.
- *
- * In this state, the equipment is idle. This constructor initializes several
- * strategies to generate random values for various status points, simulating
- * a live but non-operational unit.
- */
-template<>
-StandbyState<ModbusRTU>::StandbyState() {
-    addStrategy("Output Frequency", new SingleValueStrategy(0.1f, 0.2f, 1000 ));
-    addStrategy("Output Voltage", new SingleValueStrategy(0.1f, 0.1f, 1000 ));
-    
-    addStrategy("Motor Speed Used", new RampStrategy(0.0f, 10.0f, 1000 ));
-    addStrategy("Motor Speed estimated", new RampStrategy(0.0f, 200.0f, 1000 ));
-    addStrategy("Motor Current", new RampStrategy(0.0f, 20.0f, 1000 ));
-    addStrategy("Motor Torque", new RampStrategy(0.0f, 20.0f, 1000 ));
-    addStrategy("Inverter Temperature", new RampStrategy(120.0f, 0.5f, 1000 ));
-
-}
-
-/**
- * @brief Executes the standby state's logic for one update cycle.
- *
- * This method checks the "Chiller On-Off" Modbus point for a command to
- * transition to the Running state. If no transition is requested, it applies
- * the strategies defined for the standby state.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusRTU>* StandbyState<ModbusRTU>::update(Equipment<ModbusRTU>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Standby update function");
-    int VFD_Start_Stop = getPointValue(equipment, "Start/Stop");
-    if (VFD_Start_Stop == 1){
-        return new RunningState<ModbusRTU>();
-    }
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the standby state.
- * Sets the "Chiller Sts" point to indicate the unit is not running.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusRTU>::enterState(Equipment<ModbusRTU>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Standby State...");
-   
-}
-
-/**
- * @brief Logic to execute once when exiting the standby state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusRTU>::exitState(Equipment<ModbusRTU>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-   
-}
\ No newline at end of file
diff --git a/src/BMS/VFD/VFD_ABB_ACH580_RTU/config.h b/src/BMS/VFD/VFD_ABB_ACH580_RTU/config.h
deleted file mode 100644
index ed8d18b..0000000
--- a/src/BMS/VFD/VFD_ABB_ACH580_RTU/config.h
+++ /dev/null
@@ -1,100 +0,0 @@
-/**
- * @file config.h
- * @brief Main configuration file for the Daikin Chiller (RTU) emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * This file contains important configurations for the Modbus RTU communication
- * and the specific register map for the emulated device.
- */
-
-#ifndef CONFIG_H
-#define CONFIG_H
-#include <ModbusRTU.h>
-#include "core.h"
-#include "Equipment/Equipment.h"
-
-
-#if defined(USE_MODBUS_IP)
-/**
-   * @defgroup ModbusTCPConfig Modbus IP Configuration
-   * @brief Parameters for Modbus TCP communication.
-   * @{
-   */
-  #include <ModbusIP_ESP8266.h>
-  const char *ssid = "wifi_name";       /**< @brief The SSID of the WiFi network. */
-  const char *password = "wifi_password";   /**< @brief The password for the WiFi network. */
-  IPAddress local_IP(192, 168, 1, 234);       /**< @brief The static IP address for the device. */
-  IPAddress gateway(192, 168, 1, 1);          /**< @brief The gateway IP address. */
-  IPAddress subnet(255, 255, 255, 0);         /**< @brief The subnet mask. */
-  
-  ModbusIP mb;
-#else
-  /**
-   * @defgroup ModbusRTUConfig Modbus RTU Configuration
-   * @brief Parameters for serial Modbus RTU communication.
-   * @{
-   */
-  #include <ModbusRTU.h>
-  const int BAUDRATE = 19200;   /**< @brief The serial communication speed in bits per second. */
-  const int RX_PIN = 17;        /**< @brief The GPIO pin used for receiving data (RX). */
-  const int TX_PIN = 16;        /**< @brief The GPIO pin used for transmitting data (TX). */
-  const int RST_PIN = 4;        /**< @brief The GPIO pin connected to the RS485 driver's DE/RE pins for direction control. */
-  const int MODBUS_ID = 1;      /**< @brief The unique slave ID for this device on the Modbus bus. */
-  /** @} */
-
-  /** @brief Global instance of the Modbus RTU server. */
-  ModbusRTU mb;
-#endif
-
-/**
- * @brief The Modbus map for the Equipment device.
- * This array defines all the Modbus points available on the emulated device.
- * The `description` field is crucial as it's used to look up points within the application logic.
- */
-modbusMap mb_map[] =
-{           
-  {HR,        149,    0,  "Speed Cmd"}, 
-  {HR,        151,    0,  "Start/Stop"}, 
-  {HR,        152,    0,  "HOA Command"}, 
-  {HR,        100,    0,  "Motor Speed Used"},                   
-  {HR,        101,    0,  "Motor Speed estimated"},                   
-  {HR_10x,    105,    0,  "Output Frequency"},                             
-  {HR_10x,    106,    0,  "Motor Current"},                
-  {HR_10x,    109,    0,  "Motor Torque"},
-  {HR_10x,    110,    0,  "DC Voltage"},
-  {HR,        112,    0,  "Output Voltage"},
-  {HR_10x,    113,    0,  "Output Power"},  //max 372580
-  {HR_10x,    119,    0,  "Inverter kWh cnt"},
-  
-  {HR,        502,    0,  "Hours Run"},
-  {HR_10x,    510,    0,  "Inverter Temperature"},
-  {HR,        521,    0,  "HOA Status Word"},
-
-  {HR,        410,    0,  "Last Fault"},
-  {HR,        411,    0,  "2nd to last Fault"},
-  {HR,        412,    0,  "3rd to last Fault"},  
-  {HR,        439,    0,  "Event Word Param"},
-  
-  {HR,        610,    0,  "Status Word 1"},
-  {HR,        615,    0,  "Status Word 2"},
-  {HR,        616,    0,  "Status Word 3"},
-  {HR,        617,    0,  "Status Word 4"},
-  {HR,        618,    0,  "Status Word 5"},
-  {HR,        619,    0,  "Status Word 6"},
-  {HR,        620,    0,  "Status Word 7"},
-  {HR,        621,    0,  "Status Word 8"},
-};
-//Size of modbus map used in FOR cycles, automatically calculated.
-/**
- * @brief The total number of entries in the `mb_map` array.
- * This is calculated at compile time and used for iterating over the map.
- */
-const int map_size = sizeof(mb_map) / sizeof(mb_map[0]);
-
-/**
- * @brief The main loop update interval in milliseconds.
- */
-int interval = 250; 
-
-#endif // CONFIG_H
diff --git a/src/BMS/VFD/VFD_ABB_ACH580_RTU/main.cpp b/src/BMS/VFD/VFD_ABB_ACH580_RTU/main.cpp
deleted file mode 100644
index 5dbc9f1..0000000
--- a/src/BMS/VFD/VFD_ABB_ACH580_RTU/main.cpp
+++ /dev/null
@@ -1,78 +0,0 @@
-/**
- * @file main.cpp
- * @brief Main execution program for the Daikin Chiller (RTU) Emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * @details This file contains the main execution program for an Arduino-based
- * emulator of a Daikin Chiller unit. The program communicates via the
- * Modbus RTU protocol over a serial connection.
- *
- * The setup() function initializes the following:
- * - Serial communication for debugging.
- * - A Modbus RTU server with parameters from config.h.
- * - Modbus points (Coils, Holding Registers, etc.) based on a predefined map in config.h.
- *
- * The loop() function continuously:
- * - Services the Modbus RTU server to handle incoming requests.
- * - Periodically calls the main update loop for the emulated equipment, which
- *   manages state transitions and behavior strategies.
- *
- * @see config.h for Modbus RTU and register map configuration.
- * @see Equipment.h for the main equipment logic.
- * @see State.h for different equipment states.
- * @see Strategies/Strategy_Behavior.h for value generation strategies.
- * @see Modbus_Point.h for the base class for all Modbus points.
- */
-//=================================================================================================================================
-//Libraries and declaration of variables.
-#include <Arduino.h>
-#include "config.h"
-#include "ModbusPoints/Modbus_PointFactory.h"
-
-//=================================================================================================================================
-/** 
- * @brief Initializes the application.
- * @details This function runs once at startup. It configures the serial communication
- * for debugging and the Modbus RTU server. It then creates and initializes all
- * the Modbus points based on the `mb_map` array in `config.h`.
- */
-const int rtsPin = 4;
-void setup() {
-  Serial.begin(115200);
-  Serial.println("Setup function started");
-
-  Serial2.begin(BAUDRATE, SERIAL_8N1, RX_PIN, TX_PIN);
-  mb.begin(&Serial2, RST_PIN); // Start the server
-  mb.slave(MODBUS_ID); // Set the slave ID
-   
-  for(int i = 0; i < map_size; i++){
-    Modbus_Point<ModbusRTU>* point = createModbus_Point(&mb, mb_map[i].category, mb_map[i].address, mb_map[i].value, mb_map[i].description);
-    if (point) {
-      point->addToModbusServer();
-      EquipmentInstance.addModbus_Point(mb_map[i].description, point);
-    }
-  }
-  Serial.println("Setup function ended"); 
-}
-//=================================================================================================================================
-/** 
- * @brief The main application loop.
- * @details This function runs repeatedly after setup() has completed. It performs two main actions:
- * 1. It continuously services the Modbus server by calling `mb.task()` to handle
- *    incoming requests from a Modbus master.
- * 2. At a fixed interval (defined in `config.h`), it calls `EquipmentInstance.update()`
- *    to run the emulator's internal state machine and behavior logic.
- */
-void loop() {
-  mb.task();
-  unsigned long currentMillis = millis();
-  if (currentMillis - previousMillis >= interval) {
-    previousMillis = currentMillis;
-    unsigned long startTime = millis();
-    EquipmentInstance.update();
-    unsigned long endTime = millis();
-    unsigned long elapsedTime = endTime - startTime;
-    Serial.printf("Control Execution time: %d ms\n", elapsedTime);
-  } 
-}
diff --git a/src/BMS/VFD/VFD_YASKAWA_HV600_RTU_PHXA7/README.md b/src/BMS/VFD/VFD_YASKAWA_HV600_RTU_PHXA7/README.md
deleted file mode 100644
index 630cf02..0000000
--- a/src/BMS/VFD/VFD_YASKAWA_HV600_RTU_PHXA7/README.md
+++ /dev/null
@@ -1,35 +0,0 @@
-# EQUIPMENT_TYPE MANUFACTURER MODEL RTU
-
-## Brief Introduction
-Equipment specifc details that make it different from other devices
-
-## List of Equipmentt
-This cofiguration has been used for these models:
-* **Model**: 09-15-22 
-* **Model**: 09-15-23 
-* **Model**: 09-15-25 
-
-## Hardware Prerequisites
-
-The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities and at least one hardware serial port for RS485 communication.
-
-* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html) 
-* **RS485 Transceiver**: [RS485 Shield for Arduino.](https://www.dfrobot.com/product-1024.html)
-
----
-
-## States and Strategies
-Provide a brief description of what variables and strategies were used in this configuraiton
-
-### Standby State
-* **Equipment running**: set to 0
-* **Common Alarm**: set to 0
-* **SAT temperature**: set to 85
-
-### Running State
-* **Equipment running**: set to 1
-* **SAT temperature**: **Ramp Strategy** set to 65 deg setpoint
-
-### Fail State
-* **Commong Alarm**: set to 1
-* **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset
diff --git a/src/BMS/VFD/VFD_YASKAWA_HV600_RTU_PHXA7/State_Fail.cpp b/src/BMS/VFD/VFD_YASKAWA_HV600_RTU_PHXA7/State_Fail.cpp
deleted file mode 100644
index 6d85f9a..0000000
--- a/src/BMS/VFD/VFD_YASKAWA_HV600_RTU_PHXA7/State_Fail.cpp
+++ /dev/null
@@ -1,77 +0,0 @@
-/**
- * @file State_Fail.cpp
- * @brief Implementation of the FailState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the FailState, which defines
- * the behavior of the equipment when it has entered a fault condition.
- */
-#include "States/State_Standby.h"
-#include "States/State_Fail.h"
-#include "ModbusPoints/Modbus_Point.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_PID.h"
-
-#include <vector>
-#include <string>
-
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new FailState object.
- *
- * This constructor receives a list of alarm descriptions and creates strategies
- * to set the corresponding Modbus points to a value of 1, indicating an
- * active alarm. It also initializes a PID strategy for the valve position.
- */
-template<>
-FailState<ModbusRTU>::FailState(const std::vector<std::string>& activeAlarms) {
-    // Simulate a failure: set common alarm and a specific fan alarm.
-}
-
-/**
- * @brief Executes the fail state's logic for one update cycle.
- *
- * This method checks the "Clear Alm" Modbus point for a command to transition
- * back to Standby, which would typically happen after a fault is cleared by a
- * user. If no transition is requested, it continues to apply the failure strategies.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusRTU>* FailState<ModbusRTU>::update(Equipment<ModbusRTU>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Fail update function");
-    
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the fail state. Sets the main alarm bit.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusRTU>::enterState(Equipment<ModbusRTU>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Fail State...");
-    
-}
-
-/**
- * @brief Logic to execute once when exiting the fail state. Clears the main alarm bit.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusRTU>::exitState(Equipment<ModbusRTU>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Fail State...");
-    
-}
\ No newline at end of file
diff --git a/src/BMS/VFD/VFD_YASKAWA_HV600_RTU_PHXA7/State_Running.cpp b/src/BMS/VFD/VFD_YASKAWA_HV600_RTU_PHXA7/State_Running.cpp
deleted file mode 100644
index 4299d0b..0000000
--- a/src/BMS/VFD/VFD_YASKAWA_HV600_RTU_PHXA7/State_Running.cpp
+++ /dev/null
@@ -1,89 +0,0 @@
-/**
- * @file State_Running.cpp
- * @brief Implementation of the RunningState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the RunningState, which defines
- * the behavior of the equipment when it is actively running.
- */
-
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "Strategies/Strategy_Behavior.h"
-#include "Strategies/Strategy_PID.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Totalizer.h"
-#include "Equipment/Equipment.h"
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-
-#include <vector>
-#include <string>
-
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new RunningState object.
- *
- * This constructor initializes behavior strategies active during the running
- * state, such as a PID controller for the 'CW Valve Position' and totalizers
- * for the run-hours of each EC fan.
- */
-template<>
-RunningState<ModbusRTU>::RunningState() {
-    //Add strategies 
-    //addStrategy("Actual Capacity", new PIDStrategy("Active SP", 1000, "Supply Temp"));
-    
-}
-
-/**
- * @brief Executes the running state's logic for one update cycle.
- *
- * This method first checks for state transition commands:
- * 1. It reads the "ON/OFF Command By BMS" point. If it's 0, it transitions to StandbyState.
- * 2. It reads the "Fault Code" point. If it's non-zero, it transitions to FailState,
- *    passing the corresponding alarm description.
- *
- * If no transition occurs, it applies the strategies defined for the running state.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusRTU>* RunningState<ModbusRTU>::update(Equipment<ModbusRTU>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Running update function");
-    
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the running state.
- * Sets the "Chiller Sts" point to indicate the unit is running.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusRTU>::enterState(Equipment<ModbusRTU>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Running State...");
-    
-}
-
-/**
- * @brief Logic to execute once when exiting the running state.
- * Sets the "Chiller Sts" point to indicate the unit is no longer running.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusRTU>::exitState(Equipment<ModbusRTU>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Running State...");
-}
\ No newline at end of file
diff --git a/src/BMS/VFD/VFD_YASKAWA_HV600_RTU_PHXA7/State_Standby.cpp b/src/BMS/VFD/VFD_YASKAWA_HV600_RTU_PHXA7/State_Standby.cpp
deleted file mode 100644
index 245a9fe..0000000
--- a/src/BMS/VFD/VFD_YASKAWA_HV600_RTU_PHXA7/State_Standby.cpp
+++ /dev/null
@@ -1,82 +0,0 @@
-/**
- * @file State_Standby.cpp
- * @brief Implementation of the StandbyState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the StandbyState, which defines
- * the behavior of the equipment when it is in an idle or standby mode.
- */
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Saw.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new StandbyState object.
- *
- * In this state, the equipment is idle. This constructor initializes several
- * strategies to generate random values for various status points, simulating
- * a live but non-operational unit.
- */
-template<>
-StandbyState<ModbusRTU>::StandbyState() {
-  addStrategy("Sts_SpdRPM", new SawStrategy(2500.0f, 3500.0f, 10.0f, 1000));
-  addStrategy("Sts_Power", new SawStrategy(15000.0f, 23000.0f, 170.0f, 1000));
-  addStrategy("Sts_Current", new SawStrategy(2500.0f, 3500.0f, 10.0f, 1000));
-  addStrategy("Sts_Voltage", new SingleValueStrategy(4800.0f, 5.0f,1000));
-  addStrategy("Sts_Energy", new SingleValueStrategy(18000.0f, 500.0f,1000));
-}
-
-/**
- * @brief Executes the standby state's logic for one update cycle.
- *
- * This method checks the "Chiller On-Off" Modbus point for a command to
- * transition to the Running state. If no transition is requested, it applies
- * the strategies defined for the standby state.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusRTU>* StandbyState<ModbusRTU>::update(Equipment<ModbusRTU>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Standby update function");
-    
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the standby state.
- * Sets the "Chiller Sts" point to indicate the unit is not running.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusRTU>::enterState(Equipment<ModbusRTU>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Standby State...");
-   
-}
-
-/**
- * @brief Logic to execute once when exiting the standby state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusRTU>::exitState(Equipment<ModbusRTU>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-   
-}
\ No newline at end of file
diff --git a/src/BMS/VFD/VFD_YASKAWA_HV600_RTU_PHXA7/config.h b/src/BMS/VFD/VFD_YASKAWA_HV600_RTU_PHXA7/config.h
deleted file mode 100644
index a346906..0000000
--- a/src/BMS/VFD/VFD_YASKAWA_HV600_RTU_PHXA7/config.h
+++ /dev/null
@@ -1,81 +0,0 @@
-/**
- * @file config.h
- * @brief Main configuration file for the Daikin Chiller (RTU) emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * This file contains important configurations for the Modbus RTU communication
- * and the specific register map for the emulated device.
- */
-
-#ifndef CONFIG_H
-#define CONFIG_H
-#include <ModbusRTU.h>
-#include "core.h"
-#include "Equipment/Equipment.h"
-
-
-#if defined(USE_MODBUS_IP)
-/**
-   * @defgroup ModbusTCPConfig Modbus IP Configuration
-   * @brief Parameters for Modbus TCP communication.
-   * @{
-   */
-  #include <ModbusIP_ESP8266.h>
-  const char *ssid = "wifi_name";       /**< @brief The SSID of the WiFi network. */
-  const char *password = "wifi_password";   /**< @brief The password for the WiFi network. */
-  IPAddress local_IP(192, 168, 1, 234);       /**< @brief The static IP address for the device. */
-  IPAddress gateway(192, 168, 1, 1);          /**< @brief The gateway IP address. */
-  IPAddress subnet(255, 255, 255, 0);         /**< @brief The subnet mask. */
-  
-  ModbusIP mb;
-#else
-  /**
-   * @defgroup ModbusRTUConfig Modbus RTU Configuration
-   * @brief Parameters for serial Modbus RTU communication.
-   * @{
-   */
-  #include <ModbusRTU.h>
-  const int BAUDRATE = 19200;   /**< @brief The serial communication speed in bits per second. */
-  const int RX_PIN = 17;        /**< @brief The GPIO pin used for receiving data (RX). */
-  const int TX_PIN = 16;        /**< @brief The GPIO pin used for transmitting data (TX). */
-  const int RST_PIN = 4;        /**< @brief The GPIO pin connected to the RS485 driver's DE/RE pins for direction control. */
-  const int MODBUS_ID = 111;      /**< @brief The unique slave ID for this device on the Modbus bus. */
-  /** @} */
-
-  /** @brief Global instance of the Modbus RTU server. */
-  ModbusRTU mb;
-#endif
-
-/**
- * @brief The Modbus map for the Equipment device.
- * This array defines all the Modbus points available on the emulated device.
- * The `description` field is crucial as it's used to look up points within the application logic.
- */
-modbusMap mb_map[] =
-{   
-  {HR,        31,    0,  "Sts_Remote"},
-  {HR,        61,    0,  "Sts_SpdRPM"},
-  {HR,        38,    0,  "Sts_Power"},
-  {HR,        37,    0,  "Sts_Current"},
-  {HR,        36,    0,  "Sts_Voltage"},
-  {HR_LONG,   91,    0,  "Sts_Energy"},
-  {HR,        0,     0,  "Cmd_Reset"},
-  {HR,        31,    0,  "Alm_NotAuto"},
-  {HR,        34691,    0,  "VFD_Bypass"},
-
-};                     
- 
-//Size of modbus map used in FOR cycles, automatically calculated.
-/**
- * @brief The total number of entries in the `mb_map` array.
- * This is calculated at compile time and used for iterating over the map.
- */
-const int map_size = sizeof(mb_map) / sizeof(mb_map[0]);
-
-/**
- * @brief The main loop update interval in milliseconds.
- */
-int interval = 250; 
-
-#endif // CONFIG_H
diff --git a/src/BMS/VFD/VFD_YASKAWA_HV600_RTU_PHXA7/main.cpp b/src/BMS/VFD/VFD_YASKAWA_HV600_RTU_PHXA7/main.cpp
deleted file mode 100644
index 5dbc9f1..0000000
--- a/src/BMS/VFD/VFD_YASKAWA_HV600_RTU_PHXA7/main.cpp
+++ /dev/null
@@ -1,78 +0,0 @@
-/**
- * @file main.cpp
- * @brief Main execution program for the Daikin Chiller (RTU) Emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * @details This file contains the main execution program for an Arduino-based
- * emulator of a Daikin Chiller unit. The program communicates via the
- * Modbus RTU protocol over a serial connection.
- *
- * The setup() function initializes the following:
- * - Serial communication for debugging.
- * - A Modbus RTU server with parameters from config.h.
- * - Modbus points (Coils, Holding Registers, etc.) based on a predefined map in config.h.
- *
- * The loop() function continuously:
- * - Services the Modbus RTU server to handle incoming requests.
- * - Periodically calls the main update loop for the emulated equipment, which
- *   manages state transitions and behavior strategies.
- *
- * @see config.h for Modbus RTU and register map configuration.
- * @see Equipment.h for the main equipment logic.
- * @see State.h for different equipment states.
- * @see Strategies/Strategy_Behavior.h for value generation strategies.
- * @see Modbus_Point.h for the base class for all Modbus points.
- */
-//=================================================================================================================================
-//Libraries and declaration of variables.
-#include <Arduino.h>
-#include "config.h"
-#include "ModbusPoints/Modbus_PointFactory.h"
-
-//=================================================================================================================================
-/** 
- * @brief Initializes the application.
- * @details This function runs once at startup. It configures the serial communication
- * for debugging and the Modbus RTU server. It then creates and initializes all
- * the Modbus points based on the `mb_map` array in `config.h`.
- */
-const int rtsPin = 4;
-void setup() {
-  Serial.begin(115200);
-  Serial.println("Setup function started");
-
-  Serial2.begin(BAUDRATE, SERIAL_8N1, RX_PIN, TX_PIN);
-  mb.begin(&Serial2, RST_PIN); // Start the server
-  mb.slave(MODBUS_ID); // Set the slave ID
-   
-  for(int i = 0; i < map_size; i++){
-    Modbus_Point<ModbusRTU>* point = createModbus_Point(&mb, mb_map[i].category, mb_map[i].address, mb_map[i].value, mb_map[i].description);
-    if (point) {
-      point->addToModbusServer();
-      EquipmentInstance.addModbus_Point(mb_map[i].description, point);
-    }
-  }
-  Serial.println("Setup function ended"); 
-}
-//=================================================================================================================================
-/** 
- * @brief The main application loop.
- * @details This function runs repeatedly after setup() has completed. It performs two main actions:
- * 1. It continuously services the Modbus server by calling `mb.task()` to handle
- *    incoming requests from a Modbus master.
- * 2. At a fixed interval (defined in `config.h`), it calls `EquipmentInstance.update()`
- *    to run the emulator's internal state machine and behavior logic.
- */
-void loop() {
-  mb.task();
-  unsigned long currentMillis = millis();
-  if (currentMillis - previousMillis >= interval) {
-    previousMillis = currentMillis;
-    unsigned long startTime = millis();
-    EquipmentInstance.update();
-    unsigned long endTime = millis();
-    unsigned long elapsedTime = endTime - startTime;
-    Serial.printf("Control Execution time: %d ms\n", elapsedTime);
-  } 
-}
diff --git a/src/Base_RTU/README.md b/src/Base_RTU/README.md
deleted file mode 100644
index 630cf02..0000000
--- a/src/Base_RTU/README.md
+++ /dev/null
@@ -1,35 +0,0 @@
-# EQUIPMENT_TYPE MANUFACTURER MODEL RTU
-
-## Brief Introduction
-Equipment specifc details that make it different from other devices
-
-## List of Equipmentt
-This cofiguration has been used for these models:
-* **Model**: 09-15-22 
-* **Model**: 09-15-23 
-* **Model**: 09-15-25 
-
-## Hardware Prerequisites
-
-The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities and at least one hardware serial port for RS485 communication.
-
-* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html) 
-* **RS485 Transceiver**: [RS485 Shield for Arduino.](https://www.dfrobot.com/product-1024.html)
-
----
-
-## States and Strategies
-Provide a brief description of what variables and strategies were used in this configuraiton
-
-### Standby State
-* **Equipment running**: set to 0
-* **Common Alarm**: set to 0
-* **SAT temperature**: set to 85
-
-### Running State
-* **Equipment running**: set to 1
-* **SAT temperature**: **Ramp Strategy** set to 65 deg setpoint
-
-### Fail State
-* **Commong Alarm**: set to 1
-* **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset
diff --git a/src/Base_RTU/State_Fail.cpp b/src/Base_RTU/State_Fail.cpp
deleted file mode 100644
index 6d85f9a..0000000
--- a/src/Base_RTU/State_Fail.cpp
+++ /dev/null
@@ -1,77 +0,0 @@
-/**
- * @file State_Fail.cpp
- * @brief Implementation of the FailState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the FailState, which defines
- * the behavior of the equipment when it has entered a fault condition.
- */
-#include "States/State_Standby.h"
-#include "States/State_Fail.h"
-#include "ModbusPoints/Modbus_Point.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_PID.h"
-
-#include <vector>
-#include <string>
-
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new FailState object.
- *
- * This constructor receives a list of alarm descriptions and creates strategies
- * to set the corresponding Modbus points to a value of 1, indicating an
- * active alarm. It also initializes a PID strategy for the valve position.
- */
-template<>
-FailState<ModbusRTU>::FailState(const std::vector<std::string>& activeAlarms) {
-    // Simulate a failure: set common alarm and a specific fan alarm.
-}
-
-/**
- * @brief Executes the fail state's logic for one update cycle.
- *
- * This method checks the "Clear Alm" Modbus point for a command to transition
- * back to Standby, which would typically happen after a fault is cleared by a
- * user. If no transition is requested, it continues to apply the failure strategies.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusRTU>* FailState<ModbusRTU>::update(Equipment<ModbusRTU>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Fail update function");
-    
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the fail state. Sets the main alarm bit.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusRTU>::enterState(Equipment<ModbusRTU>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Fail State...");
-    
-}
-
-/**
- * @brief Logic to execute once when exiting the fail state. Clears the main alarm bit.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusRTU>::exitState(Equipment<ModbusRTU>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Fail State...");
-    
-}
\ No newline at end of file
diff --git a/src/Base_RTU/State_Running.cpp b/src/Base_RTU/State_Running.cpp
deleted file mode 100644
index 4299d0b..0000000
--- a/src/Base_RTU/State_Running.cpp
+++ /dev/null
@@ -1,89 +0,0 @@
-/**
- * @file State_Running.cpp
- * @brief Implementation of the RunningState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the RunningState, which defines
- * the behavior of the equipment when it is actively running.
- */
-
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "Strategies/Strategy_Behavior.h"
-#include "Strategies/Strategy_PID.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Totalizer.h"
-#include "Equipment/Equipment.h"
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-
-#include <vector>
-#include <string>
-
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new RunningState object.
- *
- * This constructor initializes behavior strategies active during the running
- * state, such as a PID controller for the 'CW Valve Position' and totalizers
- * for the run-hours of each EC fan.
- */
-template<>
-RunningState<ModbusRTU>::RunningState() {
-    //Add strategies 
-    //addStrategy("Actual Capacity", new PIDStrategy("Active SP", 1000, "Supply Temp"));
-    
-}
-
-/**
- * @brief Executes the running state's logic for one update cycle.
- *
- * This method first checks for state transition commands:
- * 1. It reads the "ON/OFF Command By BMS" point. If it's 0, it transitions to StandbyState.
- * 2. It reads the "Fault Code" point. If it's non-zero, it transitions to FailState,
- *    passing the corresponding alarm description.
- *
- * If no transition occurs, it applies the strategies defined for the running state.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusRTU>* RunningState<ModbusRTU>::update(Equipment<ModbusRTU>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Running update function");
-    
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the running state.
- * Sets the "Chiller Sts" point to indicate the unit is running.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusRTU>::enterState(Equipment<ModbusRTU>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Running State...");
-    
-}
-
-/**
- * @brief Logic to execute once when exiting the running state.
- * Sets the "Chiller Sts" point to indicate the unit is no longer running.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusRTU>::exitState(Equipment<ModbusRTU>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Running State...");
-}
\ No newline at end of file
diff --git a/src/Base_RTU/State_Standby.cpp b/src/Base_RTU/State_Standby.cpp
deleted file mode 100644
index 4082ff1..0000000
--- a/src/Base_RTU/State_Standby.cpp
+++ /dev/null
@@ -1,77 +0,0 @@
-/**
- * @file State_Standby.cpp
- * @brief Implementation of the StandbyState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the StandbyState, which defines
- * the behavior of the equipment when it is in an idle or standby mode.
- */
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new StandbyState object.
- *
- * In this state, the equipment is idle. This constructor initializes several
- * strategies to generate random values for various status points, simulating
- * a live but non-operational unit.
- */
-template<>
-StandbyState<ModbusRTU>::StandbyState() {
-  
-}
-
-/**
- * @brief Executes the standby state's logic for one update cycle.
- *
- * This method checks the "Chiller On-Off" Modbus point for a command to
- * transition to the Running state. If no transition is requested, it applies
- * the strategies defined for the standby state.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusRTU>* StandbyState<ModbusRTU>::update(Equipment<ModbusRTU>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Standby update function");
-    
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the standby state.
- * Sets the "Chiller Sts" point to indicate the unit is not running.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusRTU>::enterState(Equipment<ModbusRTU>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Standby State...");
-   
-}
-
-/**
- * @brief Logic to execute once when exiting the standby state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusRTU>::exitState(Equipment<ModbusRTU>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-   
-}
\ No newline at end of file
diff --git a/src/Base_RTU/config.h b/src/Base_RTU/config.h
deleted file mode 100644
index 3791cd7..0000000
--- a/src/Base_RTU/config.h
+++ /dev/null
@@ -1,81 +0,0 @@
-/**
- * @file config.h
- * @brief Main configuration file for the Daikin Chiller (RTU) emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * This file contains important configurations for the Modbus RTU communication
- * and the specific register map for the emulated device.
- */
-
-#ifndef CONFIG_H
-#define CONFIG_H
-#include <ModbusRTU.h>
-#include "core.h"
-#include "Equipment/Equipment.h"
-
-
-#if defined(USE_MODBUS_IP)
-/**
-   * @defgroup ModbusTCPConfig Modbus IP Configuration
-   * @brief Parameters for Modbus TCP communication.
-   * @{
-   */
-  #include <ModbusIP_ESP8266.h>
-  const char *ssid = "wifi_name";       /**< @brief The SSID of the WiFi network. */
-  const char *password = "wifi_password";   /**< @brief The password for the WiFi network. */
-  IPAddress local_IP(192, 168, 1, 234);       /**< @brief The static IP address for the device. */
-  IPAddress gateway(192, 168, 1, 1);          /**< @brief The gateway IP address. */
-  IPAddress subnet(255, 255, 255, 0);         /**< @brief The subnet mask. */
-  
-  ModbusIP mb;
-#else
-  /**
-   * @defgroup ModbusRTUConfig Modbus RTU Configuration
-   * @brief Parameters for serial Modbus RTU communication.
-   * @{
-   */
-  #include <ModbusRTU.h>
-  const int BAUDRATE = 19200;   /**< @brief The serial communication speed in bits per second. */
-  const int RX_PIN = 17;        /**< @brief The GPIO pin used for receiving data (RX). */
-  const int TX_PIN = 16;        /**< @brief The GPIO pin used for transmitting data (TX). */
-  const int RST_PIN = 4;        /**< @brief The GPIO pin connected to the RS485 driver's DE/RE pins for direction control. */
-  const int MODBUS_ID = 1;      /**< @brief The unique slave ID for this device on the Modbus bus. */
-  /** @} */
-
-  /** @brief Global instance of the Modbus RTU server. */
-  ModbusRTU mb;
-#endif
-
-/**
- * @brief The Modbus map for the Equipment device.
- * This array defines all the Modbus points available on the emulated device.
- * The `description` field is crucial as it's used to look up points within the application logic.
- */
-modbusMap mb_map[] =
-{   
-  {COIL,      0,    0,  "Coil"},  
-  {DI,        1,    0,  "Discrete input"},
-  {IR,        2,    0,  "Input Register 1 word"},
-  {IR_10x,    3,    0,  "Input Register scaled by 10"},                   
-  {IR_FLOAT,  4,    0,  "Input Register float"},                   
-  {IR_LONG,   6,    0,  "Input Register 2 word"},   
-  {HR,        8,    0,  "Holding Register 1 word"},                 
-  {HR_10x,    8,    0,  "Holding Register scaled by 10"},                   
-  {HR_FLOAT,  10,   0,  "Holding Register float"},                   
-  {HR_LONG,   12,   0,  "Holding Register 2 word"}, 
-};                     
- 
-//Size of modbus map used in FOR cycles, automatically calculated.
-/**
- * @brief The total number of entries in the `mb_map` array.
- * This is calculated at compile time and used for iterating over the map.
- */
-const int map_size = sizeof(mb_map) / sizeof(mb_map[0]);
-
-/**
- * @brief The main loop update interval in milliseconds.
- */
-int interval = 250; 
-
-#endif // CONFIG_H
diff --git a/src/Base_RTU/main.cpp b/src/Base_RTU/main.cpp
deleted file mode 100644
index 5dbc9f1..0000000
--- a/src/Base_RTU/main.cpp
+++ /dev/null
@@ -1,78 +0,0 @@
-/**
- * @file main.cpp
- * @brief Main execution program for the Daikin Chiller (RTU) Emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * @details This file contains the main execution program for an Arduino-based
- * emulator of a Daikin Chiller unit. The program communicates via the
- * Modbus RTU protocol over a serial connection.
- *
- * The setup() function initializes the following:
- * - Serial communication for debugging.
- * - A Modbus RTU server with parameters from config.h.
- * - Modbus points (Coils, Holding Registers, etc.) based on a predefined map in config.h.
- *
- * The loop() function continuously:
- * - Services the Modbus RTU server to handle incoming requests.
- * - Periodically calls the main update loop for the emulated equipment, which
- *   manages state transitions and behavior strategies.
- *
- * @see config.h for Modbus RTU and register map configuration.
- * @see Equipment.h for the main equipment logic.
- * @see State.h for different equipment states.
- * @see Strategies/Strategy_Behavior.h for value generation strategies.
- * @see Modbus_Point.h for the base class for all Modbus points.
- */
-//=================================================================================================================================
-//Libraries and declaration of variables.
-#include <Arduino.h>
-#include "config.h"
-#include "ModbusPoints/Modbus_PointFactory.h"
-
-//=================================================================================================================================
-/** 
- * @brief Initializes the application.
- * @details This function runs once at startup. It configures the serial communication
- * for debugging and the Modbus RTU server. It then creates and initializes all
- * the Modbus points based on the `mb_map` array in `config.h`.
- */
-const int rtsPin = 4;
-void setup() {
-  Serial.begin(115200);
-  Serial.println("Setup function started");
-
-  Serial2.begin(BAUDRATE, SERIAL_8N1, RX_PIN, TX_PIN);
-  mb.begin(&Serial2, RST_PIN); // Start the server
-  mb.slave(MODBUS_ID); // Set the slave ID
-   
-  for(int i = 0; i < map_size; i++){
-    Modbus_Point<ModbusRTU>* point = createModbus_Point(&mb, mb_map[i].category, mb_map[i].address, mb_map[i].value, mb_map[i].description);
-    if (point) {
-      point->addToModbusServer();
-      EquipmentInstance.addModbus_Point(mb_map[i].description, point);
-    }
-  }
-  Serial.println("Setup function ended"); 
-}
-//=================================================================================================================================
-/** 
- * @brief The main application loop.
- * @details This function runs repeatedly after setup() has completed. It performs two main actions:
- * 1. It continuously services the Modbus server by calling `mb.task()` to handle
- *    incoming requests from a Modbus master.
- * 2. At a fixed interval (defined in `config.h`), it calls `EquipmentInstance.update()`
- *    to run the emulator's internal state machine and behavior logic.
- */
-void loop() {
-  mb.task();
-  unsigned long currentMillis = millis();
-  if (currentMillis - previousMillis >= interval) {
-    previousMillis = currentMillis;
-    unsigned long startTime = millis();
-    EquipmentInstance.update();
-    unsigned long endTime = millis();
-    unsigned long elapsedTime = endTime - startTime;
-    Serial.printf("Control Execution time: %d ms\n", elapsedTime);
-  } 
-}
diff --git a/src/Base_TCP/README.md b/src/Base_TCP/README.md
deleted file mode 100644
index 355156f..0000000
--- a/src/Base_TCP/README.md
+++ /dev/null
@@ -1,33 +0,0 @@
-# EQUIPMENT_TYPE MANUFACTURER MODEL TCP
-
-## Brief Introduction
-Equipment specifc details that make it different from other devices
-
-## List of Equipmentt
-This cofiguration has been used for these models:
-* **Model**: 09-15-22 
-* **Model**: 09-15-23 
-* **Model**: 09-15-25 
-
-## Hardware Prerequisites
-
-The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities.
-* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html) 
-
----
-
-## States and Strategies
-Provide a brief description of what variables and strategies were used in this configuraiton
-
-### Standby State
-* **Equipment running**: set to 0
-* **Common Alarm**: set to 0
-* **SAT temperature**: set to 85
-
-### Running State
-* **Equipment running**: set to 1
-* **SAT temperature**: **Ramp Strategy** set to 65 deg setpoint
-
-### Fail State
-* **Commong Alarm**: set to 1
-* **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset
diff --git a/src/Base_TCP/State_Fail.cpp b/src/Base_TCP/State_Fail.cpp
deleted file mode 100644
index 8bc0385..0000000
--- a/src/Base_TCP/State_Fail.cpp
+++ /dev/null
@@ -1,81 +0,0 @@
-/**
- * @file State_Fail.cpp
- * @brief Implementation of the FailState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the FailState, which defines
- * the behavior of the equipment when it has entered a fault condition.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new FailState object with a list of active alarms.
- *
- * This constructor receives a list of alarm descriptions and creates strategies
- * to set the corresponding Modbus points to a value of 1, indicating an
- * active alarm. It also initializes a PID strategy for the 'CW Valve Position'
- * to maintain its state during the fault.
- * @param activeAlarms A vector of strings, where each string is the
- *                     description of a Modbus point to be set as an active alarm.
- */
-template<>
-FailState<ModbusIP>::FailState(const std::vector<std::string>& activeAlarms) {
-    // Simulate a failure: set common alarm and a specific fan alarm.
-
-    
-}
-
-/**
- * @brief Executes the fail state's logic for one update cycle.
- *
- * This method checks the "Alarm Reset" Modbus point for a command to
- * transition back to Standby, which would typically happen after a fault
- * is cleared by a user. If no transition is requested, it continues to apply
- * the failure strategies (e.g., keeping alarm bits active).
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* FailState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Fail update function");
-    
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the fail state.
- * Sets the "Alarm Common" point to 1 to indicate a general fault condition.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Fail State...");
-}
-
-/**
- * @brief Logic to execute once when exiting the fail state.
- * Clears the "Alarm Common" point to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Fail State...");
-}
\ No newline at end of file
diff --git a/src/Base_TCP/State_Running.cpp b/src/Base_TCP/State_Running.cpp
deleted file mode 100644
index b9e4a99..0000000
--- a/src/Base_TCP/State_Running.cpp
+++ /dev/null
@@ -1,89 +0,0 @@
-/**
- * @file State_Running.cpp
- * @brief Implementation of the RunningState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the RunningState, which defines
- * the behavior of the equipment when it is actively running.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "Strategies/Strategy_Totalizer.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new RunningState object.
- *
- * This constructor initializes behavior strategies active during the running
- * state, such as a PID controller for the 'CW Valve Position' and totalizers
- * for the run-hours of each EC fan.
- */
-template<>
-RunningState<ModbusIP>::RunningState() {
-}
-
-/**
- * @brief Executes the running state's logic for one update cycle.
- *
- * This method first checks for state transition commands:
- * 1. It reads the "ON/OFF Command By BMS" point. If it's 0, it transitions to StandbyState.
- * 2. It reads the "Fault Code" point. If it's non-zero, it transitions to FailState,
- *    passing the corresponding alarm description.
- *
- * If no transition occurs, it applies the strategies defined for the running state.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* RunningState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Running update function");
-    
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the running state.
- * Sets the "Run Status" for all EC fans to 1 to indicate they are active.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Running State...");
-    // You could also update a Modbus register to show the "standby" state
-
-}
-
-/**
- * @brief Logic to execute once when exiting the running state.
- * Sets the "Run Status" for all EC fans to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Running State...");
-   
-}
\ No newline at end of file
diff --git a/src/Base_TCP/State_Standby.cpp b/src/Base_TCP/State_Standby.cpp
deleted file mode 100644
index 20029d1..0000000
--- a/src/Base_TCP/State_Standby.cpp
+++ /dev/null
@@ -1,85 +0,0 @@
-/**
- * @file State_Standby.cpp
- * @brief Implementation of the StandbyState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the StandbyState, which defines
- * the behavior of the equipment when it is in an idle or standby mode.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-/**
- * @brief Constructs a new StandbyState object.
- *
- * In this state, the equipment is idle. This constructor initializes strategies
- * to bring the system to a safe, idle condition. It sets a stable value for
- * the SAT reading and creates ramp strategies to bring the CW valve and all
- * EC fan speeds down to zero.
- */
-template<>
-StandbyState<ModbusIP>::StandbyState() {
-    // You can add initialization code here if needed
-    
-
-}
-
-/**
- * @brief Executes the standby state's logic for one update cycle.
- *
- * This method applies the strategies defined for the standby state (e.g.,
- * ramping values to zero).
- *
- * @warning This method currently does not check for a command to transition to the
- *          Running state. This logic needs to be added to allow the unit to start.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* StandbyState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Standby update function");
-    
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the standby state.
- * This method performs cleanup by setting all alarm points and all EC fan
- * run status points to 0.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Standby State...");
-}
-
-/**
- * @brief Logic to execute once when exiting the standby state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Standby State...");
-}
\ No newline at end of file
diff --git a/src/Base_TCP/config.h b/src/Base_TCP/config.h
deleted file mode 100644
index ca0d770..0000000
--- a/src/Base_TCP/config.h
+++ /dev/null
@@ -1,86 +0,0 @@
-/**
- * @file config.h
- * @brief Main configuration file for the CRAH Unit (TCP) emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * This file contains two important configurations: WiFi network parameters
- * and the Modbus register map for the device.
- */
-
-#ifndef CONFIG_H
-#define CONFIG_H
-
-#include "core.h"
-#include "Equipment/Equipment.h"
-
-#if defined(USE_MODBUS_IP)
-/**
-   * @defgroup ModbusTCPConfig Modbus IP Configuration
-   * @brief Parameters for Modbus TCP communication.
-   * @{
-   */
-  #include <ModbusIP_ESP8266.h>
-  const char *ssid = "QTS_ATL_Arduino";       /**< @brief The SSID of the WiFi network. */
-  const char *password = "Fayetteville123";   /**< @brief The password for the WiFi network. */
-  IPAddress local_IP(172, 17, 25, 115);       /**< @brief The static IP address for the device. */
-  IPAddress gateway(172, 17, 25, 1);          /**< @brief The gateway IP address. */
-  IPAddress subnet(255, 255, 255, 0);         /**< @brief The subnet mask. */
-  
-  ModbusIP mb;
-#else
-  /**
-   * @defgroup ModbusRTUConfig Modbus RTU Configuration
-   * @brief Parameters for serial Modbus RTU communication.
-   * @{
-   */
-  #include <ModbusRTU.h>
-  const int BAUDRATE = 19200;   /**< @brief The serial communication speed in bits per second. */
-  const int RX_PIN = 17;        /**< @brief The GPIO pin used for receiving data (RX). */
-  const int TX_PIN = 16;        /**< @brief The GPIO pin used for transmitting data (TX). */
-  const int RST_PIN = 4;        /**< @brief The GPIO pin connected to the RS485 driver's DE/RE pins for direction control. */
-  const int MODBUS_ID = 1;      /**< @brief The unique slave ID for this device on the Modbus bus. */
-  /** @} */
-
-  /** @brief Global instance of the Modbus RTU server. */
-  ModbusRTU mb;
-#endif
-
-
-
-/**
- * @defgroup ModbusMapConfig Modbus Map Configuration
- * @brief Defines the Modbus register map and related parameters for the emulator.
- * @{
- */
-/**
- * @brief The Modbus map for the Equipment device.
- * This array defines all the Modbus points available on the emulated device.
- * The `description` field is crucial as it's used to look up points within the application logic.
- */
-modbusMap mb_map[] =
-{   
-  {COIL,      0,    0,  "Coil"},  
-  {DI,        1,    0,  "Discrete input"},
-  {IR,        2,    0,  "Input Register 1 word"},
-  {IR_10x,    3,    0,  "Input Register scaled by 10"},                   
-  {IR_FLOAT,  4,    0,  "Input Register float"},                   
-  {IR_LONG,   6,    0,  "Input Register 2 word"},   
-  {HR,        8,    0,  "Holding Register 1 word"},                 
-  {HR_10x,    8,    0,  "Holding Register scaled by 10"},                   
-  {HR_FLOAT,  10,   0,  "Holding Register float"},                   
-  {HR_LONG,   12,   0,  "Holding Register 2 word"}, 
-}; 
-//Size of modbus map used in FOR cycles, automatically calculated.
-
-/**
- * @brief The total number of entries in the `mb_map` array.
- * This is calculated at compile time and used for iterating over the map.
- */
-const int map_size = sizeof(mb_map) / sizeof(mb_map[0]);
-
-/** @brief The main loop update interval in milliseconds. */
-int interval = 250; 
-/** @} */ // End of ModbusMapConfig group
-
-#endif // CONFIG_H
diff --git a/src/Base_TCP/main.cpp b/src/Base_TCP/main.cpp
deleted file mode 100644
index 286a98c..0000000
--- a/src/Base_TCP/main.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-/**
- * @file main.cpp
- * @brief Main execution program for the CRAH Unit (TCP) Emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * @details This file contains the main execution program for an Arduino-based emulator of a CRAH unit. 
- * The program uses a Wi-Fi connection to communicate via the Modbus IP protocol.
- *
- * The setup() function initializes the following:
- * - Serial communication for debugging.
- * - Wi-Fi connection using credentials from config.h.
- * - A Modbus TCP server.
- * - Modbus points (Coils, Holding Registers, etc.) based on a predefined map in config.h.
- *
- * The loop() function continuously:
- * - Services the Modbus TCP server to handle incoming requests.
- * - Periodically calls the main update loop for the emulated equipment, which
- *   manages state transitions and behavior strategies.
- *
- * @see config.h for Wi-Fi and Modbus configuration.
- * @see Equipment.h for the main equipment logic.
- * @see State.h for different equipment states.
- * @see Strategies/Strategy_Behavior.h for value generation strategies.
- * @see Modbus_Point.h for the base class for all Modbus points.
- */
-//=================================================================================================================================
-//Libraries and declaration of variables.
-#include <WiFi.h>
-#include "config.h"
-#include "ModbusPoints/Modbus_PointFactory.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-//=================================================================================================================================
-/** 
- * @brief Initializes the application.
- * @details This function runs once at startup. It configures the serial communication, 
- * Wi-Fi, and the Modbus server. It also creates and initializes all the Modbus points 
- * based on the `mb_map` array in `config.h`.
- */
-void setup() {
-  Serial.begin(115200);                       //Serial comm start
-  WiFi.config(local_IP, gateway, subnet);     // Wifi service start
-  WiFi.begin(ssid, password);
-  while (WiFi.status() != WL_CONNECTED) {
-    delay(1000);
-    Serial.print(".");
-  }
-  Serial.println("Connected!!");
-  mb.server();                                //Modbus server start
-  Serial.println("Server Created");
-  Serial.println(map_size);
-  for(int i = 0; i < map_size; i++){
-    Modbus_Point<ModbusIP>* point = createModbus_Point(&mb, mb_map[i].category, mb_map[i].address, mb_map[i].value, mb_map[i].description);
-    if (point) {
-      point->addToModbusServer();
-      EquipmentInstance.addModbus_Point(mb_map[i].description, point);
-    }
-  }
-  Serial.println("All modbus Points created");
-  Serial.println("Setup function ended");
-}
-//=================================================================================================================================
-/** 
- * @brief The main application loop.
- * @details This function runs repeatedly after setup() has completed. It performs two main actions:
- * 1. It continuously services the Modbus server by calling `mb.task()` to handle
- *    incoming requests from a Modbus master.
- * 2. At a fixed interval (defined in `config.h`), it calls `EquipmentInstance.update()`
- *    to run the emulator's internal state machine and behavior logic.
- */
-void loop() {
-  mb.task();
-  unsigned long currentMillis = millis();
-  if (currentMillis - previousMillis >= interval) {
-    previousMillis = currentMillis;
-    unsigned long startTime = millis();
-    EquipmentInstance.update();
-    unsigned long endTime = millis();
-    unsigned long elapsedTime = endTime - startTime;
-    Serial.printf("Control Execution time: %d ms\n", elapsedTime);
-  } 
-}
diff --git a/src/EPMS/ATS/ATS_Eaton_ATC900_RPD_TCP/README.md b/src/EPMS/ATS/ATS_Eaton_ATC900_RPD_TCP/README.md
deleted file mode 100644
index 355156f..0000000
--- a/src/EPMS/ATS/ATS_Eaton_ATC900_RPD_TCP/README.md
+++ /dev/null
@@ -1,33 +0,0 @@
-# EQUIPMENT_TYPE MANUFACTURER MODEL TCP
-
-## Brief Introduction
-Equipment specifc details that make it different from other devices
-
-## List of Equipmentt
-This cofiguration has been used for these models:
-* **Model**: 09-15-22 
-* **Model**: 09-15-23 
-* **Model**: 09-15-25 
-
-## Hardware Prerequisites
-
-The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities.
-* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html) 
-
----
-
-## States and Strategies
-Provide a brief description of what variables and strategies were used in this configuraiton
-
-### Standby State
-* **Equipment running**: set to 0
-* **Common Alarm**: set to 0
-* **SAT temperature**: set to 85
-
-### Running State
-* **Equipment running**: set to 1
-* **SAT temperature**: **Ramp Strategy** set to 65 deg setpoint
-
-### Fail State
-* **Commong Alarm**: set to 1
-* **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset
diff --git a/src/EPMS/ATS/ATS_Eaton_ATC900_RPD_TCP/State_Fail.cpp b/src/EPMS/ATS/ATS_Eaton_ATC900_RPD_TCP/State_Fail.cpp
deleted file mode 100644
index 8bc0385..0000000
--- a/src/EPMS/ATS/ATS_Eaton_ATC900_RPD_TCP/State_Fail.cpp
+++ /dev/null
@@ -1,81 +0,0 @@
-/**
- * @file State_Fail.cpp
- * @brief Implementation of the FailState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the FailState, which defines
- * the behavior of the equipment when it has entered a fault condition.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new FailState object with a list of active alarms.
- *
- * This constructor receives a list of alarm descriptions and creates strategies
- * to set the corresponding Modbus points to a value of 1, indicating an
- * active alarm. It also initializes a PID strategy for the 'CW Valve Position'
- * to maintain its state during the fault.
- * @param activeAlarms A vector of strings, where each string is the
- *                     description of a Modbus point to be set as an active alarm.
- */
-template<>
-FailState<ModbusIP>::FailState(const std::vector<std::string>& activeAlarms) {
-    // Simulate a failure: set common alarm and a specific fan alarm.
-
-    
-}
-
-/**
- * @brief Executes the fail state's logic for one update cycle.
- *
- * This method checks the "Alarm Reset" Modbus point for a command to
- * transition back to Standby, which would typically happen after a fault
- * is cleared by a user. If no transition is requested, it continues to apply
- * the failure strategies (e.g., keeping alarm bits active).
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* FailState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Fail update function");
-    
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the fail state.
- * Sets the "Alarm Common" point to 1 to indicate a general fault condition.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Fail State...");
-}
-
-/**
- * @brief Logic to execute once when exiting the fail state.
- * Clears the "Alarm Common" point to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Fail State...");
-}
\ No newline at end of file
diff --git a/src/EPMS/ATS/ATS_Eaton_ATC900_RPD_TCP/State_Running.cpp b/src/EPMS/ATS/ATS_Eaton_ATC900_RPD_TCP/State_Running.cpp
deleted file mode 100644
index 8075096..0000000
--- a/src/EPMS/ATS/ATS_Eaton_ATC900_RPD_TCP/State_Running.cpp
+++ /dev/null
@@ -1,154 +0,0 @@
-/**
- * @file State_Running.cpp
- * @brief Implementation of the RunningState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the RunningState, which defines
- * the behavior of the equipment when it is actively running.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "Strategies/Strategy_Totalizer.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new RunningState object.
- *
- * This constructor initializes behavior strategies active during the running
- * state, such as a PID controller for the 'CW Valve Position' and totalizers
- * for the run-hours of each EC fan.
- */
-template<>
-RunningState<ModbusIP>::RunningState() {
-
-  addStrategy("Source 2 Volts AB", new SingleValueStrategy(480.0F, 2.0f, 1000));
-  addStrategy("Source 2 Volts BC", new SingleValueStrategy(480.0F, 2.0f, 1000));
-  addStrategy("Source 2 Volts CA", new SingleValueStrategy(480.0F, 2.0f, 1000));
-  addStrategy("Source 2 Frequency", new SingleValueStrategy(60.0f, 1.0f, 1000));
-  addStrategy("Power Factor", new SingleValueStrategy(90.0f, 2.0f, 1000));
-  addStrategy("Volts AB", new SingleValueStrategy(480.0f, 2.0f, 1000));
-  addStrategy("Votls BC", new SingleValueStrategy(480.0f, 2.0f, 1000));
-  addStrategy("Volts CA", new SingleValueStrategy(480.0f, 2.0f, 1000));
-  addStrategy("Amps A", new SingleValueStrategy(1.0f, 3.0f, 1000));
-  addStrategy("Amps B", new SingleValueStrategy(1.0f, 3.0f, 1000));
-  addStrategy("Amps C", new SingleValueStrategy(1.0f, 3.0f, 1000)); 
-  addStrategy("Total Active Power", new SingleValueStrategy(6.0f, 5.0f, 1000));
-  addStrategy("Total Apparent Power", new SingleValueStrategy(6.0f, 5.0f, 1000));
-
-}
-
-/**
- * @brief Executes the running state's logic for one update cycle.
- *
- * This method first checks for state transition commands:
- * 1. It reads the "ON/OFF Command By BMS" point. If it's 0, it transitions to StandbyState.
- * 2. It reads the "Fault Code" point. If it's non-zero, it transitions to FailState,
- *    passing the corresponding alarm description.
- *
- * If no transition occurs, it applies the strategies defined for the running state.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* RunningState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Running update function");
-    float State_Ctrl = getPointValue(equipment, "ATS_Source"); 
-    if (State_Ctrl == 1){
-      return new StandbyState<ModbusIP>();
-    }
-
-    float load = getPointValue(equipment, "ATS_Load");
-    float rating = getPointValue(equipment, "ATS_Rating");
-    float sim_load = rating * (load/100.0f);
-
-    Strategy_Behavior* ampsA_svs = getStrategy("Amps A");
-    Strategy_Behavior* ampsB_svs = getStrategy("Amps B");
-    Strategy_Behavior* ampsC_svs = getStrategy("Amps C");
-
-    static_cast<SingleValueStrategy*>(ampsA_svs)->setSetpoint(sim_load);
-    static_cast<SingleValueStrategy*>(ampsB_svs)->setSetpoint(sim_load);
-    static_cast<SingleValueStrategy*>(ampsC_svs)->setSetpoint(sim_load);
-    // Apply any strategies defined for the standby state
-    float v_ab = getPointValue(equipment, "Source 2 Volts AB");
-    float v_bc = getPointValue(equipment, "Source 2 Volts BC");
-    float v_ca = getPointValue(equipment, "Source 2 Volts CA");
-    float i_a = getPointValue(equipment, "Amps A");
-    float i_b = getPointValue(equipment, "Amps B");
-    float i_c = getPointValue(equipment, "Ampc C");
-    float pwr = ((v_ab * i_a) + (v_bc * i_b) + (v_ca * i_c));
-    setPointValue(equipment, "Total Active Power", pwr*1000.0f);
-    float pf = getPointValue(equipment, "Power Factor");
-    float a_pwr = pwr * (pf/100.0f);
-    setPointValue(equipment, "Total Apparent Power", a_pwr*1000.0f);
-    
-    float preferred = getPointValue(equipment, "ATS_Preferred");
-    if (preferred == 1.0f){
-      setPointValue(equipment, "Source 1 Preferred", 1.0f);
-      setPointValue(equipment, "Source 2 Preferred", 0.0f);
-    }
-    if (preferred == 2.0f){
-      setPointValue(equipment, "Source 1 Preferred", 0.0f);
-      setPointValue(equipment, "Source 2 Preferred", 1.0f);
-    }
-
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the running state.
- * Sets the "Run Status" for all EC fans to 1 to indicate they are active.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Running State...");
-    // You could also update a Modbus register to show the "standby" state
-    setPointValue(equipment, "Source 1 Available", 1);
-    setPointValue(equipment, "Source 2 Available", 0);
-    setPointValue(equipment, "Source 1 Active", 0);
-    setPointValue(equipment, "Source 2 Active", 1);
-    setPointValue(equipment, "Source 1 Preferred", 1);
-    setPointValue(equipment, "Source 2 Preferred", 0);
-
-    setPointValue(equipment, "Source 1 Volts AB", 0.0f);
-    setPointValue(equipment, "Source 1 Volts BC", 0.0f);
-    setPointValue(equipment, "Source 1 Volts CA", 0.0f);
-    setPointValue(equipment, "Source 1 Frequency", 0.0f);
-
-    int transferQty = getPointValue(equipment, "Number of Transfers");
-    setPointValue(equipment, "Number of Transfers", transferQty + 1);
-}
-
-/**
- * @brief Logic to execute once when exiting the running state.
- * Sets the "Run Status" for all EC fans to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Running State...");
-   
-}
\ No newline at end of file
diff --git a/src/EPMS/ATS/ATS_Eaton_ATC900_RPD_TCP/State_Standby.cpp b/src/EPMS/ATS/ATS_Eaton_ATC900_RPD_TCP/State_Standby.cpp
deleted file mode 100644
index 100cf86..0000000
--- a/src/EPMS/ATS/ATS_Eaton_ATC900_RPD_TCP/State_Standby.cpp
+++ /dev/null
@@ -1,150 +0,0 @@
-/**
- * @file State_Standby.cpp
- * @brief Implementation of the StandbyState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the StandbyState, which defines
- * the behavior of the equipment when it is in an idle or standby mode.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-/**
- * @brief Constructs a new StandbyState object.
- *
- * In this state, the equipment is idle. This constructor initializes strategies
- * to bring the system to a safe, idle condition. It sets a stable value for
- * the SAT reading and creates ramp strategies to bring the CW valve and all
- * EC fan speeds down to zero.
- */
-template<>
-StandbyState<ModbusIP>::StandbyState() {
-  // You can add initialization code here if needed
-  addStrategy("Source 1 Volts AB", new SingleValueStrategy(480.0F, 2.0f, 1000));
-  addStrategy("Source 1 Volts BC", new SingleValueStrategy(480.0F, 2.0f, 1000));
-  addStrategy("Source 1 Volts CA", new SingleValueStrategy(480.0F, 2.0f, 1000));
-  addStrategy("Source 1 Frequency", new SingleValueStrategy(60.0f, 1.0f, 1000));
-  addStrategy("Power Factor", new SingleValueStrategy(90.0f, 2.0f, 1000));
-  addStrategy("Volts AB", new SingleValueStrategy(480.0f, 2.0f, 1000));
-  addStrategy("Votls BC", new SingleValueStrategy(480.0f, 2.0f, 1000));
-  addStrategy("Volts CA", new SingleValueStrategy(480.0f, 2.0f, 1000));
-  addStrategy("Amps A", new SingleValueStrategy(1.0f, 3.0f, 1000));
-  addStrategy("Amps B", new SingleValueStrategy(1.0f, 3.0f, 1000));
-  addStrategy("Amps C", new SingleValueStrategy(1.0f, 3.0f, 1000)); 
-  addStrategy("Total Active Power", new SingleValueStrategy(6.0f, 5.0f, 1000));
-  addStrategy("Total Apparent Power", new SingleValueStrategy(6.0f, 5.0f, 1000));
-
-}
-
-/**
- * @brief Executes the standby state's logic for one update cycle.
- *
- * This method applies the strategies defined for the standby state (e.g.,
- * ramping values to zero).
- *
- * @warning This method currently does not check for a command to transition to the
- *          Running state. This logic needs to be added to allow the unit to start.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* StandbyState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Standby update function");
-    float State_Ctrl = getPointValue(equipment, "ATS_Source"); 
-    if (State_Ctrl ==2){
-      return new RunningState<ModbusIP>();
-    }
-
-    float load = getPointValue(equipment, "ATS_Load");
-    float rating = getPointValue(equipment, "ATS_Rating");
-    float sim_load = rating * (load/100.0f);
-
-    Strategy_Behavior* ampsA_svs = getStrategy("Amps A");
-    Strategy_Behavior* ampsB_svs = getStrategy("Amps B");
-    Strategy_Behavior* ampsC_svs = getStrategy("Amps C");
-
-    static_cast<SingleValueStrategy*>(ampsA_svs)->setSetpoint(sim_load);
-    static_cast<SingleValueStrategy*>(ampsB_svs)->setSetpoint(sim_load);
-    static_cast<SingleValueStrategy*>(ampsC_svs)->setSetpoint(sim_load);
-    // Apply any strategies defined for the standby state
-    float v_ab = getPointValue(equipment, "Source 1 Volts AB");
-    float v_bc = getPointValue(equipment, "Source 1 Volts BC");
-    float v_ca = getPointValue(equipment, "Source 1 Volts CA");
-    float i_a = getPointValue(equipment, "Amps A");
-    float i_b = getPointValue(equipment, "Amps B");
-    float i_c = getPointValue(equipment, "Ampc C");
-    float pwr = ((v_ab * i_a) + (v_bc * i_b) + (v_ca * i_c));
-    setPointValue(equipment, "Total Active Power", pwr*1000.0f);
-    float pf = getPointValue(equipment, "Power Factor");
-    float a_pwr = pwr * (pf/100.0f);
-    setPointValue(equipment, "Total Apparent Power", a_pwr*1000.0f);
-
-    /*setPointValue(equipment, "S2 kW", kw);
-    setPointValue(equipment, "S2 MWh", mwh);*/
-    
-    float preferred = getPointValue(equipment, "ATS_Preferred");
-    if (preferred == 1.0f){
-      setPointValue(equipment, "Source 1 Preferred", 1.0f);
-      setPointValue(equipment, "Source 2 Preferred", 0.0f);
-    }
-    if (preferred == 2.0f){
-      setPointValue(equipment, "Source 1 Preferred", 0.0f);
-      setPointValue(equipment, "Source 2 Preferred", 1.0f);
-    }
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the standby state.
- * This method performs cleanup by setting all alarm points and all EC fan
- * run status points to 0.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Standby State...");
-    setPointValue(equipment, "Source 1 Available", 0);
-    setPointValue(equipment, "Source 2 Available", 1);
-    setPointValue(equipment, "Source 1 Active", 1);
-    setPointValue(equipment, "Source 2 Active", 0);
-    setPointValue(equipment, "Source 1 Preferred", 0);
-    setPointValue(equipment, "Source 2 Preferred", 1);
-
-    setPointValue(equipment, "Source 2 Volts AB", 0.0f);
-    setPointValue(equipment, "Source 2 Volts BC", 0.0f);
-    setPointValue(equipment, "Source 2 Volts CA", 0.0f);
-    setPointValue(equipment, "Source 2 Frequency", 0.0f);
-
-    int transferQty = getPointValue(equipment, "Number of Transfers");
-    setPointValue(equipment, "Number of Transfers", transferQty + 1);
-}
-
-/**
- * @brief Logic to execute once when exiting the standby state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Standby State...");
-}
\ No newline at end of file
diff --git a/src/EPMS/ATS/ATS_Eaton_ATC900_RPD_TCP/config.h b/src/EPMS/ATS/ATS_Eaton_ATC900_RPD_TCP/config.h
deleted file mode 100644
index 6df64d2..0000000
--- a/src/EPMS/ATS/ATS_Eaton_ATC900_RPD_TCP/config.h
+++ /dev/null
@@ -1,109 +0,0 @@
-/**
- * @file config.h
- * @brief Main configuration file for the CRAH Unit (TCP) emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * This file contains two important configurations: WiFi network parameters
- * and the Modbus register map for the device.
- */
-
-#ifndef CONFIG_H
-#define CONFIG_H
-
-#include "core.h"
-#include "Equipment/Equipment.h"
-
-#if defined(USE_MODBUS_IP)
-/**
-   * @defgroup ModbusTCPConfig Modbus IP Configuration
-   * @brief Parameters for Modbus TCP communication.
-   * @{
-   */
-  #include <ModbusIP_ESP8266.h>
-  const char *ssid = "QTS_CDR_Arduino";       /**< @brief The SSID of the WiFi network. */
-  const char *password = "123abc456";   /**< @brief The password for the WiFi network. */
-  IPAddress local_IP(172, 17, 33, 172);       /**< @brief The static IP address for the device. */
-  IPAddress gateway(172, 17, 33, 1);          /**< @brief The gateway IP address. */
-  IPAddress subnet(255, 255, 255, 0);         /**< @brief The subnet mask. */
-  
-  ModbusIP mb;
-#else
-  /**
-   * @defgroup ModbusRTUConfig Modbus RTU Configuration
-   * @brief Parameters for serial Modbus RTU communication.
-   * @{
-   */
-  #include <ModbusRTU.h>
-  const int BAUDRATE = 19200;   /**< @brief The serial communication speed in bits per second. */
-  const int RX_PIN = 17;        /**< @brief The GPIO pin used for receiving data (RX). */
-  const int TX_PIN = 16;        /**< @brief The GPIO pin used for transmitting data (TX). */
-  const int RST_PIN = 4;        /**< @brief The GPIO pin connected to the RS485 driver's DE/RE pins for direction control. */
-  const int MODBUS_ID = 1;      /**< @brief The unique slave ID for this device on the Modbus bus. */
-  /** @} */
-
-  /** @brief Global instance of the Modbus RTU server. */
-  ModbusRTU mb;
-#endif
-
-
-
-/**
- * @defgroup ModbusMapConfig Modbus Map Configuration
- * @brief Defines the Modbus register map and related parameters for the emulator.
- * @{
- */
-/**
- * @brief The Modbus map for the Equipment device.
- * This array defines all the Modbus points available on the emulated device.
- * The `description` field is crucial as it's used to look up points within the application logic.
- */
-modbusMap mb_map[] =
-{   
-  {HR,           8,   0,  "ATS_Preferred"},    //Internal to control from Modscan
-  {HR,           9,   0,  "ATS_Source"},    //Internal to control from Modscan
-  {HR,          10,   0,  "ATS_Load"},      //Internal Fault code from Modscan
-  {HR,          11,   0,  "ATS_Rating"},     //Internal Fault code from Modscan
-  {HR,          12,   0,  "ATS_Input"},     //Internal Fault code from Modscan
-  {DI,         999,   0,  "Source 1 Available"},  
-  {DI,        1000,   0,  "Source 2 Available"},                
-  {DI,        1001,   0,  "Source 1 Active"},        
-  {DI,        1002,   0,  "Source 2 Active"},            
-  {DI,        1003,   0,  "Source 1 Preferred"},                  
-  {DI,        1004,   0,  "Source 2 Preferred"},                 
-  {DI,        1013,   0,  "Summary Alarm"},         
-  {DI,        1019,   0,  "Transfer Inhibit"},        
-  {IR,        6144,   0,  "Source 1 Volts AB"},
-  {IR,        6145,   0,  "Source 1 Volts BC"},
-  {IR,        6146,   0,  "Source 1 Volts CA"},  
-  {IR,        6147,   0,  "Source 2 Volts AB"},
-  {IR,        6148,   0,  "Source 2 Volts BC"},
-  {IR,        6149,   0,  "Source 2 Volts CA"},
-  {IR,        6151,   0,  "Volts AB"},
-  {IR,        6152,   0,  "Volts BC"},
-  {IR,        6153,   0,  "Volts CA"}, 
-  {IR,        6154,   0,  "Source 1 Frequency"},
-  {IR,        6155,   0,  "Source 2 Frequency"},
-  {IR,        6158,   0,  "Amps A"},                     
-  {IR,        6159,   0,  "Amps B"},                   
-  {IR,        6160,   0,  "Amps C"}, 
-  {IR_LONG,   6165,   0,  "Total Active Power"},       //0.001                  
-  {IR_LONG,   6169,   0,  "Total Apparent Power"},     //0.001             
-  {IR,        6171,   0,  "Power Factor"},             //0.001
-  {IR,        6263,   0,  "Number of Transfers"},
-  {IR,        6297,   0,  "Alarm Status Bits"},       
-  
-};
-//Size of modbus map used in FOR cycles, automatically calculated.
-
-/**
- * @brief The total number of entries in the `mb_map` array.
- * This is calculated at compile time and used for iterating over the map.
- */
-const int map_size = sizeof(mb_map) / sizeof(mb_map[0]);
-
-/** @brief The main loop update interval in milliseconds. */
-int interval = 250; 
-/** @} */ // End of ModbusMapConfig group
-
-#endif // CONFIG_H
diff --git a/src/EPMS/ATS/ATS_Eaton_ATC900_RPD_TCP/main.cpp b/src/EPMS/ATS/ATS_Eaton_ATC900_RPD_TCP/main.cpp
deleted file mode 100644
index 286a98c..0000000
--- a/src/EPMS/ATS/ATS_Eaton_ATC900_RPD_TCP/main.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-/**
- * @file main.cpp
- * @brief Main execution program for the CRAH Unit (TCP) Emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * @details This file contains the main execution program for an Arduino-based emulator of a CRAH unit. 
- * The program uses a Wi-Fi connection to communicate via the Modbus IP protocol.
- *
- * The setup() function initializes the following:
- * - Serial communication for debugging.
- * - Wi-Fi connection using credentials from config.h.
- * - A Modbus TCP server.
- * - Modbus points (Coils, Holding Registers, etc.) based on a predefined map in config.h.
- *
- * The loop() function continuously:
- * - Services the Modbus TCP server to handle incoming requests.
- * - Periodically calls the main update loop for the emulated equipment, which
- *   manages state transitions and behavior strategies.
- *
- * @see config.h for Wi-Fi and Modbus configuration.
- * @see Equipment.h for the main equipment logic.
- * @see State.h for different equipment states.
- * @see Strategies/Strategy_Behavior.h for value generation strategies.
- * @see Modbus_Point.h for the base class for all Modbus points.
- */
-//=================================================================================================================================
-//Libraries and declaration of variables.
-#include <WiFi.h>
-#include "config.h"
-#include "ModbusPoints/Modbus_PointFactory.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-//=================================================================================================================================
-/** 
- * @brief Initializes the application.
- * @details This function runs once at startup. It configures the serial communication, 
- * Wi-Fi, and the Modbus server. It also creates and initializes all the Modbus points 
- * based on the `mb_map` array in `config.h`.
- */
-void setup() {
-  Serial.begin(115200);                       //Serial comm start
-  WiFi.config(local_IP, gateway, subnet);     // Wifi service start
-  WiFi.begin(ssid, password);
-  while (WiFi.status() != WL_CONNECTED) {
-    delay(1000);
-    Serial.print(".");
-  }
-  Serial.println("Connected!!");
-  mb.server();                                //Modbus server start
-  Serial.println("Server Created");
-  Serial.println(map_size);
-  for(int i = 0; i < map_size; i++){
-    Modbus_Point<ModbusIP>* point = createModbus_Point(&mb, mb_map[i].category, mb_map[i].address, mb_map[i].value, mb_map[i].description);
-    if (point) {
-      point->addToModbusServer();
-      EquipmentInstance.addModbus_Point(mb_map[i].description, point);
-    }
-  }
-  Serial.println("All modbus Points created");
-  Serial.println("Setup function ended");
-}
-//=================================================================================================================================
-/** 
- * @brief The main application loop.
- * @details This function runs repeatedly after setup() has completed. It performs two main actions:
- * 1. It continuously services the Modbus server by calling `mb.task()` to handle
- *    incoming requests from a Modbus master.
- * 2. At a fixed interval (defined in `config.h`), it calls `EquipmentInstance.update()`
- *    to run the emulator's internal state machine and behavior logic.
- */
-void loop() {
-  mb.task();
-  unsigned long currentMillis = millis();
-  if (currentMillis - previousMillis >= interval) {
-    previousMillis = currentMillis;
-    unsigned long startTime = millis();
-    EquipmentInstance.update();
-    unsigned long endTime = millis();
-    unsigned long elapsedTime = endTime - startTime;
-    Serial.printf("Control Execution time: %d ms\n", elapsedTime);
-  } 
-}
diff --git a/src/EPMS/ATS/ATS_Woodward_DTSC200A_TCP/README.md b/src/EPMS/ATS/ATS_Woodward_DTSC200A_TCP/README.md
deleted file mode 100644
index 4f156e3..0000000
--- a/src/EPMS/ATS/ATS_Woodward_DTSC200A_TCP/README.md
+++ /dev/null
@@ -1,48 +0,0 @@
-# Daikin Chiller (RTU) Emulator
-
-This project is an Arduino-based emulator for a Daikin Chiller unit, communicating over Modbus RTU. It is designed to be a flexible template that can be adapted to simulate different types of chillers by modifying the configuration and state logic.
-
-The emulator operates on a state machine with three core states:
-* **Standby**: The chiller is idle but ready.
-* **Running**: The chiller is active and operational.
-* **Fail**: The chiller has encountered a fault condition.
-
-## Features
-
-* **Modbus RTU Communication**: Emulates a Modbus slave device.
-* **State Machine Logic**: Simulates different operational states (Standby, Running, Fail).
-* **Dynamic Value Simulation**: Uses "Strategies" (e.g., PID, Ramp) to generate realistic, changing values for Modbus points.
-* **Configurable Modbus Map**: The entire Modbus register map is defined in a single, easy-to-modify file (`config.h`).
-* **Extensible Design**: The structure allows for the addition of new states and behaviors.
-
-## Hardware Prerequisites
-
-The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities and at least one hardware serial port for RS485 communication.
-
-* **Microcontroller**: ESP8266, ESP32, or similar.
-* **RS485 Transceiver**: A module like the MAX485 to interface with the Modbus RTU bus.
-
-## Software Dependencies
-
-This project relies on a Modbus library. Ensure you have the correct library installed in your Arduino IDE.
-
-* **Modbus Library**: The code uses a library that provides `ModbusRTU.h` and optionally `ModbusIP_ESP8266.h`.
-
----
-
-## How to Customize for a New Chiller
-
-To adapt this template for a new chiller, follow these steps.
-
-### 1. Configure Device-Specific Parameters (`config.h`)
-
-Open `CH_Daikin_AWV026B_RTU/config.h`. This is the main file for device-specific settings.
-
-#### Modbus RTU Settings
-Update the following constants for your device's serial communication setup.
-```c++
-const int BAUDRATE = 19200;   // The serial communication speed
-const int RX_PIN = 17;        // The GPIO pin for receiving data (RX)
-const int TX_PIN = 16;        // The GPIO pin for transmitting data (TX)
-const int RST_PIN = 4;        // The GPIO pin for RS485 direction control
-const int MODBUS_ID = 1;      // The unique slave ID for this device
\ No newline at end of file
diff --git a/src/EPMS/ATS/ATS_Woodward_DTSC200A_TCP/State_Fail.cpp b/src/EPMS/ATS/ATS_Woodward_DTSC200A_TCP/State_Fail.cpp
deleted file mode 100644
index 8bc0385..0000000
--- a/src/EPMS/ATS/ATS_Woodward_DTSC200A_TCP/State_Fail.cpp
+++ /dev/null
@@ -1,81 +0,0 @@
-/**
- * @file State_Fail.cpp
- * @brief Implementation of the FailState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the FailState, which defines
- * the behavior of the equipment when it has entered a fault condition.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new FailState object with a list of active alarms.
- *
- * This constructor receives a list of alarm descriptions and creates strategies
- * to set the corresponding Modbus points to a value of 1, indicating an
- * active alarm. It also initializes a PID strategy for the 'CW Valve Position'
- * to maintain its state during the fault.
- * @param activeAlarms A vector of strings, where each string is the
- *                     description of a Modbus point to be set as an active alarm.
- */
-template<>
-FailState<ModbusIP>::FailState(const std::vector<std::string>& activeAlarms) {
-    // Simulate a failure: set common alarm and a specific fan alarm.
-
-    
-}
-
-/**
- * @brief Executes the fail state's logic for one update cycle.
- *
- * This method checks the "Alarm Reset" Modbus point for a command to
- * transition back to Standby, which would typically happen after a fault
- * is cleared by a user. If no transition is requested, it continues to apply
- * the failure strategies (e.g., keeping alarm bits active).
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* FailState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Fail update function");
-    
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the fail state.
- * Sets the "Alarm Common" point to 1 to indicate a general fault condition.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Fail State...");
-}
-
-/**
- * @brief Logic to execute once when exiting the fail state.
- * Clears the "Alarm Common" point to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Fail State...");
-}
\ No newline at end of file
diff --git a/src/EPMS/ATS/ATS_Woodward_DTSC200A_TCP/State_Running.cpp b/src/EPMS/ATS/ATS_Woodward_DTSC200A_TCP/State_Running.cpp
deleted file mode 100644
index cd10304..0000000
--- a/src/EPMS/ATS/ATS_Woodward_DTSC200A_TCP/State_Running.cpp
+++ /dev/null
@@ -1,162 +0,0 @@
-/**
- * @file State_Running.cpp
- * @brief Implementation of the RunningState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the RunningState, which defines
- * the behavior of the equipment when it is actively running.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "Strategies/Strategy_Totalizer.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new RunningState object.
- *
- * This constructor initializes behavior strategies active during the running
- * state, such as a PID controller for the 'CW Valve Position' and totalizers
- * for the run-hours of each EC fan.
- */
-template<>
-RunningState<ModbusIP>::RunningState() {
-
-  addStrategy("S2 Volts AB", new SingleValueStrategy(4800.0F, 10.0f, 1000));
-  addStrategy("S2 Volts BC", new SingleValueStrategy(4800.0F, 10.0f, 1000));
-  addStrategy("S2 Volts CA", new SingleValueStrategy(4800.0F, 10.0f, 1000));
-
-  addStrategy("PF", new SingleValueStrategy(910.0f, 20.0f, 1000));
-
-  addStrategy("S2 Amps A", new SingleValueStrategy(200.0f, 100.0f, 1000));
-  addStrategy("S2 Amps B", new SingleValueStrategy(200.0f, 100.0f, 1000));
-  addStrategy("S2 Amps C", new SingleValueStrategy(200.0f, 100.0f, 1000));
-
-}
-
-/**
- * @brief Executes the running state's logic for one update cycle.
- *
- * This method first checks for state transition commands:
- * 1. It reads the "ON/OFF Command By BMS" point. If it's 0, it transitions to StandbyState.
- * 2. It reads the "Fault Code" point. If it's non-zero, it transitions to FailState,
- *    passing the corresponding alarm description.
- *
- * If no transition occurs, it applies the strategies defined for the running state.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* RunningState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Running update function");
-    float State_Ctrl = getPointValue(equipment, "ATS_Source"); 
-    if (State_Ctrl == 1){
-      return new StandbyState<ModbusIP>();
-    }
-    float volts_AB = getPointValue(equipment, "S2 Volts AB");
-    float volts_BC = getPointValue(equipment, "S2 Volts BC");
-    float volts_CA = getPointValue(equipment, "S2 Volts CA");
-
-    setPointValue(equipment, "S2 Volts AN", volts_AB/1.732);
-    setPointValue(equipment, "S2 Volts BN", volts_BC/1.732);
-    setPointValue(equipment, "S2 Volts CN", volts_CA/1.732);
-
-    int I_load = getPointValue(equipment, "ATS_Load");
-    int I_rating = getPointValue(equipment, "ATS_Rating");
-    float load = static_cast<float>(I_load);
-    float rating = static_cast<float>(I_rating);
-    float sim_load = rating * (load/100.0f);
-    Strategy_Behavior* ampsA_svs = getStrategy("S2 Amps A");
-    Strategy_Behavior* ampsB_svs = getStrategy("S2 Amps B");
-    Strategy_Behavior* ampsC_svs = getStrategy("S2 Amps C");
-
-    static_cast<SingleValueStrategy*>(ampsA_svs)->setSetpoint(sim_load*1000.0f);
-    static_cast<SingleValueStrategy*>(ampsB_svs)->setSetpoint(sim_load*1000.0f);
-    static_cast<SingleValueStrategy*>(ampsC_svs)->setSetpoint(sim_load*1000.0f);
-
-    float get_pf = getPointValue(equipment, "PF");
-    float pf = get_pf/1000.0f;
-
-    float real_v_AB = volts_AB/1000.0f;
-    float real_v_BC = volts_BC/1000.0f;
-    float real_v_CA = volts_CA/1000.0f;
-    float kw = (1.732f * ((real_v_AB + real_v_BC + real_v_CA)/3.0f) * sim_load * pf)*10;
-    float mwh = kw *600.0f;
-
-    setPointValue(equipment, "S2 kW", kw);
-    setPointValue(equipment, "S2 MWh", mwh);
-    
-    float preferred = getPointValue(equipment, "ATS_Preferred");
-    if (preferred == 1.0f){
-      setBitValue(equipment, "Source Preferred", 9, true);
-      setBitValue(equipment, "Source Preferred", 8, false);
-    }
-    if (preferred == 2.0f){
-      setBitValue(equipment, "Source Preferred", 9, false);
-      setBitValue(equipment, "Source Preferred", 8, true);
-    }
-
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the running state.
- * Sets the "Run Status" for all EC fans to 1 to indicate they are active.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Running State...");
-    // You could also update a Modbus register to show the "standby" state
-    setPointValue(equipment, "S1 Volts AB", 0.0f);
-    setPointValue(equipment, "S1 Volts BC", 0.0f);
-    setPointValue(equipment, "S1 Volts CA", 0.0f);
-    setPointValue(equipment, "S1 Volts AN", 0.0f);
-    setPointValue(equipment, "S1 Volts BN", 0.0f);
-    setPointValue(equipment, "S1 Volts CN", 0.0f);
-    setPointValue(equipment, "S1 Amps A", 0.0f);
-    setPointValue(equipment, "S1 Amps B", 0.0f);
-    setPointValue(equipment, "S1 Amps C", 0.0f);
-    setPointValue(equipment, "S1 kW", 0.0f);
-    setPointValue(equipment, "S1 MWh", 0.0f);
-
-    setBitValue(equipment, "Source Active", 4, false);
-    setBitValue(equipment, "Source Active", 3, true);
-
-    setBitValue(equipment, "Source Preferred", 8, false);
-    setBitValue(equipment, "Source Preferred", 9, true);
-}
-
-/**
- * @brief Logic to execute once when exiting the running state.
- * Sets the "Run Status" for all EC fans to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Running State...");
-   
-}
\ No newline at end of file
diff --git a/src/EPMS/ATS/ATS_Woodward_DTSC200A_TCP/State_Standby.cpp b/src/EPMS/ATS/ATS_Woodward_DTSC200A_TCP/State_Standby.cpp
deleted file mode 100644
index cb1a547..0000000
--- a/src/EPMS/ATS/ATS_Woodward_DTSC200A_TCP/State_Standby.cpp
+++ /dev/null
@@ -1,153 +0,0 @@
-/**
- * @file State_Standby.cpp
- * @brief Implementation of the StandbyState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the StandbyState, which defines
- * the behavior of the equipment when it is in an idle or standby mode.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-/**
- * @brief Constructs a new StandbyState object.
- *
- * In this state, the equipment is idle. This constructor initializes strategies
- * to bring the system to a safe, idle condition. It sets a stable value for
- * the SAT reading and creates ramp strategies to bring the CW valve and all
- * EC fan speeds down to zero.
- */
-template<>
-StandbyState<ModbusIP>::StandbyState() {
-    // You can add initialization code here if needed
-  addStrategy("S1 Volts AB", new SingleValueStrategy(4800.0F, 10.0f, 1000));
-  addStrategy("S1 Volts BC", new SingleValueStrategy(4800.0F, 10.0f, 1000));
-  addStrategy("S1 Volts CA", new SingleValueStrategy(4800.0F, 10.0f, 1000));
-
-  addStrategy("PF", new SingleValueStrategy(910.0f, 20.0f, 1000));
-
-  addStrategy("S1 Amps A", new SingleValueStrategy(200.0f, 100.0f, 1000));
-  addStrategy("S1 Amps B", new SingleValueStrategy(200.0f, 100.0f, 1000));
-  addStrategy("S1 Amps C", new SingleValueStrategy(200.0f, 100.0f, 1000));
-}
-
-/**
- * @brief Executes the standby state's logic for one update cycle.
- *
- * This method applies the strategies defined for the standby state (e.g.,
- * ramping values to zero).
- *
- * @warning This method currently does not check for a command to transition to the
- *          Running state. This logic needs to be added to allow the unit to start.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* StandbyState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    float State_Ctrl = getPointValue(equipment, "ATS_Source"); 
-    if (State_Ctrl == 2){
-      return new RunningState<ModbusIP>();
-    }
-    float volts_AB = getPointValue(equipment, "S1 Volts AB");
-    float volts_BC = getPointValue(equipment, "S1 Volts BC");
-    float volts_CA = getPointValue(equipment, "S1 Volts CA");
-
-    setPointValue(equipment, "S1 Volts AN", volts_AB/1.732);
-    setPointValue(equipment, "S1 Volts BN", volts_BC/1.732);
-    setPointValue(equipment, "S1 Volts CN", volts_CA/1.732);
-
-    int I_load = getPointValue(equipment, "ATS_Load");
-    int I_rating = getPointValue(equipment, "ATS_Rating");
-    float load = static_cast<float>(I_load);
-    float rating = static_cast<float>(I_rating);
-    float sim_load = rating * (load/100.0f);
-    Strategy_Behavior* ampsA_svs = getStrategy("S1 Amps A");
-    Strategy_Behavior* ampsB_svs = getStrategy("S1 Amps B");
-    Strategy_Behavior* ampsC_svs = getStrategy("S1 Amps C");
-
-    static_cast<SingleValueStrategy*>(ampsA_svs)->setSetpoint(sim_load*1000.0f);
-    static_cast<SingleValueStrategy*>(ampsB_svs)->setSetpoint(sim_load*1000.0f);
-    static_cast<SingleValueStrategy*>(ampsC_svs)->setSetpoint(sim_load*1000.0f);
-
-    float get_pf = getPointValue(equipment, "PF");
-    float pf = get_pf/1000.0f;
-
-    float real_v_AB = volts_AB/1000.0f;
-    float real_v_BC = volts_BC/1000.0f;
-    float real_v_CA = volts_CA/1000.0f;
-    float kw = (1.732f * ((real_v_AB + real_v_BC + real_v_CA)/3.0f) * sim_load * pf)*10;
-    float mwh = kw *600.0f;
-
-    float preferred = getPointValue(equipment, "ATS_Preferred");
-    if (preferred == 1.0f){
-      setBitValue(equipment, "Source Preferred", 9, true);
-      setBitValue(equipment, "Source Preferred", 8, false);
-    }
-    if (preferred == 2.0f){
-      setBitValue(equipment, "Source Preferred", 9, false);
-      setBitValue(equipment, "Source Preferred", 8, true);
-    }
-
-    setPointValue(equipment, "S1 kW", kw);
-    setPointValue(equipment, "S1 MWh", mwh);
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the standby state.
- * This method performs cleanup by setting all alarm points and all EC fan
- * run status points to 0.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Standby State...");
-
-    setPointValue(equipment, "S2 Volts AB", 0.0f);
-    setPointValue(equipment, "S2 Volts BC", 0.0f);
-    setPointValue(equipment, "S2 Volts CA", 0.0f);
-    setPointValue(equipment, "S2 Volts AN", 0.0f);
-    setPointValue(equipment, "S2 Volts BN", 0.0f);
-    setPointValue(equipment, "S2 Volts CN", 0.0f);
-    setPointValue(equipment, "S2 Amps A", 0.0f);
-    setPointValue(equipment, "S2 Amps B", 0.0f);
-    setPointValue(equipment, "S2 Amps C", 0.0f);
-    setPointValue(equipment, "S2 kW", 0.0f);
-    setPointValue(equipment, "S2 MWh", 0.0f);
-
-    setBitValue(equipment, "Source Active", 3, false);
-    setBitValue(equipment, "Source Active", 4, true);
-
-    setBitValue(equipment, "Source Preferred", 8, false);
-    setBitValue(equipment, "Source Preferred", 9, true);
-    
-}
-/**
- * @brief Logic to execute once when exiting the standby state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Standby State...");
-}
\ No newline at end of file
diff --git a/src/EPMS/ATS/ATS_Woodward_DTSC200A_TCP/config.h b/src/EPMS/ATS/ATS_Woodward_DTSC200A_TCP/config.h
deleted file mode 100644
index 1223b95..0000000
--- a/src/EPMS/ATS/ATS_Woodward_DTSC200A_TCP/config.h
+++ /dev/null
@@ -1,108 +0,0 @@
-/**
- * @file config.h
- * @brief Main configuration file for the CRAH Unit (TCP) emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * This file contains two important configurations: WiFi network parameters
- * and the Modbus register map for the device.
- */
-
-#ifndef CONFIG_H
-#define CONFIG_H
-
-#include "core.h"
-#include "Equipment/Equipment.h"
-
-#if defined(USE_MODBUS_IP)
-/**
-   * @defgroup ModbusTCPConfig Modbus IP Configuration
-   * @brief Parameters for Modbus TCP communication.
-   * @{
-   */
-  #include <ModbusIP_ESP8266.h>
-  const char *ssid = "ArduinoWifiB";       /**< @brief The SSID of the WiFi network. */
-  const char *password = "123abc456";   /**< @brief The password for the WiFi network. */
-  IPAddress local_IP(172, 17, 32, 82);       /**< @brief The static IP address for the device. */
-  IPAddress gateway(172, 17, 32, 1);          /**< @brief The gateway IP address. */
-  IPAddress subnet(255, 255, 255, 0);         /**< @brief The subnet mask. */
-  
-  ModbusIP mb;
-#else
-  /**
-   * @defgroup ModbusRTUConfig Modbus RTU Configuration
-   * @brief Parameters for serial Modbus RTU communication.
-   * @{
-   */
-  #include <ModbusRTU.h>
-  const int BAUDRATE = 19200;   /**< @brief The serial communication speed in bits per second. */
-  const int RX_PIN = 17;        /**< @brief The GPIO pin used for receiving data (RX). */
-  const int TX_PIN = 16;        /**< @brief The GPIO pin used for transmitting data (TX). */
-  const int RST_PIN = 4;        /**< @brief The GPIO pin connected to the RS485 driver's DE/RE pins for direction control. */
-  const int MODBUS_ID = 1;      /**< @brief The unique slave ID for this device on the Modbus bus. */
-  /** @} */
-
-  /** @brief Global instance of the Modbus RTU server. */
-  ModbusRTU mb;
-#endif
-
-
-
-/**
- * @defgroup ModbusMapConfig Modbus Map Configuration
- * @brief Defines the Modbus register map and related parameters for the emulator.
- * @{
- */
-/**
- * @brief The Modbus map for the Equipment device.
- * This array defines all the Modbus points available on the emulated device.
- * The `description` field is crucial as it's used to look up points within the application logic.
- */
-modbusMap mb_map[] =
-{   
-  {HR,        8,      0,  "ATS_Preferred"},  //Internal to control from Modscan
-  {HR,        9,      0,  "ATS_Source"},  //Internal to control from Modscan
-  {HR,        10,     0,  "ATS_Load"},
-  {HR,        11,     0,  "ATS_Rating"},     //Internal Fault code from Modscan
-                  
-  {HR,        50009,  0,  "PF"},                //0.001x
-  {HR_LONG,   50001,  0,  "S2 Volts AB"},       //0.1x
-  {HR_LONG,   50004,  0,  "S2 Volts AN"},       //0.1x           
-  {HR_LONG,   50007,  0,  "S2 Volts BC"},       //0.1x     
-  {HR_LONG,   50010,  0,  "S2 Volts BN"},       //0.1x         
-  {HR_LONG,   50013,  0,  "S2 Volts CA"},       //0.1x
-  {HR_LONG,   50016,  0,  "S2 Volts CN"},       //0.1x          
-  {HR_LONG,   50019,  0,  "S1 Volts AB"},       //0.1x
-  {HR_LONG,   50022,  0,  "S1 Volts AN"},       //0.1x
-  {HR_LONG,   50025,  0,  "S1 Volts BC"},       //0.1x
-  {HR_LONG,   50028,  0,  "S1 Volts BN"},       //0.1x
-  {HR_LONG,   50031,  0,  "S1 Volts CA"},       //0.1x
-  {HR_LONG,   50034,  0,  "S1 Volts CN"},       //0.1x
-  {HR_LONG,   50037,  0,  "S2 Amps A"},         //0.001x
-  {HR_LONG,   50040,  0,  "S2 Amps B"},         //0.001x       
-  {HR_LONG,   50043,  0,  "S2 Amps C"},         //0.001x
-  {HR_LONG,   50060,  0,  "S2 kW"},             
-  {HR_LONG,   50064,  0,  "S2 MWh"},            //0.01x
-  {HR,        50078,  0,  "Source Preferred"},  //bit9 source1 bit8 source 2
-  {HR,        50082,  0,  "Source Active"},     //bit4 source1 bit3 source 2
-  {HR_LONG,   50091,  0,  "S1 Amps A"},         //.001x
-  {HR,        50093,  0,  "S1 kW"},             //.1x
-  {HR_LONG,   50094,  0,  "S1 Amps B"},         //.001x
-  {HR_LONG,   50097,  0,  "S1 Amps C"},         //.001x
-  {HR_LONG,   50100,  0,  "S1 MWh"},            //.01x
-
-               
-};
-//Size of modbus map used in FOR cycles, automatically calculated.
-
-/**
- * @brief The total number of entries in the `mb_map` array.
- * This is calculated at compile time and used for iterating over the map.
- */
-const int map_size = sizeof(mb_map) / sizeof(mb_map[0]);
-
-/** @brief The main loop update interval in milliseconds. */
-int interval = 250; 
-/** @} */ // End of ModbusMapConfig group
-
-#endif // CONFIG_H
diff --git a/src/EPMS/ATS/ATS_Woodward_DTSC200A_TCP/main.cpp b/src/EPMS/ATS/ATS_Woodward_DTSC200A_TCP/main.cpp
deleted file mode 100644
index 286a98c..0000000
--- a/src/EPMS/ATS/ATS_Woodward_DTSC200A_TCP/main.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-/**
- * @file main.cpp
- * @brief Main execution program for the CRAH Unit (TCP) Emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * @details This file contains the main execution program for an Arduino-based emulator of a CRAH unit. 
- * The program uses a Wi-Fi connection to communicate via the Modbus IP protocol.
- *
- * The setup() function initializes the following:
- * - Serial communication for debugging.
- * - Wi-Fi connection using credentials from config.h.
- * - A Modbus TCP server.
- * - Modbus points (Coils, Holding Registers, etc.) based on a predefined map in config.h.
- *
- * The loop() function continuously:
- * - Services the Modbus TCP server to handle incoming requests.
- * - Periodically calls the main update loop for the emulated equipment, which
- *   manages state transitions and behavior strategies.
- *
- * @see config.h for Wi-Fi and Modbus configuration.
- * @see Equipment.h for the main equipment logic.
- * @see State.h for different equipment states.
- * @see Strategies/Strategy_Behavior.h for value generation strategies.
- * @see Modbus_Point.h for the base class for all Modbus points.
- */
-//=================================================================================================================================
-//Libraries and declaration of variables.
-#include <WiFi.h>
-#include "config.h"
-#include "ModbusPoints/Modbus_PointFactory.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-//=================================================================================================================================
-/** 
- * @brief Initializes the application.
- * @details This function runs once at startup. It configures the serial communication, 
- * Wi-Fi, and the Modbus server. It also creates and initializes all the Modbus points 
- * based on the `mb_map` array in `config.h`.
- */
-void setup() {
-  Serial.begin(115200);                       //Serial comm start
-  WiFi.config(local_IP, gateway, subnet);     // Wifi service start
-  WiFi.begin(ssid, password);
-  while (WiFi.status() != WL_CONNECTED) {
-    delay(1000);
-    Serial.print(".");
-  }
-  Serial.println("Connected!!");
-  mb.server();                                //Modbus server start
-  Serial.println("Server Created");
-  Serial.println(map_size);
-  for(int i = 0; i < map_size; i++){
-    Modbus_Point<ModbusIP>* point = createModbus_Point(&mb, mb_map[i].category, mb_map[i].address, mb_map[i].value, mb_map[i].description);
-    if (point) {
-      point->addToModbusServer();
-      EquipmentInstance.addModbus_Point(mb_map[i].description, point);
-    }
-  }
-  Serial.println("All modbus Points created");
-  Serial.println("Setup function ended");
-}
-//=================================================================================================================================
-/** 
- * @brief The main application loop.
- * @details This function runs repeatedly after setup() has completed. It performs two main actions:
- * 1. It continuously services the Modbus server by calling `mb.task()` to handle
- *    incoming requests from a Modbus master.
- * 2. At a fixed interval (defined in `config.h`), it calls `EquipmentInstance.update()`
- *    to run the emulator's internal state machine and behavior logic.
- */
-void loop() {
-  mb.task();
-  unsigned long currentMillis = millis();
-  if (currentMillis - previousMillis >= interval) {
-    previousMillis = currentMillis;
-    unsigned long startTime = millis();
-    EquipmentInstance.update();
-    unsigned long endTime = millis();
-    unsigned long elapsedTime = endTime - startTime;
-    Serial.printf("Control Execution time: %d ms\n", elapsedTime);
-  } 
-}
diff --git a/src/EPMS/Breaker/BKR_ABB_EMax2_TCP/README.md b/src/EPMS/Breaker/BKR_ABB_EMax2_TCP/README.md
deleted file mode 100644
index 355156f..0000000
--- a/src/EPMS/Breaker/BKR_ABB_EMax2_TCP/README.md
+++ /dev/null
@@ -1,33 +0,0 @@
-# EQUIPMENT_TYPE MANUFACTURER MODEL TCP
-
-## Brief Introduction
-Equipment specifc details that make it different from other devices
-
-## List of Equipmentt
-This cofiguration has been used for these models:
-* **Model**: 09-15-22 
-* **Model**: 09-15-23 
-* **Model**: 09-15-25 
-
-## Hardware Prerequisites
-
-The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities.
-* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html) 
-
----
-
-## States and Strategies
-Provide a brief description of what variables and strategies were used in this configuraiton
-
-### Standby State
-* **Equipment running**: set to 0
-* **Common Alarm**: set to 0
-* **SAT temperature**: set to 85
-
-### Running State
-* **Equipment running**: set to 1
-* **SAT temperature**: **Ramp Strategy** set to 65 deg setpoint
-
-### Fail State
-* **Commong Alarm**: set to 1
-* **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset
diff --git a/src/EPMS/Breaker/BKR_ABB_EMax2_TCP/State_Fail.cpp b/src/EPMS/Breaker/BKR_ABB_EMax2_TCP/State_Fail.cpp
deleted file mode 100644
index 8bc0385..0000000
--- a/src/EPMS/Breaker/BKR_ABB_EMax2_TCP/State_Fail.cpp
+++ /dev/null
@@ -1,81 +0,0 @@
-/**
- * @file State_Fail.cpp
- * @brief Implementation of the FailState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the FailState, which defines
- * the behavior of the equipment when it has entered a fault condition.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new FailState object with a list of active alarms.
- *
- * This constructor receives a list of alarm descriptions and creates strategies
- * to set the corresponding Modbus points to a value of 1, indicating an
- * active alarm. It also initializes a PID strategy for the 'CW Valve Position'
- * to maintain its state during the fault.
- * @param activeAlarms A vector of strings, where each string is the
- *                     description of a Modbus point to be set as an active alarm.
- */
-template<>
-FailState<ModbusIP>::FailState(const std::vector<std::string>& activeAlarms) {
-    // Simulate a failure: set common alarm and a specific fan alarm.
-
-    
-}
-
-/**
- * @brief Executes the fail state's logic for one update cycle.
- *
- * This method checks the "Alarm Reset" Modbus point for a command to
- * transition back to Standby, which would typically happen after a fault
- * is cleared by a user. If no transition is requested, it continues to apply
- * the failure strategies (e.g., keeping alarm bits active).
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* FailState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Fail update function");
-    
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the fail state.
- * Sets the "Alarm Common" point to 1 to indicate a general fault condition.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Fail State...");
-}
-
-/**
- * @brief Logic to execute once when exiting the fail state.
- * Clears the "Alarm Common" point to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Fail State...");
-}
\ No newline at end of file
diff --git a/src/EPMS/Breaker/BKR_ABB_EMax2_TCP/State_Running.cpp b/src/EPMS/Breaker/BKR_ABB_EMax2_TCP/State_Running.cpp
deleted file mode 100644
index 6d6c693..0000000
--- a/src/EPMS/Breaker/BKR_ABB_EMax2_TCP/State_Running.cpp
+++ /dev/null
@@ -1,137 +0,0 @@
-/**
- * @file State_Running.cpp
- * @brief Implementation of the RunningState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the RunningState, which defines
- * the behavior of the equipment when it is actively running.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "Strategies/Strategy_Totalizer.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new RunningState object.
- *
- * This constructor initializes behavior strategies active during the running
- * state, such as a PID controller for the 'CW Valve Position' and totalizers
- * for the run-hours of each EC fan.
- */
-template<>
-RunningState<ModbusIP>::RunningState() {
-  addStrategy("V_AB", new SingleValueStrategy(4800.0F, 5.0f, 1000));
-  addStrategy("V_BC", new SingleValueStrategy(4800.0F, 5.0f, 1000));
-  addStrategy("V_CA", new SingleValueStrategy(4800.0F, 5.0f, 1000));
-
-  addStrategy("Amps A", new SingleValueStrategy(1.0f, 10.0f, 1000));
-  addStrategy("Amps B", new SingleValueStrategy(1.0f, 10.0f, 1000));
-  addStrategy("Amps C", new SingleValueStrategy(1.0f, 10.0f, 1000));
-}
-
-/**
- * @brief Executes the running state's logic for one update cycle.
- *
- * This method first checks for state transition commands:
- * 1. It reads the "ON/OFF Command By BMS" point. If it's 0, it transitions to StandbyState.
- * 2. It reads the "Fault Code" point. If it's non-zero, it transitions to FailState,
- *    passing the corresponding alarm description.
- *
- * If no transition occurs, it applies the strategies defined for the running state.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* RunningState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Running update function");
-    float State_Ctrl = getPointValue(equipment, "PxControl");
-    if (State_Ctrl == 0.0f){
-      return new StandbyState<ModbusIP>();
-    }
-    if (State_Ctrl == 1.0f){
-      setBitValue(equipment, "CB_Position", 0, true);
-      setBitValue(equipment, "CB_Position", 12, false);
-    }
-    if (State_Ctrl == 2.0f){
-      return new StandbyState<ModbusIP>();
-    }
-
-    float volts_AB = getPointValue(equipment, "V_AB");
-    float volts_BC = getPointValue(equipment, "V_BC");
-    float volts_AC = getPointValue(equipment, "V_CA");
-
-    setPointValue(equipment, "V_AN", volts_AB/1.732f);
-    setPointValue(equipment, "V_BN", volts_BC/1.732f);
-    setPointValue(equipment, "V_CN", volts_AC/1.732f);
-
-
-    int I_load = getPointValue(equipment, "PxLoad");
-    int I_rating = getPointValue(equipment, "PxRating");
-    float load = static_cast<float>(I_load);
-    float rating = static_cast<float>(I_rating);
-    float real_load = rating * (load/100.0f);
-    setPointValue(equipment, "Amps A", real_load * 10.0f);
-    setPointValue(equipment, "Amps B", real_load * 10.0f);
-    setPointValue(equipment, "Amps C", real_load * 10.0f);
-    setPointValue(equipment, "Amps G", volts_AB * 0.037f);
-    setPointValue(equipment, "Amps N", volts_BC * 0.034f);
-
-
-
-
-    float kva = (1.732f * ((volts_AB + volts_BC + volts_AC)/4.0f) * real_load * (0.92f))/100000.0f;
-    float kw =  (1.732f * ((volts_AB + volts_BC + volts_AC)/4.0f) * real_load )/10000.0f;
-
-    setPointValue(equipment, "kW", kw);
-    setPointValue(equipment, "kVA", kva);
-    setPointValue(equipment, "kVA2", kva);
-    setPointValue(equipment, "kWh", 1724.0f);
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the running state.
- * Sets the "Run Status" for all EC fans to 1 to indicate they are active.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Running State...");
-    // You could also update a Modbus register to show the "standby" state
-
-}
-
-/**
- * @brief Logic to execute once when exiting the running state.
- * Sets the "Run Status" for all EC fans to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Running State...");
-   
-}
\ No newline at end of file
diff --git a/src/EPMS/Breaker/BKR_ABB_EMax2_TCP/State_Standby.cpp b/src/EPMS/Breaker/BKR_ABB_EMax2_TCP/State_Standby.cpp
deleted file mode 100644
index 51e0f25..0000000
--- a/src/EPMS/Breaker/BKR_ABB_EMax2_TCP/State_Standby.cpp
+++ /dev/null
@@ -1,111 +0,0 @@
-/**
- * @file State_Standby.cpp
- * @brief Implementation of the StandbyState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the StandbyState, which defines
- * the behavior of the equipment when it is in an idle or standby mode.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-/**
- * @brief Constructs a new StandbyState object.
- *
- * In this state, the equipment is idle. This constructor initializes strategies
- * to bring the system to a safe, idle condition. It sets a stable value for
- * the SAT reading and creates ramp strategies to bring the CW valve and all
- * EC fan speeds down to zero.
- */
-template<>
-StandbyState<ModbusIP>::StandbyState() {
-    // You can add initialization code here if needed
-    
-
-}
-
-/**
- * @brief Executes the standby state's logic for one update cycle.
- *
- * This method applies the strategies defined for the standby state (e.g.,
- * ramping values to zero).
- *
- * @warning This method currently does not check for a command to transition to the
- *          Running state. This logic needs to be added to allow the unit to start.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* StandbyState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Standby update function");
-    float State_Ctrl = getPointValue(equipment, "PxControl");
-    if (State_Ctrl == 1.0f){
-      return new RunningState<ModbusIP>();
-    }
-    if (State_Ctrl == 0.0f){
-      setBitValue(equipment, "CB_Position", 0, false);
-      setBitValue(equipment, "CB_Position", 12, false);
-    }
-    if (State_Ctrl == 2.0f){
-      setBitValue(equipment, "CB_Position", 0, false);
-      setBitValue(equipment, "CB_Position", 12, true);
-    }
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the standby state.
- * This method performs cleanup by setting all alarm points and all EC fan
- * run status points to 0.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Standby State...");
-    setPointValue(equipment, "V_AB", 0.0f);
-    setPointValue(equipment, "V_BC", 0.0f);
-    setPointValue(equipment, "V_CA", 0.0f);
-    setPointValue(equipment, "V_AN", 0.0f);
-    setPointValue(equipment, "V_BN", 0.0f);
-    setPointValue(equipment, "V_CN", 0.0f);
-    setPointValue(equipment, "Amps A", 0.0f);
-    setPointValue(equipment, "Amps B", 0.0f);
-    setPointValue(equipment, "Amps C", 0.0f);
-    setPointValue(equipment, "Amps G", 0.0f);
-    setPointValue(equipment, "Amps N", 0.0f);
-    setPointValue(equipment, "kW", 0.0f);
-    setPointValue(equipment, "k_VA", 0.0f);
-    setPointValue(equipment, "k_VA2", 0.0f);
-    setPointValue(equipment, "kWh", 0.0f);
-}
-
-/**
- * @brief Logic to execute once when exiting the standby state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Standby State...");
-}
\ No newline at end of file
diff --git a/src/EPMS/Breaker/BKR_ABB_EMax2_TCP/config.h b/src/EPMS/Breaker/BKR_ABB_EMax2_TCP/config.h
deleted file mode 100644
index 7728a3c..0000000
--- a/src/EPMS/Breaker/BKR_ABB_EMax2_TCP/config.h
+++ /dev/null
@@ -1,98 +0,0 @@
-/**
- * @file config.h
- * @brief Main configuration file for the Breaker ABB EMax2
- * @author Zach Gutierrez
- * @date 2025-09-02
- *
- * This file contains two important configurations: WiFi network parameters
- * and the Modbus register map for the device.
- */
-
-#ifndef CONFIG_H
-#define CONFIG_H
-
-#include "core.h"
-#include "Equipment/Equipment.h"
-
-#if defined(USE_MODBUS_IP)
-/**
-   * @defgroup ModbusTCPConfig Modbus IP Configuration
-   * @brief Parameters for Modbus TCP communication.
-   * @{
-   */
-  #include <ModbusIP_ESP8266.h>
-  const char *ssid = "wifi";       /**< @brief The SSID of the WiFi network. */
-  const char *password = "password";   /**< @brief The password for the WiFi network. */
-  IPAddress local_IP(192, 168, 1, 170);       /**< @brief The static IP address for the device. */
-  IPAddress gateway(192, 168, 1, 1);           /**< @brief The gateway IP address. */
-  IPAddress subnet(255, 255, 255, 0);         /**< @brief The subnet mask. */
-  
-  ModbusIP mb;
-#else
-  /**
-   * @defgroup ModbusRTUConfig Modbus RTU Configuration
-   * @brief Parameters for serial Modbus RTU communication.
-   * @{
-   */
-  #include <ModbusRTU.h>
-  const int BAUDRATE = 19200;   /**< @brief The serial communication speed in bits per second. */
-  const int RX_PIN = 17;        /**< @brief The GPIO pin used for receiving data (RX). */
-  const int TX_PIN = 16;        /**< @brief The GPIO pin used for transmitting data (TX). */
-  const int RST_PIN = 4;        /**< @brief The GPIO pin connected to the RS485 driver's DE/RE pins for direction control. */
-  const int MODBUS_ID = 1;      /**< @brief The unique slave ID for this device on the Modbus bus. */
-  /** @} */
-
-  /** @brief Global instance of the Modbus RTU server. */
-  ModbusRTU mb;
-#endif
-
-
-
-/**
- * @defgroup ModbusMapConfig Modbus Map Configuration
- * @brief Defines the Modbus register map and related parameters for the emulator.
- * @{
- */
-/**
- * @brief The Modbus map for the Equipment device.
- * This array defines all the Modbus points available on the emulated device.
- * The `description` field is crucial as it's used to look up points within the application logic.
- */
-modbusMap mb_map[] = {
-  // ESP8266 Modbus server uses 0-based addressing, while Modbus Poll uses 1-based addressing.
-  // Convert from ESP8266 to traditional Modbus addressing: subtract 30001/40001.
-
-  // Input Registers (3x) - Floating Point (MSB & LSB)
-  {HR,        9,      0,  "PxControl"}, //Open-Close Cmd
-  {HR,        10,     0,  "PxLoad"},          //Adjustble Load
-  {HR,        11,     0,  "PxRating"},        //Max amp to calculate kw, kVA, etc
-  {IR, 39, 0, "CB_Position" },  // 300041.0 - Circuit Breaker Position || 300041.12 - Circuit Breaker Tripped
-  {IR_LONG, 99, 0, "Amps A" }, //DWORD
-  {IR_LONG, 101, 0, "Amps B" }, //DWORD
-  {IR_LONG, 103, 0, "Amps C" }, //DWORD
-  {IR_LONG, 105, 0, "Amps N" }, //DWORD
-  {IR_LONG, 107, 0, "Amps G" }, //DWORD
-  {IR, 149, 0, "V_AN" }, //WORD
-  {IR, 150, 0, "V_BN" }, //WORD
-  {IR, 151, 0, "V_CN" }, //WORD
-  {IR, 153, 0, "V_AB" }, //WORD
-  {IR, 154, 0, "V_BC" }, //WORD
-  {IR, 155, 0, "V_CA" }, //WORD
-  {IR_LONG, 221, 0, "k_VA" }, //LONG
-  {IR_LONG, 205, 0, "kW" }, //LONG
-  {IR_LONG, 303, 0, "kWh" }, //LONG
-  {IR, 252, 0, "k_VA2" }, //SHORT
-};
-//Size of modbus map used in FOR cycles, automatically calculated.
-
-/**
- * @brief The total number of entries in the `mb_map` array.
- * This is calculated at compile time and used for iterating over the map.
- */
-const int map_size = sizeof(mb_map) / sizeof(mb_map[0]);
-
-/** @brief The main loop update interval in milliseconds. */
-int interval = 250; 
-/** @} */ // End of ModbusMapConfig group
-
-#endif // CONFIG_H
diff --git a/src/EPMS/Breaker/BKR_ABB_EMax2_TCP/main.cpp b/src/EPMS/Breaker/BKR_ABB_EMax2_TCP/main.cpp
deleted file mode 100644
index 286a98c..0000000
--- a/src/EPMS/Breaker/BKR_ABB_EMax2_TCP/main.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-/**
- * @file main.cpp
- * @brief Main execution program for the CRAH Unit (TCP) Emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * @details This file contains the main execution program for an Arduino-based emulator of a CRAH unit. 
- * The program uses a Wi-Fi connection to communicate via the Modbus IP protocol.
- *
- * The setup() function initializes the following:
- * - Serial communication for debugging.
- * - Wi-Fi connection using credentials from config.h.
- * - A Modbus TCP server.
- * - Modbus points (Coils, Holding Registers, etc.) based on a predefined map in config.h.
- *
- * The loop() function continuously:
- * - Services the Modbus TCP server to handle incoming requests.
- * - Periodically calls the main update loop for the emulated equipment, which
- *   manages state transitions and behavior strategies.
- *
- * @see config.h for Wi-Fi and Modbus configuration.
- * @see Equipment.h for the main equipment logic.
- * @see State.h for different equipment states.
- * @see Strategies/Strategy_Behavior.h for value generation strategies.
- * @see Modbus_Point.h for the base class for all Modbus points.
- */
-//=================================================================================================================================
-//Libraries and declaration of variables.
-#include <WiFi.h>
-#include "config.h"
-#include "ModbusPoints/Modbus_PointFactory.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-//=================================================================================================================================
-/** 
- * @brief Initializes the application.
- * @details This function runs once at startup. It configures the serial communication, 
- * Wi-Fi, and the Modbus server. It also creates and initializes all the Modbus points 
- * based on the `mb_map` array in `config.h`.
- */
-void setup() {
-  Serial.begin(115200);                       //Serial comm start
-  WiFi.config(local_IP, gateway, subnet);     // Wifi service start
-  WiFi.begin(ssid, password);
-  while (WiFi.status() != WL_CONNECTED) {
-    delay(1000);
-    Serial.print(".");
-  }
-  Serial.println("Connected!!");
-  mb.server();                                //Modbus server start
-  Serial.println("Server Created");
-  Serial.println(map_size);
-  for(int i = 0; i < map_size; i++){
-    Modbus_Point<ModbusIP>* point = createModbus_Point(&mb, mb_map[i].category, mb_map[i].address, mb_map[i].value, mb_map[i].description);
-    if (point) {
-      point->addToModbusServer();
-      EquipmentInstance.addModbus_Point(mb_map[i].description, point);
-    }
-  }
-  Serial.println("All modbus Points created");
-  Serial.println("Setup function ended");
-}
-//=================================================================================================================================
-/** 
- * @brief The main application loop.
- * @details This function runs repeatedly after setup() has completed. It performs two main actions:
- * 1. It continuously services the Modbus server by calling `mb.task()` to handle
- *    incoming requests from a Modbus master.
- * 2. At a fixed interval (defined in `config.h`), it calls `EquipmentInstance.update()`
- *    to run the emulator's internal state machine and behavior logic.
- */
-void loop() {
-  mb.task();
-  unsigned long currentMillis = millis();
-  if (currentMillis - previousMillis >= interval) {
-    previousMillis = currentMillis;
-    unsigned long startTime = millis();
-    EquipmentInstance.update();
-    unsigned long endTime = millis();
-    unsigned long elapsedTime = endTime - startTime;
-    Serial.printf("Control Execution time: %d ms\n", elapsedTime);
-  } 
-}
diff --git a/src/EPMS/Breaker/BKR_ABB_XT_TCP/README.md b/src/EPMS/Breaker/BKR_ABB_XT_TCP/README.md
deleted file mode 100644
index 355156f..0000000
--- a/src/EPMS/Breaker/BKR_ABB_XT_TCP/README.md
+++ /dev/null
@@ -1,33 +0,0 @@
-# EQUIPMENT_TYPE MANUFACTURER MODEL TCP
-
-## Brief Introduction
-Equipment specifc details that make it different from other devices
-
-## List of Equipmentt
-This cofiguration has been used for these models:
-* **Model**: 09-15-22 
-* **Model**: 09-15-23 
-* **Model**: 09-15-25 
-
-## Hardware Prerequisites
-
-The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities.
-* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html) 
-
----
-
-## States and Strategies
-Provide a brief description of what variables and strategies were used in this configuraiton
-
-### Standby State
-* **Equipment running**: set to 0
-* **Common Alarm**: set to 0
-* **SAT temperature**: set to 85
-
-### Running State
-* **Equipment running**: set to 1
-* **SAT temperature**: **Ramp Strategy** set to 65 deg setpoint
-
-### Fail State
-* **Commong Alarm**: set to 1
-* **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset
diff --git a/src/EPMS/Breaker/BKR_ABB_XT_TCP/State_Fail.cpp b/src/EPMS/Breaker/BKR_ABB_XT_TCP/State_Fail.cpp
deleted file mode 100644
index 8bc0385..0000000
--- a/src/EPMS/Breaker/BKR_ABB_XT_TCP/State_Fail.cpp
+++ /dev/null
@@ -1,81 +0,0 @@
-/**
- * @file State_Fail.cpp
- * @brief Implementation of the FailState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the FailState, which defines
- * the behavior of the equipment when it has entered a fault condition.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new FailState object with a list of active alarms.
- *
- * This constructor receives a list of alarm descriptions and creates strategies
- * to set the corresponding Modbus points to a value of 1, indicating an
- * active alarm. It also initializes a PID strategy for the 'CW Valve Position'
- * to maintain its state during the fault.
- * @param activeAlarms A vector of strings, where each string is the
- *                     description of a Modbus point to be set as an active alarm.
- */
-template<>
-FailState<ModbusIP>::FailState(const std::vector<std::string>& activeAlarms) {
-    // Simulate a failure: set common alarm and a specific fan alarm.
-
-    
-}
-
-/**
- * @brief Executes the fail state's logic for one update cycle.
- *
- * This method checks the "Alarm Reset" Modbus point for a command to
- * transition back to Standby, which would typically happen after a fault
- * is cleared by a user. If no transition is requested, it continues to apply
- * the failure strategies (e.g., keeping alarm bits active).
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* FailState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Fail update function");
-    
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the fail state.
- * Sets the "Alarm Common" point to 1 to indicate a general fault condition.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Fail State...");
-}
-
-/**
- * @brief Logic to execute once when exiting the fail state.
- * Clears the "Alarm Common" point to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Fail State...");
-}
\ No newline at end of file
diff --git a/src/EPMS/Breaker/BKR_ABB_XT_TCP/State_Running.cpp b/src/EPMS/Breaker/BKR_ABB_XT_TCP/State_Running.cpp
deleted file mode 100644
index e044cb4..0000000
--- a/src/EPMS/Breaker/BKR_ABB_XT_TCP/State_Running.cpp
+++ /dev/null
@@ -1,135 +0,0 @@
-/**
- * @file State_Running.cpp
- * @brief Implementation of the RunningState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the RunningState, which defines
- * the behavior of the equipment when it is actively running.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "Strategies/Strategy_Totalizer.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new RunningState object.
- *
- * This constructor initializes behavior strategies active during the running
- * state, such as a PID controller for the 'CW Valve Position' and totalizers
- * for the run-hours of each EC fan.
- */
-template<>
-RunningState<ModbusIP>::RunningState() {
-  addStrategy("Volts AB", new SingleValueStrategy(4800.0F, 5.0f, 1000));
-  addStrategy("Volts BC", new SingleValueStrategy(4800.0F, 5.0f, 1000));
-  addStrategy("Volts CA", new SingleValueStrategy(4800.0F, 5.0f, 1000));
-
-  addStrategy("PF", new SingleValueStrategy(900.0f, 1.0f, 1000));
-
-  addStrategy("Amps A", new SingleValueStrategy(1.0f, 10.0f, 1000));
-  addStrategy("Amps B", new SingleValueStrategy(1.0f, 10.0f, 1000));
-  addStrategy("Amps C", new SingleValueStrategy(1.0f, 10.0f, 1000));
-}
-
-/**
- * @brief Executes the running state's logic for one update cycle.
- *
- * This method first checks for state transition commands:
- * 1. It reads the "ON/OFF Command By BMS" point. If it's 0, it transitions to StandbyState.
- * 2. It reads the "Fault Code" point. If it's non-zero, it transitions to FailState,
- *    passing the corresponding alarm description.
- *
- * If no transition occurs, it applies the strategies defined for the running state.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* RunningState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Running update function");
-    float State_Ctrl = getPointValue(equipment, "State Control");
-    if (State_Ctrl == 0.0f){
-      return new StandbyState<ModbusIP>();
-    }
-    if (State_Ctrl == 2.0f){
-      return new StandbyState<ModbusIP>();
-    }
-    // Apply any strategies defined for the standby state
-    float volts_AB = getPointValue(equipment, "Volts AB");
-    float volts_BC = getPointValue(equipment, "Volts BC");
-    float volts_AC = getPointValue(equipment, "Volts CA");
-
-    setPointValue(equipment, "Volts AN", volts_AB/1.732f);
-    setPointValue(equipment, "Volts BN", volts_BC/1.732f);
-    setPointValue(equipment, "Volts CN", volts_AC/1.732f);
-
-
-    int I_load = getPointValue(equipment, "Load");
-    int I_rating = getPointValue(equipment, "Rating");
-    float load = static_cast<float>(I_load);
-    float rating = static_cast<float>(I_rating);
-    float real_load = rating * (load/100.0f);
-    setPointValue(equipment, "Amps A", real_load * 10.0f);
-    setPointValue(equipment, "Amps B", real_load * 10.0f);
-    setPointValue(equipment, "Amps C", real_load * 10.0f);
-    setPointValue(equipment, "Amps G", volts_AB * 0.037f);
-    setPointValue(equipment, "Amps N", volts_BC * 0.034f);
-
-    float pf = getPointValue(equipment, "PF");
-
-
-    float kva = (1.732f * ((volts_AB + volts_BC + volts_AC)/4.0f) * real_load * (pf/100.0f))/100000.0f;
-    float kw =  (1.732f * ((volts_AB + volts_BC + volts_AC)/4.0f) * real_load )/10000.0f;
-
-    setPointValue(equipment, "kW", kw);
-    setPointValue(equipment, "kVA", kva);
-    setPointValue(equipment, "kWh", 1724.0f);
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the running state.
- * Sets the "Run Status" for all EC fans to 1 to indicate they are active.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Running State...");
-    // You could also update a Modbus register to show the "standby" state
-    setBitValue(equipment, "CB Position", 0, true);
-    setBitValue(equipment, "CB Position", 12, false);
-}
-
-/**
- * @brief Logic to execute once when exiting the running state.
- * Sets the "Run Status" for all EC fans to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Running State...");
-   
-}
\ No newline at end of file
diff --git a/src/EPMS/Breaker/BKR_ABB_XT_TCP/State_Standby.cpp b/src/EPMS/Breaker/BKR_ABB_XT_TCP/State_Standby.cpp
deleted file mode 100644
index e065339..0000000
--- a/src/EPMS/Breaker/BKR_ABB_XT_TCP/State_Standby.cpp
+++ /dev/null
@@ -1,112 +0,0 @@
-/**
- * @file State_Standby.cpp
- * @brief Implementation of the StandbyState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the StandbyState, which defines
- * the behavior of the equipment when it is in an idle or standby mode.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-/**
- * @brief Constructs a new StandbyState object.
- *
- * In this state, the equipment is idle. This constructor initializes strategies
- * to bring the system to a safe, idle condition. It sets a stable value for
- * the SAT reading and creates ramp strategies to bring the CW valve and all
- * EC fan speeds down to zero.
- */
-template<>
-StandbyState<ModbusIP>::StandbyState() {
-    // You can add initialization code here if needed
-    
-
-}
-
-/**
- * @brief Executes the standby state's logic for one update cycle.
- *
- * This method applies the strategies defined for the standby state (e.g.,
- * ramping values to zero).
- *
- * @warning This method currently does not check for a command to transition to the
- *          Running state. This logic needs to be added to allow the unit to start.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* StandbyState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Standby update function");
-    float State_Ctrl = getPointValue(equipment, "State Control");
-    if (State_Ctrl == 1.0f){
-      return new RunningState<ModbusIP>();
-    }
-
-    if (State_Ctrl == 0.0f){
-      setBitValue(equipment, "CB Position", 12, false);
-    }
-    if (State_Ctrl == 2.0f){
-      setBitValue(equipment, "CB Position", 12, true);
-    }
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the standby state.
- * This method performs cleanup by setting all alarm points and all EC fan
- * run status points to 0.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Standby State...");
-    setBitValue(equipment, "CB Position", 0, false);
-    setPointValue(equipment, "Volts AB", 0.0f);
-    setPointValue(equipment, "Volts BC", 0.0f);
-    setPointValue(equipment, "Volts CA", 0.0f);
-    setPointValue(equipment, "Volts AN", 0.0f);
-    setPointValue(equipment, "Volts BN", 0.0f);
-    setPointValue(equipment, "Volts CN", 0.0f);
-    setPointValue(equipment, "PF", 0.0f);
-    setPointValue(equipment, "Amps A", 0.0f);
-    setPointValue(equipment, "Amps B", 0.0f);
-    setPointValue(equipment, "Amps C", 0.0f);
-    setPointValue(equipment, "Amps G", 0.0f);
-    setPointValue(equipment, "Amps N", 0.0f);
-    setPointValue(equipment, "kW", 0.0f);
-    setPointValue(equipment, "kVA", 0.0f);
-    setPointValue(equipment, "kWh", 0.0f);
-    setBitValue(equipment, "Alarm General", 0, false);
-}
-
-/**
- * @brief Logic to execute once when exiting the standby state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Standby State...");
-}
\ No newline at end of file
diff --git a/src/EPMS/Breaker/BKR_ABB_XT_TCP/config.h b/src/EPMS/Breaker/BKR_ABB_XT_TCP/config.h
deleted file mode 100644
index 7dd406b..0000000
--- a/src/EPMS/Breaker/BKR_ABB_XT_TCP/config.h
+++ /dev/null
@@ -1,95 +0,0 @@
-/**
- * @file config.h
- * @brief Main configuration file for the Braker ABB XT
- * @author Zach Gutierrez
- * @date 2025-09-02
- *
- * This file contains two important configurations: WiFi network parameters
- * and the Modbus register map for the device.
- */
-
-#ifndef CONFIG_H
-#define CONFIG_H
-
-#include "core.h"
-#include "Equipment/Equipment.h"
-
-#if defined(USE_MODBUS_IP)
-/**
-   * @defgroup ModbusTCPConfig Modbus IP Configuration
-   * @brief Parameters for Modbus TCP communication.
-   * @{
-   */
-  #include <ModbusIP_ESP8266.h>
-  const char *ssid = "ArduinoWifiB";       /**< @brief The SSID of the WiFi network. */
-  const char *password = "123abc456";   /**< @brief The password for the WiFi network. */
-  IPAddress local_IP(172, 17, 32, 102);       /**< @brief The static IP address for the device. */
-  IPAddress gateway(172, 17, 32, 1);          /**< @brief The gateway IP address. */
-  IPAddress subnet(255, 255, 255, 0);         /**< @brief The subnet mask. */
-  
-  ModbusIP mb;
-#else
-  /**
-   * @defgroup ModbusRTUConfig Modbus RTU Configuration
-   * @brief Parameters for serial Modbus RTU communication.
-   * @{
-   */
-  #include <ModbusRTU.h>
-  const int BAUDRATE = 19200;   /**< @brief The serial communication speed in bits per second. */
-  const int RX_PIN = 17;        /**< @brief The GPIO pin used for receiving data (RX). */
-  const int TX_PIN = 16;        /**< @brief The GPIO pin used for transmitting data (TX). */
-  const int RST_PIN = 4;        /**< @brief The GPIO pin connected to the RS485 driver's DE/RE pins for direction control. */
-  const int MODBUS_ID = 1;      /**< @brief The unique slave ID for this device on the Modbus bus. */
-  /** @} */
-
-  /** @brief Global instance of the Modbus RTU server. */
-  ModbusRTU mb;
-#endif
-
-
-
-/**
- * @defgroup ModbusMapConfig Modbus Map Configuration
- * @brief Defines the Modbus register map and related parameters for the emulator.
- * @{
- */
-/**
- * @brief The Modbus map for the Equipment device.
- * This array defines all the Modbus points available on the emulated device.
- * The `description` field is crucial as it's used to look up points within the application logic.
- */
-modbusMap mb_map[] =
-{   
-  {HR,        9,      0,  "State Control"}, //Open-Close Cmd
-  {HR,        10,     0,  "Load"},          //Adjustble Load
-  {HR,        11,     0,  "Rating"},        //Max amp to calculate kw, kVA, etc
-  {IR,        41,     0,  "CB Position"},   //b0 close open  b12 tripped
-  {IR_LONG,   101,    0,  "Amps A"},
-  {IR_LONG,   103,    0,  "Amps B"},
-  {IR_LONG,   105,    0,  "Amps C"},
-  {IR_LONG,   107,    0,  "Amps G"},
-  {IR_LONG,   109,    0,  "Amps N"},
-  {IR,        151,    0,  "Volts AN"},
-  {IR,        152,    0,  "Volts BN"},
-  {IR,        153,    0,  "Volts CN"},
-  {IR,        155,    0,  "Volts AB"},
-  {IR,        156,    0,  "Volts BC"},
-  {IR,        157,    0,  "Volts CA"},
-  {IR_LONG,   207,    0,  "kW"},
-  {IR_LONG,   223,    0,  "kVA"},
-  {IR,        254,    0,  "PF"},
-  {IR_LONG,   305,    0,  "kWh"},
-};
-//Size of modbus map used in FOR cycles, automatically calculated.
-
-/**
- * @brief The total number of entries in the `mb_map` array.
- * This is calculated at compile time and used for iterating over the map.
- */
-const int map_size = sizeof(mb_map) / sizeof(mb_map[0]);
-
-/** @brief The main loop update interval in milliseconds. */
-int interval = 250; 
-/** @} */ // End of ModbusMapConfig group
-
-#endif // CONFIG_H
diff --git a/src/EPMS/Breaker/BKR_ABB_XT_TCP/main.cpp b/src/EPMS/Breaker/BKR_ABB_XT_TCP/main.cpp
deleted file mode 100644
index 286a98c..0000000
--- a/src/EPMS/Breaker/BKR_ABB_XT_TCP/main.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-/**
- * @file main.cpp
- * @brief Main execution program for the CRAH Unit (TCP) Emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * @details This file contains the main execution program for an Arduino-based emulator of a CRAH unit. 
- * The program uses a Wi-Fi connection to communicate via the Modbus IP protocol.
- *
- * The setup() function initializes the following:
- * - Serial communication for debugging.
- * - Wi-Fi connection using credentials from config.h.
- * - A Modbus TCP server.
- * - Modbus points (Coils, Holding Registers, etc.) based on a predefined map in config.h.
- *
- * The loop() function continuously:
- * - Services the Modbus TCP server to handle incoming requests.
- * - Periodically calls the main update loop for the emulated equipment, which
- *   manages state transitions and behavior strategies.
- *
- * @see config.h for Wi-Fi and Modbus configuration.
- * @see Equipment.h for the main equipment logic.
- * @see State.h for different equipment states.
- * @see Strategies/Strategy_Behavior.h for value generation strategies.
- * @see Modbus_Point.h for the base class for all Modbus points.
- */
-//=================================================================================================================================
-//Libraries and declaration of variables.
-#include <WiFi.h>
-#include "config.h"
-#include "ModbusPoints/Modbus_PointFactory.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-//=================================================================================================================================
-/** 
- * @brief Initializes the application.
- * @details This function runs once at startup. It configures the serial communication, 
- * Wi-Fi, and the Modbus server. It also creates and initializes all the Modbus points 
- * based on the `mb_map` array in `config.h`.
- */
-void setup() {
-  Serial.begin(115200);                       //Serial comm start
-  WiFi.config(local_IP, gateway, subnet);     // Wifi service start
-  WiFi.begin(ssid, password);
-  while (WiFi.status() != WL_CONNECTED) {
-    delay(1000);
-    Serial.print(".");
-  }
-  Serial.println("Connected!!");
-  mb.server();                                //Modbus server start
-  Serial.println("Server Created");
-  Serial.println(map_size);
-  for(int i = 0; i < map_size; i++){
-    Modbus_Point<ModbusIP>* point = createModbus_Point(&mb, mb_map[i].category, mb_map[i].address, mb_map[i].value, mb_map[i].description);
-    if (point) {
-      point->addToModbusServer();
-      EquipmentInstance.addModbus_Point(mb_map[i].description, point);
-    }
-  }
-  Serial.println("All modbus Points created");
-  Serial.println("Setup function ended");
-}
-//=================================================================================================================================
-/** 
- * @brief The main application loop.
- * @details This function runs repeatedly after setup() has completed. It performs two main actions:
- * 1. It continuously services the Modbus server by calling `mb.task()` to handle
- *    incoming requests from a Modbus master.
- * 2. At a fixed interval (defined in `config.h`), it calls `EquipmentInstance.update()`
- *    to run the emulator's internal state machine and behavior logic.
- */
-void loop() {
-  mb.task();
-  unsigned long currentMillis = millis();
-  if (currentMillis - previousMillis >= interval) {
-    previousMillis = currentMillis;
-    unsigned long startTime = millis();
-    EquipmentInstance.update();
-    unsigned long endTime = millis();
-    unsigned long elapsedTime = endTime - startTime;
-    Serial.printf("Control Execution time: %d ms\n", elapsedTime);
-  } 
-}
diff --git a/src/EPMS/Breaker/BKR_Eaton_PXR20_25/README.md b/src/EPMS/Breaker/BKR_Eaton_PXR20_25/README.md
deleted file mode 100644
index 4f156e3..0000000
--- a/src/EPMS/Breaker/BKR_Eaton_PXR20_25/README.md
+++ /dev/null
@@ -1,48 +0,0 @@
-# Daikin Chiller (RTU) Emulator
-
-This project is an Arduino-based emulator for a Daikin Chiller unit, communicating over Modbus RTU. It is designed to be a flexible template that can be adapted to simulate different types of chillers by modifying the configuration and state logic.
-
-The emulator operates on a state machine with three core states:
-* **Standby**: The chiller is idle but ready.
-* **Running**: The chiller is active and operational.
-* **Fail**: The chiller has encountered a fault condition.
-
-## Features
-
-* **Modbus RTU Communication**: Emulates a Modbus slave device.
-* **State Machine Logic**: Simulates different operational states (Standby, Running, Fail).
-* **Dynamic Value Simulation**: Uses "Strategies" (e.g., PID, Ramp) to generate realistic, changing values for Modbus points.
-* **Configurable Modbus Map**: The entire Modbus register map is defined in a single, easy-to-modify file (`config.h`).
-* **Extensible Design**: The structure allows for the addition of new states and behaviors.
-
-## Hardware Prerequisites
-
-The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities and at least one hardware serial port for RS485 communication.
-
-* **Microcontroller**: ESP8266, ESP32, or similar.
-* **RS485 Transceiver**: A module like the MAX485 to interface with the Modbus RTU bus.
-
-## Software Dependencies
-
-This project relies on a Modbus library. Ensure you have the correct library installed in your Arduino IDE.
-
-* **Modbus Library**: The code uses a library that provides `ModbusRTU.h` and optionally `ModbusIP_ESP8266.h`.
-
----
-
-## How to Customize for a New Chiller
-
-To adapt this template for a new chiller, follow these steps.
-
-### 1. Configure Device-Specific Parameters (`config.h`)
-
-Open `CH_Daikin_AWV026B_RTU/config.h`. This is the main file for device-specific settings.
-
-#### Modbus RTU Settings
-Update the following constants for your device's serial communication setup.
-```c++
-const int BAUDRATE = 19200;   // The serial communication speed
-const int RX_PIN = 17;        // The GPIO pin for receiving data (RX)
-const int TX_PIN = 16;        // The GPIO pin for transmitting data (TX)
-const int RST_PIN = 4;        // The GPIO pin for RS485 direction control
-const int MODBUS_ID = 1;      // The unique slave ID for this device
\ No newline at end of file
diff --git a/src/EPMS/Breaker/BKR_Eaton_PXR20_25/State_Fail.cpp b/src/EPMS/Breaker/BKR_Eaton_PXR20_25/State_Fail.cpp
deleted file mode 100644
index 8bc0385..0000000
--- a/src/EPMS/Breaker/BKR_Eaton_PXR20_25/State_Fail.cpp
+++ /dev/null
@@ -1,81 +0,0 @@
-/**
- * @file State_Fail.cpp
- * @brief Implementation of the FailState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the FailState, which defines
- * the behavior of the equipment when it has entered a fault condition.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new FailState object with a list of active alarms.
- *
- * This constructor receives a list of alarm descriptions and creates strategies
- * to set the corresponding Modbus points to a value of 1, indicating an
- * active alarm. It also initializes a PID strategy for the 'CW Valve Position'
- * to maintain its state during the fault.
- * @param activeAlarms A vector of strings, where each string is the
- *                     description of a Modbus point to be set as an active alarm.
- */
-template<>
-FailState<ModbusIP>::FailState(const std::vector<std::string>& activeAlarms) {
-    // Simulate a failure: set common alarm and a specific fan alarm.
-
-    
-}
-
-/**
- * @brief Executes the fail state's logic for one update cycle.
- *
- * This method checks the "Alarm Reset" Modbus point for a command to
- * transition back to Standby, which would typically happen after a fault
- * is cleared by a user. If no transition is requested, it continues to apply
- * the failure strategies (e.g., keeping alarm bits active).
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* FailState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Fail update function");
-    
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the fail state.
- * Sets the "Alarm Common" point to 1 to indicate a general fault condition.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Fail State...");
-}
-
-/**
- * @brief Logic to execute once when exiting the fail state.
- * Clears the "Alarm Common" point to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Fail State...");
-}
\ No newline at end of file
diff --git a/src/EPMS/Breaker/BKR_Eaton_PXR20_25/State_Running.cpp b/src/EPMS/Breaker/BKR_Eaton_PXR20_25/State_Running.cpp
deleted file mode 100644
index 431ab66..0000000
--- a/src/EPMS/Breaker/BKR_Eaton_PXR20_25/State_Running.cpp
+++ /dev/null
@@ -1,138 +0,0 @@
-/**
- * @file State_Running.cpp
- * @brief Implementation of the RunningState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the RunningState, which defines
- * the behavior of the equipment when it is actively running.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "Strategies/Strategy_Totalizer.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new RunningState object.
- *
- * This constructor initializes behavior strategies active during the running
- * state, such as a PID controller for the 'CW Valve Position' and totalizers
- * for the run-hours of each EC fan.
- */
-template<>
-RunningState<ModbusIP>::RunningState() {
-  addStrategy("Volts AB", new SingleValueStrategy(480.0F, 5.0f, 1000));
-  addStrategy("Volts BC", new SingleValueStrategy(480.0F, 5.0f, 1000));
-  addStrategy("Volts CA", new SingleValueStrategy(480.0F, 5.0f, 1000));
-
-  addStrategy("PF", new SingleValueStrategy(0.9f, 0.05f, 1000));
-
-  addStrategy("Amps A", new SingleValueStrategy(1.0f, 10.0f, 1000));
-  addStrategy("Amps B", new SingleValueStrategy(1.0f, 10.0f, 1000));
-  addStrategy("Amps C", new SingleValueStrategy(1.0f, 10.0f, 1000));
-
-}
-
-/**
- * @brief Executes the running state's logic for one update cycle.
- *
- * This method first checks for state transition commands:
- * 1. It reads the "ON/OFF Command By BMS" point. If it's 0, it transitions to StandbyState.
- * 2. It reads the "Fault Code" point. If it's non-zero, it transitions to FailState,
- *    passing the corresponding alarm description.
- *
- * If no transition occurs, it applies the strategies defined for the running state.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* RunningState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Running update function");
-    float State_Ctrl = getPointValue(equipment, "State Control");
-    if (State_Ctrl == 0){
-      return new StandbyState<ModbusIP>();
-    }
-    if (State_Ctrl == 2){
-      return new StandbyState<ModbusIP>();
-    }
-    // Apply any strategies defined for the standby state
-    float volts_AB = getPointValue(equipment, "Volts AB");
-    float volts_BC = getPointValue(equipment, "Volts BC");
-    float volts_AC = getPointValue(equipment, "Volts CA");
-
-    setPointValue(equipment, "Volts AN", volts_AB/1.732);
-    setPointValue(equipment, "Volts BN", volts_BC/1.732);
-    setPointValue(equipment, "Volts CN", volts_AC/1.732);
-
-
-    int I_load = getPointValue(equipment, "Load");
-    int I_rating = getPointValue(equipment, "Rating");
-    float load = static_cast<float>(I_load);
-    float rating = static_cast<float>(I_rating);
-    float real_load = rating * (load/100.0f);
-    Strategy_Behavior* ampsA_svs = getStrategy("Amps A");
-    Strategy_Behavior* ampsB_svs = getStrategy("Amps B");
-    Strategy_Behavior* ampsC_svs = getStrategy("Amps C");
-
-    static_cast<SingleValueStrategy*>(ampsA_svs)->setSetpoint(real_load);
-    static_cast<SingleValueStrategy*>(ampsB_svs)->setSetpoint(real_load);
-    static_cast<SingleValueStrategy*>(ampsC_svs)->setSetpoint(real_load);
-
-    float pf = getPointValue(equipment, "PF");
-
-
-    float kw = (1.732f * ((volts_AB + volts_BC + volts_AC)/3.0f) * real_load * pf)/1000;
-    float kva = (1.732f * ((volts_AB + volts_BC + volts_AC)/3.0f) * real_load)/1000;
-
-    setPointValue(equipment, "kW", kw);
-    setPointValue(equipment, "kVA", kva);
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the running state.
- * Sets the "Run Status" for all EC fans to 1 to indicate they are active.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Running State...");
-    // You could also update a Modbus register to show the "standby" state
-    setPointValue(equipment, "CB Position", 2048);
-    setPointValue(equipment, "CB Trip", 0.0f);
-
-}
-
-/**
- * @brief Logic to execute once when exiting the running state.
- * Sets the "Run Status" for all EC fans to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Running State...");
-   
-}
\ No newline at end of file
diff --git a/src/EPMS/Breaker/BKR_Eaton_PXR20_25/State_Standby.cpp b/src/EPMS/Breaker/BKR_Eaton_PXR20_25/State_Standby.cpp
deleted file mode 100644
index f2195c2..0000000
--- a/src/EPMS/Breaker/BKR_Eaton_PXR20_25/State_Standby.cpp
+++ /dev/null
@@ -1,107 +0,0 @@
-/**
- * @file State_Standby.cpp
- * @brief Implementation of the StandbyState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the StandbyState, which defines
- * the behavior of the equipment when it is in an idle or standby mode.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-/**
- * @brief Constructs a new StandbyState object.
- *
- * In this state, the equipment is idle. This constructor initializes strategies
- * to bring the system to a safe, idle condition. It sets a stable value for
- * the SAT reading and creates ramp strategies to bring the CW valve and all
- * EC fan speeds down to zero.
- */
-template<>
-StandbyState<ModbusIP>::StandbyState() {
-    // You can add initialization code here if needed
-    
-
-}
-
-/**
- * @brief Executes the standby state's logic for one update cycle.
- *
- * This method applies the strategies defined for the standby state (e.g.,
- * ramping values to zero).
- *
- * @warning This method currently does not check for a command to transition to the
- *          Running state. This logic needs to be added to allow the unit to start.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* StandbyState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Standby update function");
-    float State_Ctrl = getPointValue(equipment, "State Control");
-    if (State_Ctrl == 1){
-      return new RunningState<ModbusIP>();
-    }
-
-    if (State_Ctrl == 0){
-      setPointValue(equipment, "CB Trip", 0.0f);
-    }
-    if (State_Ctrl == 2){
-      setPointValue(equipment, "CB Trip", 1.0f);
-    }
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the standby state.
- * This method performs cleanup by setting all alarm points and all EC fan
- * run status points to 0.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Standby State...");
-    setPointValue(equipment, "CB Position", 0);
-    setPointValue(equipment, "Volts AB", 0.0f);
-    setPointValue(equipment, "Volts BC", 0.0f);
-    setPointValue(equipment, "Volts CA", 0.0f);
-    setPointValue(equipment, "Volts AN", 0.0f);
-    setPointValue(equipment, "Volts BN", 0.0f);
-    setPointValue(equipment, "Volts CN", 0.0f);
-    setPointValue(equipment, "PF", 0.0f);
-    setPointValue(equipment, "Amps A", 0.0f);
-    setPointValue(equipment, "Amps B", 0.0f);
-    setPointValue(equipment, "Amps C", 0.0f);
-}
-
-/**
- * @brief Logic to execute once when exiting the standby state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Standby State...");
-    
-}
\ No newline at end of file
diff --git a/src/EPMS/Breaker/BKR_Eaton_PXR20_25/config.h b/src/EPMS/Breaker/BKR_Eaton_PXR20_25/config.h
deleted file mode 100644
index 6a3bd12..0000000
--- a/src/EPMS/Breaker/BKR_Eaton_PXR20_25/config.h
+++ /dev/null
@@ -1,96 +0,0 @@
-/**
- * @file config.h
- * @brief Main configuration file for the CRAH Unit (TCP) emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * This file contains two important configurations: WiFi network parameters
- * and the Modbus register map for the device.
- */
-
-#ifndef CONFIG_H
-#define CONFIG_H
-
-#include "core.h"
-#include "Equipment/Equipment.h"
-
-#if defined(USE_MODBUS_IP)
-/**
-   * @defgroup ModbusTCPConfig Modbus IP Configuration
-   * @brief Parameters for Modbus TCP communication.
-   * @{
-   */
-  #include <ModbusIP_ESP8266.h>
-  const char *ssid = "QTS_CDR_Arduino";       /**< @brief The SSID of the WiFi network. */
-  const char *password = "123abc456";   /**< @brief The password for the WiFi network. */
-  IPAddress local_IP(172, 17, 33, 167);       /**< @brief The static IP address for the device. */
-  IPAddress gateway(172, 17, 33, 1);          /**< @brief The gateway IP address. */
-  IPAddress subnet(255, 255, 255, 0);         /**< @brief The subnet mask. */
-  
-  ModbusIP mb;
-#else
-  /**
-   * @defgroup ModbusRTUConfig Modbus RTU Configuration
-   * @brief Parameters for serial Modbus RTU communication.
-   * @{
-   */
-  #include <ModbusRTU.h>
-  const int BAUDRATE = 19200;   /**< @brief The serial communication speed in bits per second. */
-  const int RX_PIN = 17;        /**< @brief The GPIO pin used for receiving data (RX). */
-  const int TX_PIN = 16;        /**< @brief The GPIO pin used for transmitting data (TX). */
-  const int RST_PIN = 4;        /**< @brief The GPIO pin connected to the RS485 driver's DE/RE pins for direction control. */
-  const int MODBUS_ID = 1;      /**< @brief The unique slave ID for this device on the Modbus bus. */
-  /** @} */
-
-  /** @brief Global instance of the Modbus RTU server. */
-  ModbusRTU mb;
-#endif
-
-
-
-/**
- * @defgroup ModbusMapConfig Modbus Map Configuration
- * @brief Defines the Modbus register map and related parameters for the emulator.
- * @{
- */
-/**
- * @brief The Modbus map for the Equipment device.
- * This array defines all the Modbus points available on the emulated device.
- * The `description` field is crucial as it's used to look up points within the application logic.
- */
-modbusMap mb_map[] =
-{   
-  {HR,        9,      0,  "State Control"}, //Open-Close Cmd
-  {HR,        10,     0,  "Load"},          //Adjustble Load
-  {HR,        11,     0,  "Rating"},        //Max amp to calculate kw, kVA, etc
-  {HR_FLOAT, 4610,    0,  "Amps A"},      
-  {HR_FLOAT, 4612,    0,  "Amps B"},                     
-  {HR_FLOAT, 4614,    0,  "Amps C"},                   
-  {HR_FLOAT, 4616,    0,  "Amps G"},                 
-  {HR_FLOAT, 4618,    0,  "Amps N"}, 
-  {HR_FLOAT, 4622,    0,  "Volts AB"},                
-  {HR_FLOAT, 4624,    0,  "Volts BC"},
-  {HR_FLOAT, 4626,    0,  "Volts CA"},
-  {HR_FLOAT, 4630,    0,  "Volts AN"}, 
-  {HR_FLOAT, 4632,    0,  "Volts BN"},
-  {HR_FLOAT, 4634,    0,  "Volts CN"},
-  {HR_FLOAT, 4650,    0,  "kW"},
-  {HR_FLOAT, 4654,    0,  "kVA"},
-  {HR_FLOAT, 4658,    0,  "PF"}, 
-  {HR_FLOAT, 6262,    0,  "kWh"},
-  {DI,       1000,    0,  "CB Position"}, 
-  {DI,       1001,    0,  "CB Trip"},                             
-};
-//Size of modbus map used in FOR cycles, automatically calculated.
-
-/**
- * @brief The total number of entries in the `mb_map` array.
- * This is calculated at compile time and used for iterating over the map.
- */
-const int map_size = sizeof(mb_map) / sizeof(mb_map[0]);
-
-/** @brief The main loop update interval in milliseconds. */
-int interval = 250; 
-/** @} */ // End of ModbusMapConfig group
-
-#endif // CONFIG_H
diff --git a/src/EPMS/Breaker/BKR_Eaton_PXR20_25/main.cpp b/src/EPMS/Breaker/BKR_Eaton_PXR20_25/main.cpp
deleted file mode 100644
index 286a98c..0000000
--- a/src/EPMS/Breaker/BKR_Eaton_PXR20_25/main.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-/**
- * @file main.cpp
- * @brief Main execution program for the CRAH Unit (TCP) Emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * @details This file contains the main execution program for an Arduino-based emulator of a CRAH unit. 
- * The program uses a Wi-Fi connection to communicate via the Modbus IP protocol.
- *
- * The setup() function initializes the following:
- * - Serial communication for debugging.
- * - Wi-Fi connection using credentials from config.h.
- * - A Modbus TCP server.
- * - Modbus points (Coils, Holding Registers, etc.) based on a predefined map in config.h.
- *
- * The loop() function continuously:
- * - Services the Modbus TCP server to handle incoming requests.
- * - Periodically calls the main update loop for the emulated equipment, which
- *   manages state transitions and behavior strategies.
- *
- * @see config.h for Wi-Fi and Modbus configuration.
- * @see Equipment.h for the main equipment logic.
- * @see State.h for different equipment states.
- * @see Strategies/Strategy_Behavior.h for value generation strategies.
- * @see Modbus_Point.h for the base class for all Modbus points.
- */
-//=================================================================================================================================
-//Libraries and declaration of variables.
-#include <WiFi.h>
-#include "config.h"
-#include "ModbusPoints/Modbus_PointFactory.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-//=================================================================================================================================
-/** 
- * @brief Initializes the application.
- * @details This function runs once at startup. It configures the serial communication, 
- * Wi-Fi, and the Modbus server. It also creates and initializes all the Modbus points 
- * based on the `mb_map` array in `config.h`.
- */
-void setup() {
-  Serial.begin(115200);                       //Serial comm start
-  WiFi.config(local_IP, gateway, subnet);     // Wifi service start
-  WiFi.begin(ssid, password);
-  while (WiFi.status() != WL_CONNECTED) {
-    delay(1000);
-    Serial.print(".");
-  }
-  Serial.println("Connected!!");
-  mb.server();                                //Modbus server start
-  Serial.println("Server Created");
-  Serial.println(map_size);
-  for(int i = 0; i < map_size; i++){
-    Modbus_Point<ModbusIP>* point = createModbus_Point(&mb, mb_map[i].category, mb_map[i].address, mb_map[i].value, mb_map[i].description);
-    if (point) {
-      point->addToModbusServer();
-      EquipmentInstance.addModbus_Point(mb_map[i].description, point);
-    }
-  }
-  Serial.println("All modbus Points created");
-  Serial.println("Setup function ended");
-}
-//=================================================================================================================================
-/** 
- * @brief The main application loop.
- * @details This function runs repeatedly after setup() has completed. It performs two main actions:
- * 1. It continuously services the Modbus server by calling `mb.task()` to handle
- *    incoming requests from a Modbus master.
- * 2. At a fixed interval (defined in `config.h`), it calls `EquipmentInstance.update()`
- *    to run the emulator's internal state machine and behavior logic.
- */
-void loop() {
-  mb.task();
-  unsigned long currentMillis = millis();
-  if (currentMillis - previousMillis >= interval) {
-    previousMillis = currentMillis;
-    unsigned long startTime = millis();
-    EquipmentInstance.update();
-    unsigned long endTime = millis();
-    unsigned long elapsedTime = endTime - startTime;
-    Serial.printf("Control Execution time: %d ms\n", elapsedTime);
-  } 
-}
diff --git a/src/EPMS/Breaker/BKR_Susol_ACB_TCP/README.md b/src/EPMS/Breaker/BKR_Susol_ACB_TCP/README.md
deleted file mode 100644
index 355156f..0000000
--- a/src/EPMS/Breaker/BKR_Susol_ACB_TCP/README.md
+++ /dev/null
@@ -1,33 +0,0 @@
-# EQUIPMENT_TYPE MANUFACTURER MODEL TCP
-
-## Brief Introduction
-Equipment specifc details that make it different from other devices
-
-## List of Equipmentt
-This cofiguration has been used for these models:
-* **Model**: 09-15-22 
-* **Model**: 09-15-23 
-* **Model**: 09-15-25 
-
-## Hardware Prerequisites
-
-The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities.
-* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html) 
-
----
-
-## States and Strategies
-Provide a brief description of what variables and strategies were used in this configuraiton
-
-### Standby State
-* **Equipment running**: set to 0
-* **Common Alarm**: set to 0
-* **SAT temperature**: set to 85
-
-### Running State
-* **Equipment running**: set to 1
-* **SAT temperature**: **Ramp Strategy** set to 65 deg setpoint
-
-### Fail State
-* **Commong Alarm**: set to 1
-* **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset
diff --git a/src/EPMS/Breaker/BKR_Susol_ACB_TCP/State_Fail.cpp b/src/EPMS/Breaker/BKR_Susol_ACB_TCP/State_Fail.cpp
deleted file mode 100644
index 17f120b..0000000
--- a/src/EPMS/Breaker/BKR_Susol_ACB_TCP/State_Fail.cpp
+++ /dev/null
@@ -1,85 +0,0 @@
-/**
- * @file State_Fail.cpp
- * @brief Implementation of the FailState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the FailState, which defines
- * the behavior of the equipment when it has entered a fault condition.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new FailState object with a list of active alarms.
- *
- * This constructor receives a list of alarm descriptions and creates strategies
- * to set the corresponding Modbus points to a value of 1, indicating an
- * active alarm. It also initializes a PID strategy for the 'CW Valve Position'
- * to maintain its state during the fault.
- * @param activeAlarms A vector of strings, where each string is the
- *                     description of a Modbus point to be set as an active alarm.
- */
-template<>
-FailState<ModbusIP>::FailState(const std::vector<std::string>& activeAlarms) {
-    // Simulate a failure: set common alarm and a specific fan alarm.
-
-    
-}
-
-/**
- * @brief Executes the fail state's logic for one update cycle.
- *
- * This method checks the "Alarm Reset" Modbus point for a command to
- * transition back to Standby, which would typically happen after a fault
- * is cleared by a user. If no transition is requested, it continues to apply
- * the failure strategies (e.g., keeping alarm bits active).
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* FailState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Fail update function");
-    float State_Ctrl = getPointValue(equipment, "State Control");
-    if (State_Ctrl == 1){
-      return new StandbyState<ModbusIP>();
-    }
-    
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the fail state.
- * Sets the "Alarm Common" point to 1 to indicate a general fault condition.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Fail State...");
-}
-
-/**
- * @brief Logic to execute once when exiting the fail state.
- * Clears the "Alarm Common" point to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Fail State...");
-}
\ No newline at end of file
diff --git a/src/EPMS/Breaker/BKR_Susol_ACB_TCP/State_Running.cpp b/src/EPMS/Breaker/BKR_Susol_ACB_TCP/State_Running.cpp
deleted file mode 100644
index a7c0ad2..0000000
--- a/src/EPMS/Breaker/BKR_Susol_ACB_TCP/State_Running.cpp
+++ /dev/null
@@ -1,114 +0,0 @@
-/**
- * @file State_Running.cpp
- * @brief Implementation of the RunningState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the RunningState, which defines
- * the behavior of the equipment when it is actively running.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "Strategies/Strategy_Totalizer.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new RunningState object.
- *
- * This constructor initializes behavior strategies active during the runnings
- * state, such as a PID controller for the 'CW Valve Position' and totalizers
- * for the run-hours of each EC fan.
- */
-template<>
-RunningState<ModbusIP>::RunningState() {
-  addStrategy("Amps A", new SingleValueStrategy(1.0f, 5.0f, 1000));
-  addStrategy("Amps B", new SingleValueStrategy(1.0f, 5.0f, 1000));
-  addStrategy("Amps C", new SingleValueStrategy(1.0f, 5.0f, 1000));
-}
-
-/**
- * @brief Executes the running state's logic for one update cycle.
- *
- * This method first checks for state transition commands:
- * 1. It reads the "ON/OFF Command By BMS" point. If it's 0, it transitions to StandbyState.
- * 2. It reads the "Fault Code" point. If it's non-zero, it transitions to FailState,
- *    passing the corresponding alarm description.
- *
- * If no transition occurs, it applies the strategies defined for the running state.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* RunningState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Running update function");
-    float State_Ctrl = getPointValue(equipment, "State Control");
-    if (State_Ctrl == 0.0f){
-      return new StandbyState<ModbusIP>();
-    }
-    if (State_Ctrl == 2.0f){
-      return new StandbyState<ModbusIP>();
-    }
-
-    // Apply any strategies defined for the standby state
-    int I_load = getPointValue(equipment, "Load");
-    int I_rating = getPointValue(equipment, "Rating");
-    float load = static_cast<float>(I_load);
-    float rating = static_cast<float>(I_rating);
-    float real_load = rating * (load/100.0f);
-    Strategy_Behavior* ampsA_svs = getStrategy("Amps A");
-    Strategy_Behavior* ampsB_svs = getStrategy("Amps B");
-    Strategy_Behavior* ampsC_svs = getStrategy("Amps C");
-
-    static_cast<SingleValueStrategy*>(ampsA_svs)->setSetpoint(real_load);
-    static_cast<SingleValueStrategy*>(ampsB_svs)->setSetpoint(real_load);
-    static_cast<SingleValueStrategy*>(ampsC_svs)->setSetpoint(real_load);
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the running state.
- * Sets the "Run Status" for all EC fans to 1 to indicate they are active.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Running State...");
-    // You could also update a Modbus register to show the "standby" state
-
-    setBitValue(equipment, "Status", 2, true);
-    setBitValue(equipment, "Tripped", 0, false);
-
-}
-
-/**
- * @brief Logic to execute once when exiting the running state.
- * Sets the "Run Status" for all EC fans to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Running State...");
-   
-}
\ No newline at end of file
diff --git a/src/EPMS/Breaker/BKR_Susol_ACB_TCP/State_Standby.cpp b/src/EPMS/Breaker/BKR_Susol_ACB_TCP/State_Standby.cpp
deleted file mode 100644
index b98eb98..0000000
--- a/src/EPMS/Breaker/BKR_Susol_ACB_TCP/State_Standby.cpp
+++ /dev/null
@@ -1,102 +0,0 @@
-/**
- * @file State_Standby.cpp
- * @brief Implementation of the StandbyState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the StandbyState, which defines
- * the behavior of the equipment when it is in an idle or standby mode.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-/**
- * @brief Constructs a new StandbyState object.
- *
- * In this state, the equipment is idle. This constructor initializes strategies
- * to bring the system to a safe, idle condition. It sets a stable value for
- * the SAT reading and creates ramp strategies to bring the CW valve and all
- * EC fan speeds down to zero.
- */
-template<>
-StandbyState<ModbusIP>::StandbyState() {
-  // You can add initialization code here if needed
-  
-
-}
-
-/**
- * @brief Executes the standby state's logic for one update cycle.
- *
- * This method applies the strategies defined for the standby state (e.g.,
- * ramping values to zero).
- *
- * @warning This method currently does not check for a command to transition to the
- *          Running state. This logic needs to be added to allow the unit to start.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* StandbyState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Standby update function");
-    float State_Ctrl = getPointValue(equipment, "State Control");
-    if (State_Ctrl == 1.0f){
-      return new RunningState<ModbusIP>();
-    }
-
-    if (State_Ctrl == 0.0f){
-      setBitValue(equipment, "Tripped", 0, false);
-    }
-    if (State_Ctrl == 2.0f){
-      setBitValue(equipment, "Tripped", 0, true);
-    }
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the standby state.
- * This method performs cleanup by setting all alarm points and all EC fan
- * run status points to 0.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Standby State...");
-    
-    setPointValue(equipment, "Amps A", 0.0f);
-    setPointValue(equipment, "Amps B", 0.0f);
-    setPointValue(equipment, "Amps C", 0.0f);
-    setPointValue(equipment, "Amps N", 0.0f);
-
-    setBitValue(equipment, "Status", 2, false);
-}
-
-/**
- * @brief Logic to execute once when exiting the standby state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Standby State...");
-}
\ No newline at end of file
diff --git a/src/EPMS/Breaker/BKR_Susol_ACB_TCP/config.h b/src/EPMS/Breaker/BKR_Susol_ACB_TCP/config.h
deleted file mode 100644
index 66287f0..0000000
--- a/src/EPMS/Breaker/BKR_Susol_ACB_TCP/config.h
+++ /dev/null
@@ -1,87 +0,0 @@
-/**
- * @file config.h
- * @brief Main configuration file for the CRAH Unit (TCP) emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * This file contains two important configurations: WiFi network parameters
- * and the Modbus register map for the device.
- */
-
-#ifndef CONFIG_H
-#define CONFIG_H
-
-#include "core.h"
-#include "Equipment/Equipment.h"
-
-#if defined(USE_MODBUS_IP)
-/**
-   * @defgroup ModbusTCPConfig Modbus IP Configuration
-   * @brief Parameters for Modbus TCP communication.
-   * @{
-   */
-  #include <ModbusIP_ESP8266.h>
-  const char *ssid = "QTS_CDR_Arduino";       /**< @brief The SSID of the WiFi network. */
-  const char *password = "123abc456";   /**< @brief The password for the WiFi network. */
-  IPAddress local_IP(172, 17, 33, 149);       /**< @brief The static IP address for the device. */
-  IPAddress gateway(172, 17, 33, 1);          /**< @brief The gateway IP address. */
-  IPAddress subnet(255, 255, 255, 0);         /**< @brief The subnet mask. */
-  
-  ModbusIP mb;
-#else
-  /**
-   * @defgroup ModbusRTUConfig Modbus RTU Configuration
-   * @brief Parameters for serial Modbus RTU communication.
-   * @{
-   */
-  #include <ModbusRTU.h>
-  const int BAUDRATE = 19200;   /**< @brief The serial communication speed in bits per second. */
-  const int RX_PIN = 17;        /**< @brief The GPIO pin used for receiving data (RX). */
-  const int TX_PIN = 16;        /**< @brief The GPIO pin used for transmitting data (TX). */
-  const int RST_PIN = 4;        /**< @brief The GPIO pin connected to the RS485 driver's DE/RE pins for direction control. */
-  const int MODBUS_ID = 1;      /**< @brief The unique slave ID for this device on the Modbus bus. */
-  /** @} */
-
-  /** @brief Global instance of the Modbus RTU server. */
-  ModbusRTU mb;
-#endif
-
-
-
-/**
- * @defgroup ModbusMapConfig Modbus Map Configuration
- * @brief Defines the Modbus register map and related parameters for the emulator.
- * @{
- */
-/**
- * @brief The Modbus map for the Equipment device.
- * This array defines all the Modbus points available on the emulated device.
- * The `description` field is crucial as it's used to look up points within the application logic.
- */
-modbusMap mb_map[] =
-{   
-  {HR,          9,     0,   "State Control"},
-  {HR,          10,    0,   "Load"},
-  {HR,          11,    0,   "Rating"},
-
-  {IR,     2,     0,  "Status"},  //bit 2 open-close, 
-  {IR,     3,     0,  "Amps A"},
-  {IR,     5,     0,  "Amps B"},
-  {IR,     7,     0,  "Amps C"},
-  {IR,     9,     0,  "Amps N"},
-  {IR,     13,     0,  "Tripped"}, //bit 0 tripped
-
-}; 
-//Size of modbus map used in FOR cycles, automatically calculated.
-
-/**
- * @brief The total number of entries in the `mb_map` array.
- * This is calculated at compile time and used for iterating over the map.
- */
-const int map_size = sizeof(mb_map) / sizeof(mb_map[0]);
-
-/** @brief The main loop update interval in milliseconds. */
-int interval = 250; 
-/** @} */ // End of ModbusMapConfig group
-
-#endif // CONFIG_H
diff --git a/src/EPMS/Breaker/BKR_Susol_ACB_TCP/main.cpp b/src/EPMS/Breaker/BKR_Susol_ACB_TCP/main.cpp
deleted file mode 100644
index 286a98c..0000000
--- a/src/EPMS/Breaker/BKR_Susol_ACB_TCP/main.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-/**
- * @file main.cpp
- * @brief Main execution program for the CRAH Unit (TCP) Emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * @details This file contains the main execution program for an Arduino-based emulator of a CRAH unit. 
- * The program uses a Wi-Fi connection to communicate via the Modbus IP protocol.
- *
- * The setup() function initializes the following:
- * - Serial communication for debugging.
- * - Wi-Fi connection using credentials from config.h.
- * - A Modbus TCP server.
- * - Modbus points (Coils, Holding Registers, etc.) based on a predefined map in config.h.
- *
- * The loop() function continuously:
- * - Services the Modbus TCP server to handle incoming requests.
- * - Periodically calls the main update loop for the emulated equipment, which
- *   manages state transitions and behavior strategies.
- *
- * @see config.h for Wi-Fi and Modbus configuration.
- * @see Equipment.h for the main equipment logic.
- * @see State.h for different equipment states.
- * @see Strategies/Strategy_Behavior.h for value generation strategies.
- * @see Modbus_Point.h for the base class for all Modbus points.
- */
-//=================================================================================================================================
-//Libraries and declaration of variables.
-#include <WiFi.h>
-#include "config.h"
-#include "ModbusPoints/Modbus_PointFactory.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-//=================================================================================================================================
-/** 
- * @brief Initializes the application.
- * @details This function runs once at startup. It configures the serial communication, 
- * Wi-Fi, and the Modbus server. It also creates and initializes all the Modbus points 
- * based on the `mb_map` array in `config.h`.
- */
-void setup() {
-  Serial.begin(115200);                       //Serial comm start
-  WiFi.config(local_IP, gateway, subnet);     // Wifi service start
-  WiFi.begin(ssid, password);
-  while (WiFi.status() != WL_CONNECTED) {
-    delay(1000);
-    Serial.print(".");
-  }
-  Serial.println("Connected!!");
-  mb.server();                                //Modbus server start
-  Serial.println("Server Created");
-  Serial.println(map_size);
-  for(int i = 0; i < map_size; i++){
-    Modbus_Point<ModbusIP>* point = createModbus_Point(&mb, mb_map[i].category, mb_map[i].address, mb_map[i].value, mb_map[i].description);
-    if (point) {
-      point->addToModbusServer();
-      EquipmentInstance.addModbus_Point(mb_map[i].description, point);
-    }
-  }
-  Serial.println("All modbus Points created");
-  Serial.println("Setup function ended");
-}
-//=================================================================================================================================
-/** 
- * @brief The main application loop.
- * @details This function runs repeatedly after setup() has completed. It performs two main actions:
- * 1. It continuously services the Modbus server by calling `mb.task()` to handle
- *    incoming requests from a Modbus master.
- * 2. At a fixed interval (defined in `config.h`), it calls `EquipmentInstance.update()`
- *    to run the emulator's internal state machine and behavior logic.
- */
-void loop() {
-  mb.task();
-  unsigned long currentMillis = millis();
-  if (currentMillis - previousMillis >= interval) {
-    previousMillis = currentMillis;
-    unsigned long startTime = millis();
-    EquipmentInstance.update();
-    unsigned long endTime = millis();
-    unsigned long elapsedTime = endTime - startTime;
-    Serial.printf("Control Execution time: %d ms\n", elapsedTime);
-  } 
-}
diff --git a/src/EPMS/Breaker/Susol_Smart_MCCB_TCP/README.md b/src/EPMS/Breaker/Susol_Smart_MCCB_TCP/README.md
deleted file mode 100644
index 355156f..0000000
--- a/src/EPMS/Breaker/Susol_Smart_MCCB_TCP/README.md
+++ /dev/null
@@ -1,33 +0,0 @@
-# EQUIPMENT_TYPE MANUFACTURER MODEL TCP
-
-## Brief Introduction
-Equipment specifc details that make it different from other devices
-
-## List of Equipmentt
-This cofiguration has been used for these models:
-* **Model**: 09-15-22 
-* **Model**: 09-15-23 
-* **Model**: 09-15-25 
-
-## Hardware Prerequisites
-
-The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities.
-* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html) 
-
----
-
-## States and Strategies
-Provide a brief description of what variables and strategies were used in this configuraiton
-
-### Standby State
-* **Equipment running**: set to 0
-* **Common Alarm**: set to 0
-* **SAT temperature**: set to 85
-
-### Running State
-* **Equipment running**: set to 1
-* **SAT temperature**: **Ramp Strategy** set to 65 deg setpoint
-
-### Fail State
-* **Commong Alarm**: set to 1
-* **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset
diff --git a/src/EPMS/Breaker/Susol_Smart_MCCB_TCP/State_Fail.cpp b/src/EPMS/Breaker/Susol_Smart_MCCB_TCP/State_Fail.cpp
deleted file mode 100644
index 8bc0385..0000000
--- a/src/EPMS/Breaker/Susol_Smart_MCCB_TCP/State_Fail.cpp
+++ /dev/null
@@ -1,81 +0,0 @@
-/**
- * @file State_Fail.cpp
- * @brief Implementation of the FailState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the FailState, which defines
- * the behavior of the equipment when it has entered a fault condition.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new FailState object with a list of active alarms.
- *
- * This constructor receives a list of alarm descriptions and creates strategies
- * to set the corresponding Modbus points to a value of 1, indicating an
- * active alarm. It also initializes a PID strategy for the 'CW Valve Position'
- * to maintain its state during the fault.
- * @param activeAlarms A vector of strings, where each string is the
- *                     description of a Modbus point to be set as an active alarm.
- */
-template<>
-FailState<ModbusIP>::FailState(const std::vector<std::string>& activeAlarms) {
-    // Simulate a failure: set common alarm and a specific fan alarm.
-
-    
-}
-
-/**
- * @brief Executes the fail state's logic for one update cycle.
- *
- * This method checks the "Alarm Reset" Modbus point for a command to
- * transition back to Standby, which would typically happen after a fault
- * is cleared by a user. If no transition is requested, it continues to apply
- * the failure strategies (e.g., keeping alarm bits active).
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* FailState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Fail update function");
-    
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the fail state.
- * Sets the "Alarm Common" point to 1 to indicate a general fault condition.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Fail State...");
-}
-
-/**
- * @brief Logic to execute once when exiting the fail state.
- * Clears the "Alarm Common" point to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Fail State...");
-}
\ No newline at end of file
diff --git a/src/EPMS/Breaker/Susol_Smart_MCCB_TCP/State_Running.cpp b/src/EPMS/Breaker/Susol_Smart_MCCB_TCP/State_Running.cpp
deleted file mode 100644
index c334bdd..0000000
--- a/src/EPMS/Breaker/Susol_Smart_MCCB_TCP/State_Running.cpp
+++ /dev/null
@@ -1,138 +0,0 @@
-/**
- * @file State_Running.cpp
- * @brief Implementation of the RunningState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the RunningState, which defines
- * the behavior of the equipment when it is actively running.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "Strategies/Strategy_Totalizer.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new RunningState object.
- *
- * This constructor initializes behavior strategies active during the runnings
- * state, such as a PID controller for the 'CW Valve Position' and totalizers
- * for the run-hours of each EC fan.
- */
-template<>
-RunningState<ModbusIP>::RunningState() {
-  addStrategy("Volts AB", new SingleValueStrategy(480.0F, 5.0f, 1000));
-  addStrategy("Volts BC", new SingleValueStrategy(480.0F, 5.0f, 1000));
-  addStrategy("Volts CA", new SingleValueStrategy(480.0F, 5.0f, 1000));
-
-  addStrategy("PF", new SingleValueStrategy(0.9f, 0.05f, 1000));
-
-  addStrategy("Amps A", new SingleValueStrategy(1.0f, 10.0f, 1000));
-  addStrategy("Amps B", new SingleValueStrategy(1.0f, 10.0f, 1000));
-  addStrategy("Amps C", new SingleValueStrategy(1.0f, 10.0f, 1000));
-
-}
-
-/**
- * @brief Executes the running state's logic for one update cycle.
- *
- * This method first checks for state transition commands:
- * 1. It reads the "ON/OFF Command By BMS" point. If it's 0, it transitions to StandbyState.
- * 2. It reads the "Fault Code" point. If it's non-zero, it transitions to FailState,
- *    passing the corresponding alarm description.
- *
- * If no transition occurs, it applies the strategies defined for the running state.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* RunningState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Running update function");
-    float State_Ctrl = getPointValue(equipment, "State Control");
-    if (State_Ctrl == 0.0f){
-      return new StandbyState<ModbusIP>();
-    }
-    if (State_Ctrl == 2.0f){
-      return new StandbyState<ModbusIP>();
-    }
-    // Apply any strategies defined for the standby state
-    float volts_AB = getPointValue(equipment, "Volts AB");
-    float volts_BC = getPointValue(equipment, "Volts BC");
-    float volts_AC = getPointValue(equipment, "Volts CA");
-
-    setPointValue(equipment, "Volts AN", volts_AB/1.732);
-    setPointValue(equipment, "Volts BN", volts_BC/1.732);
-    setPointValue(equipment, "Volts CN", volts_AC/1.732);
-
-
-    int I_load = getPointValue(equipment, "Load");
-    int I_rating = getPointValue(equipment, "Rating");
-    float load = static_cast<float>(I_load);
-    float rating = static_cast<float>(I_rating);
-    float real_load = rating * (load/100.0f);
-    Strategy_Behavior* ampsA_svs = getStrategy("Amps A");
-    Strategy_Behavior* ampsB_svs = getStrategy("Amps B");
-    Strategy_Behavior* ampsC_svs = getStrategy("Amps C");
-
-    static_cast<SingleValueStrategy*>(ampsA_svs)->setSetpoint(real_load);
-    static_cast<SingleValueStrategy*>(ampsB_svs)->setSetpoint(real_load);
-    static_cast<SingleValueStrategy*>(ampsC_svs)->setSetpoint(real_load);
-
-    float pf = getPointValue(equipment, "PF");
-
-
-    float kw = (1.732f * ((volts_AB + volts_BC + volts_AC)/3.0f) * real_load * pf)/1000;
-    float kva = (1.732f * ((volts_AB + volts_BC + volts_AC)/3.0f) * real_load)/1000;
-
-    setPointValue(equipment, "kW", kw);
-    setPointValue(equipment, "kVA", kva);
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the running state.
- * Sets the "Run Status" for all EC fans to 1 to indicate they are active.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Running State...");
-    // You could also update a Modbus register to show the "standby" state
-  
-    setBitValue(equipment, "CB Position", 12, true);
-    setBitValue(equipment, "CB Position", 9, false);
-
-}
-
-/**
- * @brief Logic to execute once when exiting the running state.
- * Sets the "Run Status" for all EC fans to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Running State...");
-   
-}
\ No newline at end of file
diff --git a/src/EPMS/Breaker/Susol_Smart_MCCB_TCP/State_Standby.cpp b/src/EPMS/Breaker/Susol_Smart_MCCB_TCP/State_Standby.cpp
deleted file mode 100644
index d839d21..0000000
--- a/src/EPMS/Breaker/Susol_Smart_MCCB_TCP/State_Standby.cpp
+++ /dev/null
@@ -1,108 +0,0 @@
-/**
- * @file State_Standby.cpp
- * @brief Implementation of the StandbyState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the StandbyState, which defines
- * the behavior of the equipment when it is in an idle or standby mode.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-/**
- * @brief Constructs a new StandbyState object.
- *
- * In this state, the equipment is idle. This constructor initializes strategies
- * to bring the system to a safe, idle condition. It sets a stable value for
- * the SAT reading and creates ramp strategies to bring the CW valve and all
- * EC fan speeds down to zero.
- */
-template<>
-StandbyState<ModbusIP>::StandbyState() {
-  // You can add initialization code here if needed
-  
-
-}
-
-/**
- * @brief Executes the standby state's logic for one update cycle.
- *
- * This method applies the strategies defined for the standby state (e.g.,
- * ramping values to zero).
- *
- * @warning This method currently does not check for a command to transition to the
- *          Running state. This logic needs to be added to allow the unit to start.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* StandbyState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Standby update function");
-    float State_Ctrl = getPointValue(equipment, "State Control");
-    if (State_Ctrl == 1.0f){
-      return new RunningState<ModbusIP>();
-    }
-
-    if (State_Ctrl == 0.0f){
-      setBitValue(equipment, "CB Position", 9, false);
-    }
-
-    if (State_Ctrl == 2.0f){
-      setBitValue(equipment, "CB Position", 9, true);
-    }
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the standby state.
- * This method performs cleanup by setting all alarm points and all EC fan
- * run status points to 0.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Standby State...");
-    setPointValue(equipment, "CB Position", 0);
-    setPointValue(equipment, "Volts AB", 0.0f);
-    setPointValue(equipment, "Volts BC", 0.0f);
-    setPointValue(equipment, "Volts CA", 0.0f);
-    setPointValue(equipment, "Volts AN", 0.0f);
-    setPointValue(equipment, "Volts BN", 0.0f);
-    setPointValue(equipment, "Volts CN", 0.0f);
-    setPointValue(equipment, "PF", 0.0f);
-    setPointValue(equipment, "Amps A", 0.0f);
-    setPointValue(equipment, "Amps B", 0.0f);
-    setPointValue(equipment, "Amps C", 0.0f);
-    setBitValue(equipment, "CB Position", 12, false);
-}
-
-/**
- * @brief Logic to execute once when exiting the standby state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Standby State...");
-}
\ No newline at end of file
diff --git a/src/EPMS/Breaker/Susol_Smart_MCCB_TCP/config.h b/src/EPMS/Breaker/Susol_Smart_MCCB_TCP/config.h
deleted file mode 100644
index cee6758..0000000
--- a/src/EPMS/Breaker/Susol_Smart_MCCB_TCP/config.h
+++ /dev/null
@@ -1,97 +0,0 @@
-/**
- * @file config.h
- * @brief Main configuration file for the CRAH Unit (TCP) emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * This file contains two important configurations: WiFi network parameters
- * and the Modbus register map for the device.
- */
-
-#ifndef CONFIG_H
-#define CONFIG_H
-
-#include "core.h"
-#include "Equipment/Equipment.h"
-
-#if defined(USE_MODBUS_IP)
-/**
-   * @defgroup ModbusTCPConfig Modbus IP Configuration
-   * @brief Parameters for Modbus TCP communication.
-   * @{
-   */
-  #include <ModbusIP_ESP8266.h>
-  const char *ssid = "QTS_CDR_Arduino";       /**< @brief The SSID of the WiFi network. */
-  const char *password = "123abc456";   /**< @brief The password for the WiFi network. */
-  IPAddress local_IP(172, 17, 33, 141);       /**< @brief The static IP address for the device. */
-  IPAddress gateway(172, 17, 33, 1);          /**< @brief The gateway IP address. */
-  IPAddress subnet(255, 255, 255, 0);         /**< @brief The subnet mask. */
-  
-  ModbusIP mb;
-#else
-  /**
-   * @defgroup ModbusRTUConfig Modbus RTU Configuration
-   * @brief Parameters for serial Modbus RTU communication.
-   * @{
-   */
-  #include <ModbusRTU.h>
-  const int BAUDRATE = 19200;   /**< @brief The serial communication speed in bits per second. */
-  const int RX_PIN = 17;        /**< @brief The GPIO pin used for receiving data (RX). */
-  const int TX_PIN = 16;        /**< @brief The GPIO pin used for transmitting data (TX). */
-  const int RST_PIN = 4;        /**< @brief The GPIO pin connected to the RS485 driver's DE/RE pins for direction control. */
-  const int MODBUS_ID = 1;      /**< @brief The unique slave ID for this device on the Modbus bus. */
-  /** @} */
-
-  /** @brief Global instance of the Modbus RTU server. */
-  ModbusRTU mb;
-#endif
-
-
-
-/**
- * @defgroup ModbusMapConfig Modbus Map Configuration
- * @brief Defines the Modbus register map and related parameters for the emulator.
- * @{
- */
-/**
- * @brief The Modbus map for the Equipment device.
- * This array defines all the Modbus points available on the emulated device.
- * The `description` field is crucial as it's used to look up points within the application logic.
- */
-modbusMap mb_map[] =
-{   
-  {HR,            9,    0,    "State Control"},
-  {HR,            10,    0,   "Load"},
-  {HR,            11,    0,   "Rating"},
-  
-  {IR,            207,    0,  "CB Position"},  //bit 9 trip   bit 12 open closed 
-  {IR_FLOAT,      215,    0,  "Amps A"},
-  {IR_FLOAT,      217,    0,  "Amps B"},
-  {IR_FLOAT,      219,    0,  "Amps C"},
-  {IR_FLOAT,      221,    0,  "Amps N"},
-  {IR_FLOAT,      223,    0,  "Amps G"},
-  {IR_FLOAT,      231,    0,  "Volts AN"},
-  {IR_FLOAT,      233,    0,  "Volts BN"},
-  {IR_FLOAT,      235,    0,  "Volts CN"},
-  {IR_FLOAT,      237,    0,  "Volts AB"},
-  {IR_FLOAT,      239,    0,  "Volts BC"},
-  {IR_FLOAT,      241,    0,  "Volts CA"},
-  {IR_FLOAT,      249,    0,  "PF"},
-  {IR_FLOAT,      251,    0,  "kW"},
-  {IR_FLOAT,      255,    0,  "kVA"},
-  {IR_FLOAT,      265,    0,  "kWh reg1"},
-  {IR_FLOAT,      267,    0,  "kWh reg2"},
-}; 
-//Size of modbus map used in FOR cycles, automatically calculated.
-
-/**
- * @brief The total number of entries in the `mb_map` array.
- * This is calculated at compile time and used for iterating over the map.
- */
-const int map_size = sizeof(mb_map) / sizeof(mb_map[0]);
-
-/** @brief The main loop update interval in milliseconds. */
-int interval = 250; 
-/** @} */ // End of ModbusMapConfig group
-
-#endif // CONFIG_H
diff --git a/src/EPMS/Breaker/Susol_Smart_MCCB_TCP/main.cpp b/src/EPMS/Breaker/Susol_Smart_MCCB_TCP/main.cpp
deleted file mode 100644
index 286a98c..0000000
--- a/src/EPMS/Breaker/Susol_Smart_MCCB_TCP/main.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-/**
- * @file main.cpp
- * @brief Main execution program for the CRAH Unit (TCP) Emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * @details This file contains the main execution program for an Arduino-based emulator of a CRAH unit. 
- * The program uses a Wi-Fi connection to communicate via the Modbus IP protocol.
- *
- * The setup() function initializes the following:
- * - Serial communication for debugging.
- * - Wi-Fi connection using credentials from config.h.
- * - A Modbus TCP server.
- * - Modbus points (Coils, Holding Registers, etc.) based on a predefined map in config.h.
- *
- * The loop() function continuously:
- * - Services the Modbus TCP server to handle incoming requests.
- * - Periodically calls the main update loop for the emulated equipment, which
- *   manages state transitions and behavior strategies.
- *
- * @see config.h for Wi-Fi and Modbus configuration.
- * @see Equipment.h for the main equipment logic.
- * @see State.h for different equipment states.
- * @see Strategies/Strategy_Behavior.h for value generation strategies.
- * @see Modbus_Point.h for the base class for all Modbus points.
- */
-//=================================================================================================================================
-//Libraries and declaration of variables.
-#include <WiFi.h>
-#include "config.h"
-#include "ModbusPoints/Modbus_PointFactory.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-//=================================================================================================================================
-/** 
- * @brief Initializes the application.
- * @details This function runs once at startup. It configures the serial communication, 
- * Wi-Fi, and the Modbus server. It also creates and initializes all the Modbus points 
- * based on the `mb_map` array in `config.h`.
- */
-void setup() {
-  Serial.begin(115200);                       //Serial comm start
-  WiFi.config(local_IP, gateway, subnet);     // Wifi service start
-  WiFi.begin(ssid, password);
-  while (WiFi.status() != WL_CONNECTED) {
-    delay(1000);
-    Serial.print(".");
-  }
-  Serial.println("Connected!!");
-  mb.server();                                //Modbus server start
-  Serial.println("Server Created");
-  Serial.println(map_size);
-  for(int i = 0; i < map_size; i++){
-    Modbus_Point<ModbusIP>* point = createModbus_Point(&mb, mb_map[i].category, mb_map[i].address, mb_map[i].value, mb_map[i].description);
-    if (point) {
-      point->addToModbusServer();
-      EquipmentInstance.addModbus_Point(mb_map[i].description, point);
-    }
-  }
-  Serial.println("All modbus Points created");
-  Serial.println("Setup function ended");
-}
-//=================================================================================================================================
-/** 
- * @brief The main application loop.
- * @details This function runs repeatedly after setup() has completed. It performs two main actions:
- * 1. It continuously services the Modbus server by calling `mb.task()` to handle
- *    incoming requests from a Modbus master.
- * 2. At a fixed interval (defined in `config.h`), it calls `EquipmentInstance.update()`
- *    to run the emulator's internal state machine and behavior logic.
- */
-void loop() {
-  mb.task();
-  unsigned long currentMillis = millis();
-  if (currentMillis - previousMillis >= interval) {
-    previousMillis = currentMillis;
-    unsigned long startTime = millis();
-    EquipmentInstance.update();
-    unsigned long endTime = millis();
-    unsigned long elapsedTime = endTime - startTime;
-    Serial.printf("Control Execution time: %d ms\n", elapsedTime);
-  } 
-}
diff --git a/src/EPMS/GEN/GEN_CAT_EMCP4_TCP/README.md b/src/EPMS/GEN/GEN_CAT_EMCP4_TCP/README.md
deleted file mode 100644
index 355156f..0000000
--- a/src/EPMS/GEN/GEN_CAT_EMCP4_TCP/README.md
+++ /dev/null
@@ -1,33 +0,0 @@
-# EQUIPMENT_TYPE MANUFACTURER MODEL TCP
-
-## Brief Introduction
-Equipment specifc details that make it different from other devices
-
-## List of Equipmentt
-This cofiguration has been used for these models:
-* **Model**: 09-15-22 
-* **Model**: 09-15-23 
-* **Model**: 09-15-25 
-
-## Hardware Prerequisites
-
-The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities.
-* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html) 
-
----
-
-## States and Strategies
-Provide a brief description of what variables and strategies were used in this configuraiton
-
-### Standby State
-* **Equipment running**: set to 0
-* **Common Alarm**: set to 0
-* **SAT temperature**: set to 85
-
-### Running State
-* **Equipment running**: set to 1
-* **SAT temperature**: **Ramp Strategy** set to 65 deg setpoint
-
-### Fail State
-* **Commong Alarm**: set to 1
-* **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset
diff --git a/src/EPMS/GEN/GEN_CAT_EMCP4_TCP/State_Fail.cpp b/src/EPMS/GEN/GEN_CAT_EMCP4_TCP/State_Fail.cpp
deleted file mode 100644
index 8bc0385..0000000
--- a/src/EPMS/GEN/GEN_CAT_EMCP4_TCP/State_Fail.cpp
+++ /dev/null
@@ -1,81 +0,0 @@
-/**
- * @file State_Fail.cpp
- * @brief Implementation of the FailState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the FailState, which defines
- * the behavior of the equipment when it has entered a fault condition.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new FailState object with a list of active alarms.
- *
- * This constructor receives a list of alarm descriptions and creates strategies
- * to set the corresponding Modbus points to a value of 1, indicating an
- * active alarm. It also initializes a PID strategy for the 'CW Valve Position'
- * to maintain its state during the fault.
- * @param activeAlarms A vector of strings, where each string is the
- *                     description of a Modbus point to be set as an active alarm.
- */
-template<>
-FailState<ModbusIP>::FailState(const std::vector<std::string>& activeAlarms) {
-    // Simulate a failure: set common alarm and a specific fan alarm.
-
-    
-}
-
-/**
- * @brief Executes the fail state's logic for one update cycle.
- *
- * This method checks the "Alarm Reset" Modbus point for a command to
- * transition back to Standby, which would typically happen after a fault
- * is cleared by a user. If no transition is requested, it continues to apply
- * the failure strategies (e.g., keeping alarm bits active).
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* FailState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Fail update function");
-    
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the fail state.
- * Sets the "Alarm Common" point to 1 to indicate a general fault condition.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Fail State...");
-}
-
-/**
- * @brief Logic to execute once when exiting the fail state.
- * Clears the "Alarm Common" point to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Fail State...");
-}
\ No newline at end of file
diff --git a/src/EPMS/GEN/GEN_CAT_EMCP4_TCP/State_Running.cpp b/src/EPMS/GEN/GEN_CAT_EMCP4_TCP/State_Running.cpp
deleted file mode 100644
index b9e4a99..0000000
--- a/src/EPMS/GEN/GEN_CAT_EMCP4_TCP/State_Running.cpp
+++ /dev/null
@@ -1,89 +0,0 @@
-/**
- * @file State_Running.cpp
- * @brief Implementation of the RunningState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the RunningState, which defines
- * the behavior of the equipment when it is actively running.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "Strategies/Strategy_Totalizer.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new RunningState object.
- *
- * This constructor initializes behavior strategies active during the running
- * state, such as a PID controller for the 'CW Valve Position' and totalizers
- * for the run-hours of each EC fan.
- */
-template<>
-RunningState<ModbusIP>::RunningState() {
-}
-
-/**
- * @brief Executes the running state's logic for one update cycle.
- *
- * This method first checks for state transition commands:
- * 1. It reads the "ON/OFF Command By BMS" point. If it's 0, it transitions to StandbyState.
- * 2. It reads the "Fault Code" point. If it's non-zero, it transitions to FailState,
- *    passing the corresponding alarm description.
- *
- * If no transition occurs, it applies the strategies defined for the running state.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* RunningState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Running update function");
-    
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the running state.
- * Sets the "Run Status" for all EC fans to 1 to indicate they are active.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Running State...");
-    // You could also update a Modbus register to show the "standby" state
-
-}
-
-/**
- * @brief Logic to execute once when exiting the running state.
- * Sets the "Run Status" for all EC fans to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Running State...");
-   
-}
\ No newline at end of file
diff --git a/src/EPMS/GEN/GEN_CAT_EMCP4_TCP/State_Standby.cpp b/src/EPMS/GEN/GEN_CAT_EMCP4_TCP/State_Standby.cpp
deleted file mode 100644
index 20029d1..0000000
--- a/src/EPMS/GEN/GEN_CAT_EMCP4_TCP/State_Standby.cpp
+++ /dev/null
@@ -1,85 +0,0 @@
-/**
- * @file State_Standby.cpp
- * @brief Implementation of the StandbyState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the StandbyState, which defines
- * the behavior of the equipment when it is in an idle or standby mode.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-/**
- * @brief Constructs a new StandbyState object.
- *
- * In this state, the equipment is idle. This constructor initializes strategies
- * to bring the system to a safe, idle condition. It sets a stable value for
- * the SAT reading and creates ramp strategies to bring the CW valve and all
- * EC fan speeds down to zero.
- */
-template<>
-StandbyState<ModbusIP>::StandbyState() {
-    // You can add initialization code here if needed
-    
-
-}
-
-/**
- * @brief Executes the standby state's logic for one update cycle.
- *
- * This method applies the strategies defined for the standby state (e.g.,
- * ramping values to zero).
- *
- * @warning This method currently does not check for a command to transition to the
- *          Running state. This logic needs to be added to allow the unit to start.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* StandbyState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Standby update function");
-    
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the standby state.
- * This method performs cleanup by setting all alarm points and all EC fan
- * run status points to 0.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Standby State...");
-}
-
-/**
- * @brief Logic to execute once when exiting the standby state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Standby State...");
-}
\ No newline at end of file
diff --git a/src/EPMS/GEN/GEN_CAT_EMCP4_TCP/config.h b/src/EPMS/GEN/GEN_CAT_EMCP4_TCP/config.h
deleted file mode 100644
index 76b42f4..0000000
--- a/src/EPMS/GEN/GEN_CAT_EMCP4_TCP/config.h
+++ /dev/null
@@ -1,125 +0,0 @@
-/**
- * @file config.h
- * @brief Main configuration file for the GEN CAT EMCP4
- * @author Zach Gutierrez
- * @date 2025-09-02
- *
- * This file contains two important configurations: WiFi network parameters
- * and the Modbus register map for the device.
- */
-
-#ifndef CONFIG_H
-#define CONFIG_H
-
-#include "core.h"
-#include "Equipment/Equipment.h"
-
-#if defined(USE_MODBUS_IP)
-/**
-   * @defgroup ModbusTCPConfig Modbus IP Configuration
-   * @brief Parameters for Modbus TCP communication.
-   * @{
-   */
-  #include <ModbusIP_ESP8266.h>
-  const char *ssid = "wifi_name";       /**< @brief The SSID of the WiFi network. */
-  const char *password = "wifi_password";   /**< @brief The password for the WiFi network. */
-  IPAddress local_IP(192, 168, 1, 234);       /**< @brief The static IP address for the device. */
-  IPAddress gateway(192, 168, 1, 1);          /**< @brief The gateway IP address. */
-  IPAddress subnet(255, 255, 255, 0);         /**< @brief The subnet mask. */
-  
-  ModbusIP mb;
-#else
-  /**
-   * @defgroup ModbusRTUConfig Modbus RTU Configuration
-   * @brief Parameters for serial Modbus RTU communication.
-   * @{
-   */
-  #include <ModbusRTU.h>
-  const int BAUDRATE = 19200;   /**< @brief The serial communication speed in bits per second. */
-  const int RX_PIN = 17;        /**< @brief The GPIO pin used for receiving data (RX). */
-  const int TX_PIN = 16;        /**< @brief The GPIO pin used for transmitting data (TX). */
-  const int RST_PIN = 4;        /**< @brief The GPIO pin connected to the RS485 driver's DE/RE pins for direction control. */
-  const int MODBUS_ID = 1;      /**< @brief The unique slave ID for this device on the Modbus bus. */
-  /** @} */
-
-  /** @brief Global instance of the Modbus RTU server. */
-  ModbusRTU mb;
-#endif
-
-
-
-/**
- * @defgroup ModbusMapConfig Modbus Map Configuration
- * @brief Defines the Modbus register map and related parameters for the emulator.
- * @{
- */
-/**
- * @brief The Modbus map for the Equipment device.
- * This array defines all the Modbus points available on the emulated device.
- * The `description` field is crucial as it's used to look up points within the application logic.
- */
-modbusMap mb_map[] = {
-  // ESP8266 Modbus server uses 0-based addressing, while Modbus Poll uses 1-based addressing.
-  
-  {HR, 48899, 0, "Alm01" },              // 448900
-  {HR, 48898, 0, "Alm02" },              // 448899
-  {HR, 48905, 0, "Alm03" },              // 448906
-  {HR, 48896, 0, "Alm04" },              // 448897
-  {HR, 48900, 0, "Alm05" },              // 448901
-  {HR, 48903, 0, "Alm06" },              // 448904
-  {HR, 48901, 0, "Alm07" },              // 448902
-  {HR, 48902, 0, "Alm08" },              // 448903
-  {HR, 48907, 0, "Fuel_LoLo" },     // 448908
-  {HR, 48912, 0, "Alm10" },              // 448913
-  {HR, 48897, 0, "Alm11" },              // 448898
-  {HR, 48914, 0, "Fuel_Hi" },       // 448915
-  {HR, 48906, 0, "Fuel_Lo" },       // 448907
-  {HR, 48911, 0, "Alm14" },              // 448912
-  {HR, 48904, 0, "Common_Alarm" },  // 448905
-  {HR, 8654, 0,  "Bkr_State" },      //48655
-  {HR, 1024, 0, "Oil Pressure" },                 // 41025 Engine_Oil_Pressure
-  {HR, 1025, 0, "Coolant Temp" },                 // 41026 Coolant_Temperature_degC
-  {HR, 1026, 0, "Oil_Temp_degC" },    // 41027 Oil_Temperature_degC
-  {HR, 1029, 0, "Battery_Voltage" },  // 41030 Battery_Voltage
-  {HR, 1030, 0, "Engine_Speed" },     // 41031 Engine_Speed
-  {HR, 1031, 0, "Freq" },             // 41032 Freq
-  {HR, 1032, 0, "Volts_AN" },         // 41033 Volts_AN
-  {HR, 1034, 0, "Volts_BN" },         // 41035 Volts_BN
-  {HR, 1036, 0, "Volts_CN" },         // 41037 Volts_CN
-  {HR, 1038, 0, "Volts_AB" },         // 41039 Volts_AB
-  {HR, 1040, 0, "Volts_BC" },         // 41041 Volts_BC
-  {HR, 1042, 0, "Volts_CA" },         // 41043 Volts_CA
-  {HR, 1044, 0, "Amps_A" },           // 41045 Amps_A
-  {HR, 1046, 0, "Amps_B" },           // 41047 Amps_B
-  {HR, 1048, 0, "Amps_C" },           // 41049 Amps_C
-  {HR, 1052, 0, "kW_A" },             // 41053 kW_A
-  {HR, 1054, 0, "kW_B" },             // 41055 kW_B
-  {HR, 1056, 0, "kW_C" },             // 41057 kW_C
-  {HR, 1288, 0, "L_Exhaust_degC" },   // 41289 Left_Exhaust_Temp_degC
-  {HR, 1289, 0, "R_Exhaust_degC" },   // 41290 Right_Exhaust_Temp_degC
-  {HR, 1354, 0, "Percent_Load" },     // 41355 Percent_Load
-  {HR, 1536, 0, "kW_Tot" },           // 41537 kW
-  {HR, 1538, 0, "kVA_A" },            // 41539 kVA_A
-  {HR, 1540, 0, "kVA_B" },            // 41541 kVA_B
-  {HR, 1542, 0, "kVA_C" },            // 41543 kVA_C
-  {HR, 1544, 0, "kVA_Tot" },          // 41545 kVA
-  {HR, 1552, 0, "kVAR_Tot" },         // 41553 kVAR
-  {HR, 1557, 0, "PF_Tot" },           // 41558 PF
-  {HR, 1798, 0, "TTL_Run_Hours" },    // 41799 TTL_Run_Hours
-  {HR, 1800, 0, "kWh_Tot" },          // 41801 kWh
-  {HR, 1808, 0, "TTL_Starts" },       // 41809 TTL_Engine_Starts
-  {HR, 48908, 0, "Auto_Mode" }        // 448909 Auto_Mode
-};
-//Size of modbus map used in FOR cycles, automatically calculated.
-
-/**
- * @brief The total number of entries in the `mb_map` array.
- * This is calculated at compile time and used for iterating over the map.
- */
-const int map_size = sizeof(mb_map) / sizeof(mb_map[0]);
-
-/** @brief The main loop update interval in milliseconds. */
-int interval = 250; 
-/** @} */ // End of ModbusMapConfig group
-
-#endif // CONFIG_H
diff --git a/src/EPMS/GEN/GEN_CAT_EMCP4_TCP/main.cpp b/src/EPMS/GEN/GEN_CAT_EMCP4_TCP/main.cpp
deleted file mode 100644
index 286a98c..0000000
--- a/src/EPMS/GEN/GEN_CAT_EMCP4_TCP/main.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-/**
- * @file main.cpp
- * @brief Main execution program for the CRAH Unit (TCP) Emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * @details This file contains the main execution program for an Arduino-based emulator of a CRAH unit. 
- * The program uses a Wi-Fi connection to communicate via the Modbus IP protocol.
- *
- * The setup() function initializes the following:
- * - Serial communication for debugging.
- * - Wi-Fi connection using credentials from config.h.
- * - A Modbus TCP server.
- * - Modbus points (Coils, Holding Registers, etc.) based on a predefined map in config.h.
- *
- * The loop() function continuously:
- * - Services the Modbus TCP server to handle incoming requests.
- * - Periodically calls the main update loop for the emulated equipment, which
- *   manages state transitions and behavior strategies.
- *
- * @see config.h for Wi-Fi and Modbus configuration.
- * @see Equipment.h for the main equipment logic.
- * @see State.h for different equipment states.
- * @see Strategies/Strategy_Behavior.h for value generation strategies.
- * @see Modbus_Point.h for the base class for all Modbus points.
- */
-//=================================================================================================================================
-//Libraries and declaration of variables.
-#include <WiFi.h>
-#include "config.h"
-#include "ModbusPoints/Modbus_PointFactory.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-//=================================================================================================================================
-/** 
- * @brief Initializes the application.
- * @details This function runs once at startup. It configures the serial communication, 
- * Wi-Fi, and the Modbus server. It also creates and initializes all the Modbus points 
- * based on the `mb_map` array in `config.h`.
- */
-void setup() {
-  Serial.begin(115200);                       //Serial comm start
-  WiFi.config(local_IP, gateway, subnet);     // Wifi service start
-  WiFi.begin(ssid, password);
-  while (WiFi.status() != WL_CONNECTED) {
-    delay(1000);
-    Serial.print(".");
-  }
-  Serial.println("Connected!!");
-  mb.server();                                //Modbus server start
-  Serial.println("Server Created");
-  Serial.println(map_size);
-  for(int i = 0; i < map_size; i++){
-    Modbus_Point<ModbusIP>* point = createModbus_Point(&mb, mb_map[i].category, mb_map[i].address, mb_map[i].value, mb_map[i].description);
-    if (point) {
-      point->addToModbusServer();
-      EquipmentInstance.addModbus_Point(mb_map[i].description, point);
-    }
-  }
-  Serial.println("All modbus Points created");
-  Serial.println("Setup function ended");
-}
-//=================================================================================================================================
-/** 
- * @brief The main application loop.
- * @details This function runs repeatedly after setup() has completed. It performs two main actions:
- * 1. It continuously services the Modbus server by calling `mb.task()` to handle
- *    incoming requests from a Modbus master.
- * 2. At a fixed interval (defined in `config.h`), it calls `EquipmentInstance.update()`
- *    to run the emulator's internal state machine and behavior logic.
- */
-void loop() {
-  mb.task();
-  unsigned long currentMillis = millis();
-  if (currentMillis - previousMillis >= interval) {
-    previousMillis = currentMillis;
-    unsigned long startTime = millis();
-    EquipmentInstance.update();
-    unsigned long endTime = millis();
-    unsigned long elapsedTime = endTime - startTime;
-    Serial.printf("Control Execution time: %d ms\n", elapsedTime);
-  } 
-}
diff --git a/src/EPMS/GEN/GEN_CAT_GCCP_TCP/README.md b/src/EPMS/GEN/GEN_CAT_GCCP_TCP/README.md
deleted file mode 100644
index 355156f..0000000
--- a/src/EPMS/GEN/GEN_CAT_GCCP_TCP/README.md
+++ /dev/null
@@ -1,33 +0,0 @@
-# EQUIPMENT_TYPE MANUFACTURER MODEL TCP
-
-## Brief Introduction
-Equipment specifc details that make it different from other devices
-
-## List of Equipmentt
-This cofiguration has been used for these models:
-* **Model**: 09-15-22 
-* **Model**: 09-15-23 
-* **Model**: 09-15-25 
-
-## Hardware Prerequisites
-
-The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities.
-* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html) 
-
----
-
-## States and Strategies
-Provide a brief description of what variables and strategies were used in this configuraiton
-
-### Standby State
-* **Equipment running**: set to 0
-* **Common Alarm**: set to 0
-* **SAT temperature**: set to 85
-
-### Running State
-* **Equipment running**: set to 1
-* **SAT temperature**: **Ramp Strategy** set to 65 deg setpoint
-
-### Fail State
-* **Commong Alarm**: set to 1
-* **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset
diff --git a/src/EPMS/GEN/GEN_CAT_GCCP_TCP/State_Fail.cpp b/src/EPMS/GEN/GEN_CAT_GCCP_TCP/State_Fail.cpp
deleted file mode 100644
index 8bc0385..0000000
--- a/src/EPMS/GEN/GEN_CAT_GCCP_TCP/State_Fail.cpp
+++ /dev/null
@@ -1,81 +0,0 @@
-/**
- * @file State_Fail.cpp
- * @brief Implementation of the FailState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the FailState, which defines
- * the behavior of the equipment when it has entered a fault condition.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new FailState object with a list of active alarms.
- *
- * This constructor receives a list of alarm descriptions and creates strategies
- * to set the corresponding Modbus points to a value of 1, indicating an
- * active alarm. It also initializes a PID strategy for the 'CW Valve Position'
- * to maintain its state during the fault.
- * @param activeAlarms A vector of strings, where each string is the
- *                     description of a Modbus point to be set as an active alarm.
- */
-template<>
-FailState<ModbusIP>::FailState(const std::vector<std::string>& activeAlarms) {
-    // Simulate a failure: set common alarm and a specific fan alarm.
-
-    
-}
-
-/**
- * @brief Executes the fail state's logic for one update cycle.
- *
- * This method checks the "Alarm Reset" Modbus point for a command to
- * transition back to Standby, which would typically happen after a fault
- * is cleared by a user. If no transition is requested, it continues to apply
- * the failure strategies (e.g., keeping alarm bits active).
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* FailState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Fail update function");
-    
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the fail state.
- * Sets the "Alarm Common" point to 1 to indicate a general fault condition.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Fail State...");
-}
-
-/**
- * @brief Logic to execute once when exiting the fail state.
- * Clears the "Alarm Common" point to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Fail State...");
-}
\ No newline at end of file
diff --git a/src/EPMS/GEN/GEN_CAT_GCCP_TCP/State_Running.cpp b/src/EPMS/GEN/GEN_CAT_GCCP_TCP/State_Running.cpp
deleted file mode 100644
index 44afe79..0000000
--- a/src/EPMS/GEN/GEN_CAT_GCCP_TCP/State_Running.cpp
+++ /dev/null
@@ -1,92 +0,0 @@
-/**
- * @file State_Running.cpp
- * @brief Implementation of the RunningState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the RunningState, which defines
- * the behavior of the equipment when it is actively running.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "Strategies/Strategy_Totalizer.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new RunningState object.
- *
- * This constructor initializes behavior strategies active during the running
- * state, such as a PID controller for the 'CW Valve Position' and totalizers
- * for the run-hours of each EC fan.
- */
-template<>
-RunningState<ModbusIP>::RunningState() {
-}
-
-/**
- * @brief Executes the running state's logic for one update cycle.
- *
- * This method first checks for state transition commands:
- * 1. It reads the "ON/OFF Command By BMS" point. If it's 0, it transitions to StandbyState.
- * 2. It reads the "Fault Code" point. If it's non-zero, it transitions to FailState,
- *    passing the corresponding alarm description.
- *
- * If no transition occurs, it applies the strategies defined for the running state.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* RunningState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Running update function");
-    float Mode = getPointValue(equipment, "PxMode");
-    if (static_cast<int>(Mode) == 2 ){
-        return new StandbyState<ModbusIP>();
-    }
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the running state.
- * Sets the "Run Status" for all EC fans to 1 to indicate they are active.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Running State...");
-    // You could also update a Modbus register to show the "standby" state
-
-}
-
-/**
- * @brief Logic to execute once when exiting the running state.
- * Sets the "Run Status" for all EC fans to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Running State...");
-   
-}
\ No newline at end of file
diff --git a/src/EPMS/GEN/GEN_CAT_GCCP_TCP/State_Standby.cpp b/src/EPMS/GEN/GEN_CAT_GCCP_TCP/State_Standby.cpp
deleted file mode 100644
index 90f8eb3..0000000
--- a/src/EPMS/GEN/GEN_CAT_GCCP_TCP/State_Standby.cpp
+++ /dev/null
@@ -1,89 +0,0 @@
-/**
- * @file State_Standby.cpp
- * @brief Implementation of the StandbyState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the StandbyState, which defines
- * the behavior of the equipment when it is in an idle or standby mode.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-/**
- * @brief Constructs a new StandbyState object.
- *
- * In this state, the equipment is idle. This constructor initializes strategies
- * to bring the system to a safe, idle condition. It sets a stable value for
- * the SAT reading and creates ramp strategies to bring the CW valve and all
- * EC fan speeds down to zero.
- */
-template<>
-StandbyState<ModbusIP>::StandbyState() {
-    // You can add initialization code here if needed
-    
-
-}
-
-/**
- * @brief Executes the standby state's logic for one update cycle.
- *
- * This method applies the strategies defined for the standby state (e.g.,
- * ramping values to zero).
- *
- * @warning This method currently does not check for a command to transition to the
- *          Running state. This logic needs to be added to allow the unit to start.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* StandbyState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Standby update function");
-    float Mode = getPointValue(equipment, "PxMode");
-    if (static_cast<int>(Mode) == 2 ){
-        return new RunningState<ModbusIP>();
-    }
-    
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the standby state.
- * This method performs cleanup by setting all alarm points and all EC fan
- * run status points to 0.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Standby State...");
-}
-
-/**
- * @brief Logic to execute once when exiting the standby state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Standby State...");
-}
\ No newline at end of file
diff --git a/src/EPMS/GEN/GEN_CAT_GCCP_TCP/config.h b/src/EPMS/GEN/GEN_CAT_GCCP_TCP/config.h
deleted file mode 100644
index 72959e4..0000000
--- a/src/EPMS/GEN/GEN_CAT_GCCP_TCP/config.h
+++ /dev/null
@@ -1,133 +0,0 @@
-/**
- * @file config.h
- * @brief Main configuration file for the GEN CAT EMCP4
- * @author Zach Gutierrez
- * @date 2025-09-02
- *
- * This file contains two important configurations: WiFi network parameters
- * and the Modbus register map for the device.
- */
-
-#ifndef CONFIG_H
-#define CONFIG_H
-
-#include "core.h"
-#include "Equipment/Equipment.h"
-
-#if defined(USE_MODBUS_IP)
-/**
-   * @defgroup ModbusTCPConfig Modbus IP Configuration
-   * @brief Parameters for Modbus TCP communication.
-   * @{
-   */
-  #include <ModbusIP_ESP8266.h>
-  const char *ssid = "wifi_name";       /**< @brief The SSID of the WiFi network. */
-  const char *password = "wifi_password";   /**< @brief The password for the WiFi network. */
-  IPAddress local_IP(192, 168, 1, 234);       /**< @brief The static IP address for the device. */
-  IPAddress gateway(192, 168, 1, 1);          /**< @brief The gateway IP address. */
-  IPAddress subnet(255, 255, 255, 0);         /**< @brief The subnet mask. */
-  
-  ModbusIP mb;
-#else
-  /**
-   * @defgroup ModbusRTUConfig Modbus RTU Configuration
-   * @brief Parameters for serial Modbus RTU communication.
-   * @{
-   */
-  #include <ModbusRTU.h>
-  const int BAUDRATE = 19200;   /**< @brief The serial communication speed in bits per second. */
-  const int RX_PIN = 17;        /**< @brief The GPIO pin used for receiving data (RX). */
-  const int TX_PIN = 16;        /**< @brief The GPIO pin used for transmitting data (TX). */
-  const int RST_PIN = 4;        /**< @brief The GPIO pin connected to the RS485 driver's DE/RE pins for direction control. */
-  const int MODBUS_ID = 1;      /**< @brief The unique slave ID for this device on the Modbus bus. */
-  /** @} */
-
-  /** @brief Global instance of the Modbus RTU server. */
-  ModbusRTU mb;
-#endif
-
-
-
-/**
- * @defgroup ModbusMapConfig Modbus Map Configuration
- * @brief Defines the Modbus register map and related parameters for the emulator.
- * @{
- */
-/**
- * @brief The Modbus map for the Equipment device.
- * This array defines all the Modbus points available on the emulated device.
- * The `description` field is crucial as it's used to look up points within the application logic.
- */
-modbusMap mb_map[] = {
-  // ESP8266 Modbus server uses 0-based addressing, while Modbus Poll uses 1-based addressing.
-  {HR, 9,  0, "PxMode" },             // 448900 High_Coolant_Temp_Warning
-  {HR, 10, 0, "Px01" },             // 448899 Low_Coolant_Temp
-  {HR, 11, 0, "Px02" },             // 448906 Unexpected_Engine_Shutdown
-
-  {HR, 48900, 0, "Alm01" },             // 448900 High_Coolant_Temp_Warning
-  {HR, 48899, 0, "Alm02" },             // 448899 Low_Coolant_Temp
-  {HR, 48906, 0, "Alm03" },             // 448906 Unexpected_Engine_Shutdown
-  {HR, 48897, 0, "Alm04" },             // 448897 Emergency_Stop
-  {HR, 48901, 0, "Alm05" },             // 448901 High_Coolant_Temp_Alarm
-  {HR, 48904, 0, "Alm06" },             // 448904 Engine_Overspeed
-  {HR, 48902, 0, "Alm07" },             // 448902 Low_Oil_Pressure_Warning
-  {HR, 48903, 0, "Alm08" },             // 448903 Low_Oil_Pressure_Alarm
-  {HR, 48908, 0, "Fuel_LoLo" },         // 448908 Fuel_LoLo
-  {HR, 48913, 0, "Alm10" },             // 448913 Low_Battery_Voltage
-  {HR, 48898, 0, "Alm11" },             // 448898 Engine_Overcrank
-  {HR, 48915, 0, "Fuel_Hi" },           // 448915 Fuel_Hi
-  {HR, 48907, 0, "Fuel_Lo" },           // 448907 Fuel_Lo
-  {HR, 48912, 0, "Alm14" },             // 448912 High_Battery_Voltage
-  {HR, 48905, 0, "Common_Alarm" },      // 448905 Common_Alarm
-  {HR, 48914, 0, "Batt_Charge_Fail" },  // 448914 Battery_Charger_Failure
-  {HR, 48916, 0, "EPS_Supp_Load" },     // 448916 EPS_Supplying_Load
-  {HR, 8655, 0,  "Bkr_State" },         // 48655 Gen_Breaker_State
-  {HR, 1025, 0, "Oil Pressure" },       // 41025 Engine_Oil_Pressure
-  {HR, 1026, 0, "Coolant Temp" },       // 41026 Coolant_Temperature_degC
-  {HR, 1027, 0, "Oil_Temp_degC" },      // 41027 Oil_Temperature_degC
-  {HR, 1030, 0, "Battery_Voltage" },    // 41030 Battery_Voltage
-  {HR, 1031, 0, "Engine_Speed" },       // 41031 Engine_Speed
-  {HR, 1032, 0, "Freq" },               // 41032 Freq
-  {HR, 1033, 0, "Volts_AN" },           // 41033 Volts_AN
-  {HR, 1035, 0, "Volts_BN" },           // 41035 Volts_BN
-  {HR, 1037, 0, "Volts_CN" },           // 41037 Volts_CN
-  {HR, 1039, 0, "Volts_AB" },           // 41039 Volts_AB
-  {HR, 1041, 0, "Volts_BC" },           // 41041 Volts_BC
-  {HR, 1043, 0, "Volts_CA" },           // 41043 Volts_CA
-  {HR, 1045, 0, "Amps_A" },             // 41045 Amps_A
-  {HR, 1047, 0, "Amps_B" },             // 41047 Amps_B
-  {HR, 1049, 0, "Amps_C" },             // 41049 Amps_C
-  {HR, 1053, 0, "kW_A" },               // 41053 kW_A
-  {HR, 1055, 0, "kW_B" },               // 41055 kW_B
-  {HR, 1057, 0, "kW_C" },               // 41057 kW_C
-  {HR, 1289, 0, "L_Exhaust_degC" },     // 41289 Left_Exhaust_Temp_degC
-  {HR, 1290, 0, "R_Exhaust_degC" },     // 41290 Right_Exhaust_Temp_degC
-  {HR, 1355, 0, "Percent_Load" },       // 41355 Percent_Load
-  {HR, 1537, 0, "kW_Tot" },             // 41537 kW
-  {HR, 1539, 0, "kVA_A" },              // 41539 kVA_A
-  {HR, 1541, 0, "kVA_B" },              // 41541 kVA_B
-  {HR, 1543, 0, "kVA_C" },              // 41543 kVA_C
-  {HR, 1545, 0, "kVA_Tot" },            // 41545 kVA
-  {HR, 1553, 0, "kVAR_Tot" },           // 41553 kVAR
-  {HR, 1558, 0, "PF_Tot" },             // 41558 PF
-  {HR, 1799, 0, "TTL_Run_Hours" },      // 41799 TTL_Run_Hours
-  {HR, 1801, 0, "kWh_Tot" },            // 41801 kWh
-  {HR, 1809, 0, "TTL_Starts" },         // 41809 TTL_Engine_Starts
-  {HR, 48909, 0, "Auto_Mode" },         // 448909 Auto_Mode
-  {HR, 48910, 0, "Stop_Mode" },         // 448910 Stop_Mode
-  {HR, 48911, 0, "Manual_Mode" },       // 448911 Manual_Mode
-  {HR, 772, 0, "Gen_Sts" }              // 400772 Generator Status
-};
-//Size of modbus map used in FOR cycles, automatically calculated.
-
-/**
- * @brief The total number of entries in the `mb_map` array.
- * This is calculated at compile time and used for iterating over the map.
- */
-const int map_size = sizeof(mb_map) / sizeof(mb_map[0]);
-
-/** @brief The main loop update interval in milliseconds. */
-int interval = 250; 
-/** @} */ // End of ModbusMapConfig group
-
-#endif // CONFIG_H
diff --git a/src/EPMS/GEN/GEN_CAT_GCCP_TCP/main.cpp b/src/EPMS/GEN/GEN_CAT_GCCP_TCP/main.cpp
deleted file mode 100644
index 286a98c..0000000
--- a/src/EPMS/GEN/GEN_CAT_GCCP_TCP/main.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-/**
- * @file main.cpp
- * @brief Main execution program for the CRAH Unit (TCP) Emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * @details This file contains the main execution program for an Arduino-based emulator of a CRAH unit. 
- * The program uses a Wi-Fi connection to communicate via the Modbus IP protocol.
- *
- * The setup() function initializes the following:
- * - Serial communication for debugging.
- * - Wi-Fi connection using credentials from config.h.
- * - A Modbus TCP server.
- * - Modbus points (Coils, Holding Registers, etc.) based on a predefined map in config.h.
- *
- * The loop() function continuously:
- * - Services the Modbus TCP server to handle incoming requests.
- * - Periodically calls the main update loop for the emulated equipment, which
- *   manages state transitions and behavior strategies.
- *
- * @see config.h for Wi-Fi and Modbus configuration.
- * @see Equipment.h for the main equipment logic.
- * @see State.h for different equipment states.
- * @see Strategies/Strategy_Behavior.h for value generation strategies.
- * @see Modbus_Point.h for the base class for all Modbus points.
- */
-//=================================================================================================================================
-//Libraries and declaration of variables.
-#include <WiFi.h>
-#include "config.h"
-#include "ModbusPoints/Modbus_PointFactory.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-//=================================================================================================================================
-/** 
- * @brief Initializes the application.
- * @details This function runs once at startup. It configures the serial communication, 
- * Wi-Fi, and the Modbus server. It also creates and initializes all the Modbus points 
- * based on the `mb_map` array in `config.h`.
- */
-void setup() {
-  Serial.begin(115200);                       //Serial comm start
-  WiFi.config(local_IP, gateway, subnet);     // Wifi service start
-  WiFi.begin(ssid, password);
-  while (WiFi.status() != WL_CONNECTED) {
-    delay(1000);
-    Serial.print(".");
-  }
-  Serial.println("Connected!!");
-  mb.server();                                //Modbus server start
-  Serial.println("Server Created");
-  Serial.println(map_size);
-  for(int i = 0; i < map_size; i++){
-    Modbus_Point<ModbusIP>* point = createModbus_Point(&mb, mb_map[i].category, mb_map[i].address, mb_map[i].value, mb_map[i].description);
-    if (point) {
-      point->addToModbusServer();
-      EquipmentInstance.addModbus_Point(mb_map[i].description, point);
-    }
-  }
-  Serial.println("All modbus Points created");
-  Serial.println("Setup function ended");
-}
-//=================================================================================================================================
-/** 
- * @brief The main application loop.
- * @details This function runs repeatedly after setup() has completed. It performs two main actions:
- * 1. It continuously services the Modbus server by calling `mb.task()` to handle
- *    incoming requests from a Modbus master.
- * 2. At a fixed interval (defined in `config.h`), it calls `EquipmentInstance.update()`
- *    to run the emulator's internal state machine and behavior logic.
- */
-void loop() {
-  mb.task();
-  unsigned long currentMillis = millis();
-  if (currentMillis - previousMillis >= interval) {
-    previousMillis = currentMillis;
-    unsigned long startTime = millis();
-    EquipmentInstance.update();
-    unsigned long endTime = millis();
-    unsigned long elapsedTime = endTime - startTime;
-    Serial.printf("Control Execution time: %d ms\n", elapsedTime);
-  } 
-}
diff --git a/src/EPMS/GEN/GEN_HSE/README.md b/src/EPMS/GEN/GEN_HSE/README.md
deleted file mode 100644
index 4f156e3..0000000
--- a/src/EPMS/GEN/GEN_HSE/README.md
+++ /dev/null
@@ -1,48 +0,0 @@
-# Daikin Chiller (RTU) Emulator
-
-This project is an Arduino-based emulator for a Daikin Chiller unit, communicating over Modbus RTU. It is designed to be a flexible template that can be adapted to simulate different types of chillers by modifying the configuration and state logic.
-
-The emulator operates on a state machine with three core states:
-* **Standby**: The chiller is idle but ready.
-* **Running**: The chiller is active and operational.
-* **Fail**: The chiller has encountered a fault condition.
-
-## Features
-
-* **Modbus RTU Communication**: Emulates a Modbus slave device.
-* **State Machine Logic**: Simulates different operational states (Standby, Running, Fail).
-* **Dynamic Value Simulation**: Uses "Strategies" (e.g., PID, Ramp) to generate realistic, changing values for Modbus points.
-* **Configurable Modbus Map**: The entire Modbus register map is defined in a single, easy-to-modify file (`config.h`).
-* **Extensible Design**: The structure allows for the addition of new states and behaviors.
-
-## Hardware Prerequisites
-
-The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities and at least one hardware serial port for RS485 communication.
-
-* **Microcontroller**: ESP8266, ESP32, or similar.
-* **RS485 Transceiver**: A module like the MAX485 to interface with the Modbus RTU bus.
-
-## Software Dependencies
-
-This project relies on a Modbus library. Ensure you have the correct library installed in your Arduino IDE.
-
-* **Modbus Library**: The code uses a library that provides `ModbusRTU.h` and optionally `ModbusIP_ESP8266.h`.
-
----
-
-## How to Customize for a New Chiller
-
-To adapt this template for a new chiller, follow these steps.
-
-### 1. Configure Device-Specific Parameters (`config.h`)
-
-Open `CH_Daikin_AWV026B_RTU/config.h`. This is the main file for device-specific settings.
-
-#### Modbus RTU Settings
-Update the following constants for your device's serial communication setup.
-```c++
-const int BAUDRATE = 19200;   // The serial communication speed
-const int RX_PIN = 17;        // The GPIO pin for receiving data (RX)
-const int TX_PIN = 16;        // The GPIO pin for transmitting data (TX)
-const int RST_PIN = 4;        // The GPIO pin for RS485 direction control
-const int MODBUS_ID = 1;      // The unique slave ID for this device
\ No newline at end of file
diff --git a/src/EPMS/GEN/GEN_HSE/State_Fail.cpp b/src/EPMS/GEN/GEN_HSE/State_Fail.cpp
deleted file mode 100644
index 8bc0385..0000000
--- a/src/EPMS/GEN/GEN_HSE/State_Fail.cpp
+++ /dev/null
@@ -1,81 +0,0 @@
-/**
- * @file State_Fail.cpp
- * @brief Implementation of the FailState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the FailState, which defines
- * the behavior of the equipment when it has entered a fault condition.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new FailState object with a list of active alarms.
- *
- * This constructor receives a list of alarm descriptions and creates strategies
- * to set the corresponding Modbus points to a value of 1, indicating an
- * active alarm. It also initializes a PID strategy for the 'CW Valve Position'
- * to maintain its state during the fault.
- * @param activeAlarms A vector of strings, where each string is the
- *                     description of a Modbus point to be set as an active alarm.
- */
-template<>
-FailState<ModbusIP>::FailState(const std::vector<std::string>& activeAlarms) {
-    // Simulate a failure: set common alarm and a specific fan alarm.
-
-    
-}
-
-/**
- * @brief Executes the fail state's logic for one update cycle.
- *
- * This method checks the "Alarm Reset" Modbus point for a command to
- * transition back to Standby, which would typically happen after a fault
- * is cleared by a user. If no transition is requested, it continues to apply
- * the failure strategies (e.g., keeping alarm bits active).
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* FailState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Fail update function");
-    
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the fail state.
- * Sets the "Alarm Common" point to 1 to indicate a general fault condition.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Fail State...");
-}
-
-/**
- * @brief Logic to execute once when exiting the fail state.
- * Clears the "Alarm Common" point to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Fail State...");
-}
\ No newline at end of file
diff --git a/src/EPMS/GEN/GEN_HSE/State_Running.cpp b/src/EPMS/GEN/GEN_HSE/State_Running.cpp
deleted file mode 100644
index b9e4a99..0000000
--- a/src/EPMS/GEN/GEN_HSE/State_Running.cpp
+++ /dev/null
@@ -1,89 +0,0 @@
-/**
- * @file State_Running.cpp
- * @brief Implementation of the RunningState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the RunningState, which defines
- * the behavior of the equipment when it is actively running.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "Strategies/Strategy_Totalizer.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new RunningState object.
- *
- * This constructor initializes behavior strategies active during the running
- * state, such as a PID controller for the 'CW Valve Position' and totalizers
- * for the run-hours of each EC fan.
- */
-template<>
-RunningState<ModbusIP>::RunningState() {
-}
-
-/**
- * @brief Executes the running state's logic for one update cycle.
- *
- * This method first checks for state transition commands:
- * 1. It reads the "ON/OFF Command By BMS" point. If it's 0, it transitions to StandbyState.
- * 2. It reads the "Fault Code" point. If it's non-zero, it transitions to FailState,
- *    passing the corresponding alarm description.
- *
- * If no transition occurs, it applies the strategies defined for the running state.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* RunningState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Running update function");
-    
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the running state.
- * Sets the "Run Status" for all EC fans to 1 to indicate they are active.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Running State...");
-    // You could also update a Modbus register to show the "standby" state
-
-}
-
-/**
- * @brief Logic to execute once when exiting the running state.
- * Sets the "Run Status" for all EC fans to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Running State...");
-   
-}
\ No newline at end of file
diff --git a/src/EPMS/GEN/GEN_HSE/State_Standby.cpp b/src/EPMS/GEN/GEN_HSE/State_Standby.cpp
deleted file mode 100644
index 20029d1..0000000
--- a/src/EPMS/GEN/GEN_HSE/State_Standby.cpp
+++ /dev/null
@@ -1,85 +0,0 @@
-/**
- * @file State_Standby.cpp
- * @brief Implementation of the StandbyState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the StandbyState, which defines
- * the behavior of the equipment when it is in an idle or standby mode.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-/**
- * @brief Constructs a new StandbyState object.
- *
- * In this state, the equipment is idle. This constructor initializes strategies
- * to bring the system to a safe, idle condition. It sets a stable value for
- * the SAT reading and creates ramp strategies to bring the CW valve and all
- * EC fan speeds down to zero.
- */
-template<>
-StandbyState<ModbusIP>::StandbyState() {
-    // You can add initialization code here if needed
-    
-
-}
-
-/**
- * @brief Executes the standby state's logic for one update cycle.
- *
- * This method applies the strategies defined for the standby state (e.g.,
- * ramping values to zero).
- *
- * @warning This method currently does not check for a command to transition to the
- *          Running state. This logic needs to be added to allow the unit to start.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* StandbyState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Standby update function");
-    
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the standby state.
- * This method performs cleanup by setting all alarm points and all EC fan
- * run status points to 0.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Standby State...");
-}
-
-/**
- * @brief Logic to execute once when exiting the standby state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Standby State...");
-}
\ No newline at end of file
diff --git a/src/EPMS/GEN/GEN_HSE/config.h b/src/EPMS/GEN/GEN_HSE/config.h
deleted file mode 100644
index f5c4439..0000000
--- a/src/EPMS/GEN/GEN_HSE/config.h
+++ /dev/null
@@ -1,132 +0,0 @@
-/**
- * @file config.h
- * @brief Main configuration file for the CRAH Unit (TCP) emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * This file contains two important configurations: WiFi network parameters
- * and the Modbus register map for the device.
- */
-
-#ifndef CONFIG_H
-#define CONFIG_H
-
-#include "core.h"
-#include "Equipment/Equipment.h"
-
-#if defined(USE_MODBUS_IP)
-/**
-   * @defgroup ModbusTCPConfig Modbus IP Configuration
-   * @brief Parameters for Modbus TCP communication.
-   * @{
-   */
-  #include <ModbusIP_ESP8266.h>
-  const char *ssid = "ArduinoWifiB";       /**< @brief The SSID of the WiFi network. */
-  const char *password = "123abc456";   /**< @brief The password for the WiFi network. */
-  IPAddress local_IP(172, 17, 32, 81);       /**< @brief The static IP address for the device. */
-  IPAddress gateway(172, 17, 32, 1);          /**< @brief The gateway IP address. */
-  IPAddress subnet(255, 255, 255, 0);         /**< @brief The subnet mask. */
-  
-  ModbusIP mb;
-#else
-  /**
-   * @defgroup ModbusRTUConfig Modbus RTU Configuration
-   * @brief Parameters for serial Modbus RTU communication.
-   * @{
-   */
-  #include <ModbusRTU.h>
-  const int BAUDRATE = 19200;   /**< @brief The serial communication speed in bits per second. */
-  const int RX_PIN = 17;        /**< @brief The GPIO pin used for receiving data (RX). */
-  const int TX_PIN = 16;        /**< @brief The GPIO pin used for transmitting data (TX). */
-  const int RST_PIN = 4;        /**< @brief The GPIO pin connected to the RS485 driver's DE/RE pins for direction control. */
-  const int MODBUS_ID = 1;      /**< @brief The unique slave ID for this device on the Modbus bus. */
-  /** @} */
-
-  /** @brief Global instance of the Modbus RTU server. */
-  ModbusRTU mb;
-#endif
-
-
-
-/**
- * @defgroup ModbusMapConfig Modbus Map Configuration
- * @brief Defines the Modbus register map and related parameters for the emulator.
- * @{
- */
-/**
- * @brief The Modbus map for the Equipment device.
- * This array defines all the Modbus points available on the emulated device.
- * The `description` field is crucial as it's used to look up points within the application logic.
- */
-modbusMap mb_map[] =
-{   
-  {HR,        15,     0,  "State Control"},  //Internal to control from Modscan
-  {HR,        16,     0,  "Fault Code"},        
-  {DI,       48914,   0,  "Battery Charger Failure"},         
-  {DI,       48905,   0,  "Common Alarm"},        
-  {DI,       48897,   0,  "Emergency Stop"},        
-  {DI,       48898,   0,  "Engine Overcrank"},  
-  {DI,       48904,   0,  "Engine Overspeed"},                  
-  {DI,       48916,   0,  "EPS Supplying Load"},            
-  {DI,       48915,   0,  "High Fuel Level"},                
-  {DI,       48907,   0,  "Low Fuel Level"},                 
-  {DI,       48908,   0,  "Low Low Fuel Level"},                 
-  {DI,       48912,   0,  "High Battery Voltage"},                  
-  {DI,       48901,   0,  "High Coolant Temp Shutdown"},                
-  {DI,       48900,   0,  "High Coolant Temp Warning"},                 
-  {DI,       48913,   0,  "Low Battery Voltage"},                  
-  {DI,       48899,   0,  "Low Coolant Temp Warning"},            
-  {DI,       48903,   0,  "Low Oil Pressure Shutdown"},         
-  {DI,       48902,   0,  "Low Oil Pressure Warning"},                   
-  {DI,       48906,   0,  "Common Shutdown"},  
-  {HR_LONG,   1045,   0,  "Amps A"},
-  {HR_LONG,   1047,   0,  "Amps B"},
-  {HR_LONG,   1049,   0,  "Amps C"},
-  {HR_LONG,   1545,   0,  "kVA"},
-  {HR_LONG,   1537,   0,  "kW"},
-  {HR_LONG,   1801,   0,  "kWh"},
-  {HR_LONG,   1809,   0,  "Total Engine Starts"},
-  {HR_LONG,   1799,   0,  "Total Run Hours"},
-  {HR_LONG,   1039,   0,  "Volts AB"},
-  {HR_LONG,   1033,   0,  "Volts AN"},
-  {HR_LONG,   1041,   0,  "Volts BC"},
-  {HR_LONG,   1035,   0,  "Volts BN"},
-  {HR_LONG,   1043,   0,  "Volts CA"},
-  {HR_LONG,   1037,   0,  "Volts CN"},
-  {HR,        8909,   0,  "Auto Mode"},
-  {HR,        1026,   0,  "Coolant Temp Deg C"},
-  {HR,        1025,   0,  "Engine Oil Pressure"},
-  {HR,        1031,   0,  "Engine Speed"},
-  {HR,        1032,   0,  "Frequency"},
-  {HR,        8655,   0,  "Gen Breaker Status"},
-  {HR,         772,   0,  "Gen Status"},
-  {HR,        1289,   0,  "Left Exhaust Temp Deg C"},
-  {HR,        8911,   0,  "Manual Mode"},
-  {HR,        1027,   0,  "Oil Temp Deg C"},
-  {HR,        1355,   0,  "Percent Load"},
-  {HR,        1558,   0,  "Power Factor (PF)"},
-  {HR,        1290,   0,  "Right Exhaust Temp Deg C"},
-  {HR,        8910,   0,  "Stop Mode"},
-  {HR_FLOAT,  1539,   0,  "kVA A"},
-  {HR_FLOAT,  1541,   0,  "kVA B"},
-  {HR_FLOAT,  1543,   0,  "kVA C"},
-  {HR_FLOAT,  1553,   0,  "kVAR"},
-  {HR_FLOAT,  1053,   0,  "kW A"},
-  {HR_FLOAT,  1055,   0,  "kW B"},
-  {HR_FLOAT,  1057,   0,  "kW C"},
-
-
-};
-//Size of modbus map used in FOR cycles, automatically calculated.
-
-/**
- * @brief The total number of entries in the `mb_map` array.
- * This is calculated at compile time and used for iterating over the map.
- */
-const int map_size = sizeof(mb_map) / sizeof(mb_map[0]);
-
-/** @brief The main loop update interval in milliseconds. */
-int interval = 250; 
-/** @} */ // End of ModbusMapConfig group
-
-#endif // CONFIG_H
diff --git a/src/EPMS/GEN/GEN_HSE/main.cpp b/src/EPMS/GEN/GEN_HSE/main.cpp
deleted file mode 100644
index 286a98c..0000000
--- a/src/EPMS/GEN/GEN_HSE/main.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-/**
- * @file main.cpp
- * @brief Main execution program for the CRAH Unit (TCP) Emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * @details This file contains the main execution program for an Arduino-based emulator of a CRAH unit. 
- * The program uses a Wi-Fi connection to communicate via the Modbus IP protocol.
- *
- * The setup() function initializes the following:
- * - Serial communication for debugging.
- * - Wi-Fi connection using credentials from config.h.
- * - A Modbus TCP server.
- * - Modbus points (Coils, Holding Registers, etc.) based on a predefined map in config.h.
- *
- * The loop() function continuously:
- * - Services the Modbus TCP server to handle incoming requests.
- * - Periodically calls the main update loop for the emulated equipment, which
- *   manages state transitions and behavior strategies.
- *
- * @see config.h for Wi-Fi and Modbus configuration.
- * @see Equipment.h for the main equipment logic.
- * @see State.h for different equipment states.
- * @see Strategies/Strategy_Behavior.h for value generation strategies.
- * @see Modbus_Point.h for the base class for all Modbus points.
- */
-//=================================================================================================================================
-//Libraries and declaration of variables.
-#include <WiFi.h>
-#include "config.h"
-#include "ModbusPoints/Modbus_PointFactory.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-//=================================================================================================================================
-/** 
- * @brief Initializes the application.
- * @details This function runs once at startup. It configures the serial communication, 
- * Wi-Fi, and the Modbus server. It also creates and initializes all the Modbus points 
- * based on the `mb_map` array in `config.h`.
- */
-void setup() {
-  Serial.begin(115200);                       //Serial comm start
-  WiFi.config(local_IP, gateway, subnet);     // Wifi service start
-  WiFi.begin(ssid, password);
-  while (WiFi.status() != WL_CONNECTED) {
-    delay(1000);
-    Serial.print(".");
-  }
-  Serial.println("Connected!!");
-  mb.server();                                //Modbus server start
-  Serial.println("Server Created");
-  Serial.println(map_size);
-  for(int i = 0; i < map_size; i++){
-    Modbus_Point<ModbusIP>* point = createModbus_Point(&mb, mb_map[i].category, mb_map[i].address, mb_map[i].value, mb_map[i].description);
-    if (point) {
-      point->addToModbusServer();
-      EquipmentInstance.addModbus_Point(mb_map[i].description, point);
-    }
-  }
-  Serial.println("All modbus Points created");
-  Serial.println("Setup function ended");
-}
-//=================================================================================================================================
-/** 
- * @brief The main application loop.
- * @details This function runs repeatedly after setup() has completed. It performs two main actions:
- * 1. It continuously services the Modbus server by calling `mb.task()` to handle
- *    incoming requests from a Modbus master.
- * 2. At a fixed interval (defined in `config.h`), it calls `EquipmentInstance.update()`
- *    to run the emulator's internal state machine and behavior logic.
- */
-void loop() {
-  mb.task();
-  unsigned long currentMillis = millis();
-  if (currentMillis - previousMillis >= interval) {
-    previousMillis = currentMillis;
-    unsigned long startTime = millis();
-    EquipmentInstance.update();
-    unsigned long endTime = millis();
-    unsigned long elapsedTime = endTime - startTime;
-    Serial.printf("Control Execution time: %d ms\n", elapsedTime);
-  } 
-}
diff --git a/src/EPMS/GEN/GEN_Kohler_KD2500_RTU_PHXA7/README.md b/src/EPMS/GEN/GEN_Kohler_KD2500_RTU_PHXA7/README.md
deleted file mode 100644
index 630cf02..0000000
--- a/src/EPMS/GEN/GEN_Kohler_KD2500_RTU_PHXA7/README.md
+++ /dev/null
@@ -1,35 +0,0 @@
-# EQUIPMENT_TYPE MANUFACTURER MODEL RTU
-
-## Brief Introduction
-Equipment specifc details that make it different from other devices
-
-## List of Equipmentt
-This cofiguration has been used for these models:
-* **Model**: 09-15-22 
-* **Model**: 09-15-23 
-* **Model**: 09-15-25 
-
-## Hardware Prerequisites
-
-The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities and at least one hardware serial port for RS485 communication.
-
-* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html) 
-* **RS485 Transceiver**: [RS485 Shield for Arduino.](https://www.dfrobot.com/product-1024.html)
-
----
-
-## States and Strategies
-Provide a brief description of what variables and strategies were used in this configuraiton
-
-### Standby State
-* **Equipment running**: set to 0
-* **Common Alarm**: set to 0
-* **SAT temperature**: set to 85
-
-### Running State
-* **Equipment running**: set to 1
-* **SAT temperature**: **Ramp Strategy** set to 65 deg setpoint
-
-### Fail State
-* **Commong Alarm**: set to 1
-* **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset
diff --git a/src/EPMS/GEN/GEN_Kohler_KD2500_RTU_PHXA7/State_Fail.cpp b/src/EPMS/GEN/GEN_Kohler_KD2500_RTU_PHXA7/State_Fail.cpp
deleted file mode 100644
index 6d85f9a..0000000
--- a/src/EPMS/GEN/GEN_Kohler_KD2500_RTU_PHXA7/State_Fail.cpp
+++ /dev/null
@@ -1,77 +0,0 @@
-/**
- * @file State_Fail.cpp
- * @brief Implementation of the FailState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the FailState, which defines
- * the behavior of the equipment when it has entered a fault condition.
- */
-#include "States/State_Standby.h"
-#include "States/State_Fail.h"
-#include "ModbusPoints/Modbus_Point.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_PID.h"
-
-#include <vector>
-#include <string>
-
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new FailState object.
- *
- * This constructor receives a list of alarm descriptions and creates strategies
- * to set the corresponding Modbus points to a value of 1, indicating an
- * active alarm. It also initializes a PID strategy for the valve position.
- */
-template<>
-FailState<ModbusRTU>::FailState(const std::vector<std::string>& activeAlarms) {
-    // Simulate a failure: set common alarm and a specific fan alarm.
-}
-
-/**
- * @brief Executes the fail state's logic for one update cycle.
- *
- * This method checks the "Clear Alm" Modbus point for a command to transition
- * back to Standby, which would typically happen after a fault is cleared by a
- * user. If no transition is requested, it continues to apply the failure strategies.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusRTU>* FailState<ModbusRTU>::update(Equipment<ModbusRTU>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Fail update function");
-    
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the fail state. Sets the main alarm bit.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusRTU>::enterState(Equipment<ModbusRTU>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Fail State...");
-    
-}
-
-/**
- * @brief Logic to execute once when exiting the fail state. Clears the main alarm bit.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusRTU>::exitState(Equipment<ModbusRTU>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Fail State...");
-    
-}
\ No newline at end of file
diff --git a/src/EPMS/GEN/GEN_Kohler_KD2500_RTU_PHXA7/State_Running.cpp b/src/EPMS/GEN/GEN_Kohler_KD2500_RTU_PHXA7/State_Running.cpp
deleted file mode 100644
index 4299d0b..0000000
--- a/src/EPMS/GEN/GEN_Kohler_KD2500_RTU_PHXA7/State_Running.cpp
+++ /dev/null
@@ -1,89 +0,0 @@
-/**
- * @file State_Running.cpp
- * @brief Implementation of the RunningState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the RunningState, which defines
- * the behavior of the equipment when it is actively running.
- */
-
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "Strategies/Strategy_Behavior.h"
-#include "Strategies/Strategy_PID.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Totalizer.h"
-#include "Equipment/Equipment.h"
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-
-#include <vector>
-#include <string>
-
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new RunningState object.
- *
- * This constructor initializes behavior strategies active during the running
- * state, such as a PID controller for the 'CW Valve Position' and totalizers
- * for the run-hours of each EC fan.
- */
-template<>
-RunningState<ModbusRTU>::RunningState() {
-    //Add strategies 
-    //addStrategy("Actual Capacity", new PIDStrategy("Active SP", 1000, "Supply Temp"));
-    
-}
-
-/**
- * @brief Executes the running state's logic for one update cycle.
- *
- * This method first checks for state transition commands:
- * 1. It reads the "ON/OFF Command By BMS" point. If it's 0, it transitions to StandbyState.
- * 2. It reads the "Fault Code" point. If it's non-zero, it transitions to FailState,
- *    passing the corresponding alarm description.
- *
- * If no transition occurs, it applies the strategies defined for the running state.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusRTU>* RunningState<ModbusRTU>::update(Equipment<ModbusRTU>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Running update function");
-    
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the running state.
- * Sets the "Chiller Sts" point to indicate the unit is running.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusRTU>::enterState(Equipment<ModbusRTU>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Running State...");
-    
-}
-
-/**
- * @brief Logic to execute once when exiting the running state.
- * Sets the "Chiller Sts" point to indicate the unit is no longer running.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusRTU>::exitState(Equipment<ModbusRTU>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Running State...");
-}
\ No newline at end of file
diff --git a/src/EPMS/GEN/GEN_Kohler_KD2500_RTU_PHXA7/State_Standby.cpp b/src/EPMS/GEN/GEN_Kohler_KD2500_RTU_PHXA7/State_Standby.cpp
deleted file mode 100644
index 9240a29..0000000
--- a/src/EPMS/GEN/GEN_Kohler_KD2500_RTU_PHXA7/State_Standby.cpp
+++ /dev/null
@@ -1,99 +0,0 @@
-/**
- * @file State_Standby.cpp
- * @brief Implementation of the StandbyState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the StandbyState, which defines
- * the behavior of the equipment when it is in an idle or standby mode.
- */
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "strategies/Strategy_SingleValue.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new StandbyState object.
- *
- * In this state, the equipment is idle. This constructor initializes several
- * strategies to generate random values for various status points, simulating
- * a live but non-operational unit.
- */
-template<>
-StandbyState<ModbusRTU>::StandbyState() {
-  addStrategy("Avg_Current", new SingleValueStrategy(3750.0f, 5.0f, 1000));
-  addStrategy("Batt_V", new SingleValueStrategy(14.0f, 0.5f, 1000));
-  addStrategy("Cooling_Tmp", new SingleValueStrategy(90.0f, 3.0f, 1000));
-  addStrategy("Engine_RPM", new SingleValueStrategy(1800.0f, 5.0f, 1000));
-  addStrategy("Freq", new SingleValueStrategy(60.0f, 1.0f, 1000));
-  addStrategy("Fuel_Rate", new SingleValueStrategy(85.0f, 5.0f, 1000));
-  addStrategy("kVAR_Total", new SingleValueStrategy(1875.0f, 5.0f, 1000));
-  addStrategy("kW_Total", new SingleValueStrategy(2500.0f, 5.0f, 1000));
-  addStrategy("Manifold_Tmp", new SingleValueStrategy(70.0f, 5.0f, 1000));
-  addStrategy("Oil_Pres", new SingleValueStrategy(50.0f, 5.0f, 1000));
-  addStrategy("Oil_Tmp", new SingleValueStrategy(100.0f, 5.0f, 1000));
-  addStrategy("PF_Total", new SingleValueStrategy(0.9f, 0.1f, 1000));
-  addStrategy("VoltageA", new SingleValueStrategy(240.0f, 2.0f, 1000));
-  addStrategy("VoltageB", new SingleValueStrategy(240.0f, 2.0f, 1000));
-  addStrategy("VoltageC", new SingleValueStrategy(240.0f, 2.0f, 1000));
-  addStrategy("Fuel_Percent", new SingleValueStrategy(75.0f, 2.0f, 1000));
-  addStrategy("CurrentA", new SingleValueStrategy(3750.0f, 5.0f, 1000));
-  addStrategy("CurrentB", new SingleValueStrategy(3750.0f, 5.0f, 1000));
-  addStrategy("CurrentC", new SingleValueStrategy(3750.0f, 5.0f, 1000));
-  addStrategy("Fuel_Usage", new SingleValueStrategy(70.0f, 5.0f, 1000));
-  addStrategy("VoltageAB", new SingleValueStrategy(480.0f, 5.0f, 1000));
-  addStrategy("VoltageBC", new SingleValueStrategy(480.0f, 5.0f, 1000));
-  addStrategy("VoltageCA", new SingleValueStrategy(480.0f, 5.0f, 1000));
-}
-
-/**
- * @brief Executes the standby state's logic for one update cycle.
- *
- * This method checks the "Chiller On-Off" Modbus point for a command to
- * transition to the Running state. If no transition is requested, it applies
- * the strategies defined for the standby state.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusRTU>* StandbyState<ModbusRTU>::update(Equipment<ModbusRTU>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Standby update function");
-    
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the standby state.
- * Sets the "Chiller Sts" point to indicate the unit is not running.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusRTU>::enterState(Equipment<ModbusRTU>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Standby State...");
-   
-}
-
-/**
- * @brief Logic to execute once when exiting the standby state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusRTU>::exitState(Equipment<ModbusRTU>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-   
-}
\ No newline at end of file
diff --git a/src/EPMS/GEN/GEN_Kohler_KD2500_RTU_PHXA7/config.h b/src/EPMS/GEN/GEN_Kohler_KD2500_RTU_PHXA7/config.h
deleted file mode 100644
index e5450a2..0000000
--- a/src/EPMS/GEN/GEN_Kohler_KD2500_RTU_PHXA7/config.h
+++ /dev/null
@@ -1,164 +0,0 @@
-/**
- * @file config.h
- * @brief Main configuration file for the Daikin Chiller (RTU) emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * This file contains important configurations for the Modbus RTU communication
- * and the specific register map for the emulated device.
- */
-
-#ifndef CONFIG_H
-#define CONFIG_H
-#include <ModbusRTU.h>
-#include "core.h"
-#include "Equipment/Equipment.h"
-
-
-#if defined(USE_MODBUS_IP)
-/**
-   * @defgroup ModbusTCPConfig Modbus IP Configuration
-   * @brief Parameters for Modbus TCP communication.
-   * @{
-   */
-  #include <ModbusIP_ESP8266.h>
-  const char *ssid = "wifi_name";       /**< @brief The SSID of the WiFi network. */
-  const char *password = "wifi_password";   /**< @brief The password for the WiFi network. */
-  IPAddress local_IP(192, 168, 1, 234);       /**< @brief The static IP address for the device. */
-  IPAddress gateway(192, 168, 1, 1);          /**< @brief The gateway IP address. */
-  IPAddress subnet(255, 255, 255, 0);         /**< @brief The subnet mask. */
-  
-  ModbusIP mb;
-#else
-  /**
-   * @defgroup ModbusRTUConfig Modbus RTU Configuration
-   * @brief Parameters for serial Modbus RTU communication.
-   * @{
-   */
-  #include <ModbusRTU.h>
-  const int BAUDRATE = 19200;   /**< @brief The serial communication speed in bits per second. */
-  const int RX_PIN = 17;        /**< @brief The GPIO pin used for receiving data (RX). */
-  const int TX_PIN = 16;        /**< @brief The GPIO pin used for transmitting data (TX). */
-  const int RST_PIN = 4;        /**< @brief The GPIO pin connected to the RS485 driver's DE/RE pins for direction control. */
-  const int MODBUS_ID = 1;      /**< @brief The unique slave ID for this device on the Modbus bus. */
-  /** @} */
-
-  /** @brief Global instance of the Modbus RTU server. */
-  ModbusRTU mb;
-#endif
-
-/**
- * @brief The Modbus map for the Equipment device.
- * This array defines all the Modbus points available on the emulated device.
- * The `description` field is crucial as it's used to look up points within the application logic.
- */
-modbusMap mb_map[] =
-{   
-  {COIL,        23,    0,  "Alm_GenFault"},
-  {HR_FLOAT,     668,    0,  "Avg_Current"},
-  {HR_FLOAT,     672,    0,  "Batt_V"},
-  {HR_FLOAT,     260,    0,  "Cooling_Tmp"},
-  {HR_FLOAT,     256,    0,  "Engine_RPM"},
-  {HR_FLOAT,     20,    0,  "Freq"},
-  {HR_FLOAT,     254,    0,  "Fuel_Rate"},
-  {HR_FLOAT,     656,    0,  "kVAR_Total"},
-  {HR_FLOAT,     654,    0,  "kW_Total"},
-  {HR_FLOAT,     262,    0,  "Manifold_Tmp"},
-  {HR_FLOAT,     278,    0,  "Oil_Pres"},
-  {HR_FLOAT,     258,    0,  "Oil_Tmp"},
-  {HR_FLOAT,     658,    0,  "PF_Total"},
-  {HR_FLOAT,     6,    0,  "VoltageA"},
-  {HR_FLOAT,     8,    0,  "VoltageB"},
-  {HR_FLOAT,     10,    0,  "VoltageC"},
-  {COIL,        29,    0,  "Breaker_Sts"},
-  {COIL,        30,    0,  "Tripped"},
-  {HR_FLOAT,     284,    0,  "Fuel_Percent"},
-  {HR,          999,    0,  "Engine_Starts"},
-  {HR_FLOAT,     266,    0,  "Run_Hrs"},
-  {COIL,        218,    0,  "Run_Status"},
-  {COIL,        222,    0,  "Charger_AC_Failure"},
-  {COIL,        12,    0,  "Emergency_Stop"},
-  {COIL,        326,    0,  "Failure_to_Close_1"},
-  {COIL,        327,    0,  "Failure_to_Close_2"},
-  {COIL,        356,    0,  "Fuel_Hi_Lvl"},
-  {COIL,        235,    0,  "Fuel_Leak_Detection"},
-  {COIL,        357,    0,  "Fuel_Low_Lvl"},
-  {COIL,        5,    0,  "Ground_Fault"},
-  {COIL,        226,    0,  "Hi_Engine_Tmp"},
-  {COIL,        220,    0,  "Low_Batt_V"},
-  {COIL,        739,    0,  "Low_Coolant_Lvl"},
-  {COIL,        224,    0,  "Low_Oil_Pres"},
-  {COIL,        233,    0,  "Not_in_Auto"},
-  {COIL,        275,    0,  "Over_Voltage_1"},
-  {COIL,        276,    0,  "Over_Voltage_2"},
-  {COIL,        277,    0,  "Over_Voltage_3"},
-  {COIL,        278,    0,  "Over_Voltage_4"},
-  {COIL,        279,    0,  "Over_Voltage_5"},
-  {COIL,        280,    0,  "Over_Voltage_6"},
-  {COIL,        284,    0,  "Overcurrent_1"},
-  {COIL,        285,    0,  "Overcurrent_2"},
-  {COIL,        286,    0,  "Overcurrent_3"},
-  {COIL,        234,    0,  "Overload"},
-  {COIL,        762,    0,  "Overspeed"},
-  {COIL,        225,    0,  "Pre_Hi_Engine_Temp_Alm"},
-  {COIL,        223,    0,  "Pre_Lo_Oil_Pres_Alm"},
-  {COIL,        23,    0,  "Shutdown_Alarm"},
-  {COIL,        201,    0,  "Under_Freq"},
-  {COIL,        263,    0,  "Under_Voltage_1"},
-  {COIL,        264,    0,  "Under_Voltage_2"},
-  {COIL,        265,    0,  "Under_Voltage_3"},
-  {COIL,        266,    0,  "Under_Voltage_4"},
-  {COIL,        267,    0,  "Under_Voltage_5"},
-  {COIL,        268,    0,  "Under_Voltage_6"},
-  {COIL,        209,    0,  "Low_Cooling_Tmp"},
-  {HR_FLOAT,     12,    0,  "CurrentA"},
-  {HR_FLOAT,     14,    0,  "CurrentB"},
-  {HR_FLOAT,     16,    0,  "CurrentC"},
-  {HR_FLOAT,     282,    0,  "Fuel_Usage"},
-  {HR_FLOAT,     0,    0,  "VoltageAB"},
-  {HR_FLOAT,     2,    0,  "VoltageBC"},
-  {HR_FLOAT,     4,    0,  "VoltageCA"},
-  {COIL,        1246,    0,  "ECU_CommLoss"},
-  {HR_FLOAT,     671,    0,  "Controller_Hours"},
-  {COIL,        13,    0,  "E_Stop"},
-  {COIL,        269,    0,  "OV_Warning_1"},
-  {COIL,        270,    0,  "OV_Warning_2"},
-  {COIL,        271,    0,  "OV_Warning_3"},
-  {COIL,        272,    0,  "OV_Warning_4"},
-  {COIL,        273,    0,  "OV_Warning_5"},
-  {COIL,        274,    0,  "OV_Warning_6"},
-  {COIL,        281,    0,  "OC_Warning_1"},
-  {COIL,        282,    0,  "OC_Warning_2"},
-  {COIL,        283,    0,  "OC_Warning_3"},
-  {COIL,        202,    0,  "Ufreq_Shutdown"},
-  {COIL,        257,    0,  "UV_Warning_1"},
-  {COIL,        258,    0,  "UV_Warning_2"},
-  {COIL,        259,    0,  "UV_Warning_3"},
-  {COIL,        260,    0,  "UV_Warning_4"},
-  {COIL,        261,    0,  "UV_Warning_5"},
-  {COIL,        262,    0,  "UV_Warning_6"},
-  {COIL,        200,    0,  "Overcrank"},
-  {COIL,        229,    0,  "Alt_Thermal_Shutdown_1"},
-  {COIL,        230,    0,  "Alt_Thermal_Shutdown_2"},
-  {COIL,        231,    0,  "Alt_Thermal_Shutdown_3"},
-  {COIL,        232,    0,  "Alt_Thermal_Shutdown_4"},
-  {COIL,        249,    0,  "RevPwr_Shutdown"},
-  {COIL,        250,    0,  "RevVAR_Shutdown"},
-  {COIL,        317,    0,  "Sys_NotReady"},
-  {COIL,        240,    0,  "Week_Battery"},
-  {HR_FLOAT,    670,    0,  "Controller_Hours"},
-};                     
- 
-//Size of modbus map used in FOR cycles, automatically calculated.
-/**
- * @brief The total number of entries in the `mb_map` array.
- * This is calculated at compile time and used for iterating over the map.
- */
-const int map_size = sizeof(mb_map) / sizeof(mb_map[0]);
-
-/**
- * @brief The main loop update interval in milliseconds.
- */
-int interval = 250; 
-
-#endif // CONFIG_H
diff --git a/src/EPMS/GEN/GEN_Kohler_KD2500_RTU_PHXA7/main.cpp b/src/EPMS/GEN/GEN_Kohler_KD2500_RTU_PHXA7/main.cpp
deleted file mode 100644
index 5dbc9f1..0000000
--- a/src/EPMS/GEN/GEN_Kohler_KD2500_RTU_PHXA7/main.cpp
+++ /dev/null
@@ -1,78 +0,0 @@
-/**
- * @file main.cpp
- * @brief Main execution program for the Daikin Chiller (RTU) Emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * @details This file contains the main execution program for an Arduino-based
- * emulator of a Daikin Chiller unit. The program communicates via the
- * Modbus RTU protocol over a serial connection.
- *
- * The setup() function initializes the following:
- * - Serial communication for debugging.
- * - A Modbus RTU server with parameters from config.h.
- * - Modbus points (Coils, Holding Registers, etc.) based on a predefined map in config.h.
- *
- * The loop() function continuously:
- * - Services the Modbus RTU server to handle incoming requests.
- * - Periodically calls the main update loop for the emulated equipment, which
- *   manages state transitions and behavior strategies.
- *
- * @see config.h for Modbus RTU and register map configuration.
- * @see Equipment.h for the main equipment logic.
- * @see State.h for different equipment states.
- * @see Strategies/Strategy_Behavior.h for value generation strategies.
- * @see Modbus_Point.h for the base class for all Modbus points.
- */
-//=================================================================================================================================
-//Libraries and declaration of variables.
-#include <Arduino.h>
-#include "config.h"
-#include "ModbusPoints/Modbus_PointFactory.h"
-
-//=================================================================================================================================
-/** 
- * @brief Initializes the application.
- * @details This function runs once at startup. It configures the serial communication
- * for debugging and the Modbus RTU server. It then creates and initializes all
- * the Modbus points based on the `mb_map` array in `config.h`.
- */
-const int rtsPin = 4;
-void setup() {
-  Serial.begin(115200);
-  Serial.println("Setup function started");
-
-  Serial2.begin(BAUDRATE, SERIAL_8N1, RX_PIN, TX_PIN);
-  mb.begin(&Serial2, RST_PIN); // Start the server
-  mb.slave(MODBUS_ID); // Set the slave ID
-   
-  for(int i = 0; i < map_size; i++){
-    Modbus_Point<ModbusRTU>* point = createModbus_Point(&mb, mb_map[i].category, mb_map[i].address, mb_map[i].value, mb_map[i].description);
-    if (point) {
-      point->addToModbusServer();
-      EquipmentInstance.addModbus_Point(mb_map[i].description, point);
-    }
-  }
-  Serial.println("Setup function ended"); 
-}
-//=================================================================================================================================
-/** 
- * @brief The main application loop.
- * @details This function runs repeatedly after setup() has completed. It performs two main actions:
- * 1. It continuously services the Modbus server by calling `mb.task()` to handle
- *    incoming requests from a Modbus master.
- * 2. At a fixed interval (defined in `config.h`), it calls `EquipmentInstance.update()`
- *    to run the emulator's internal state machine and behavior logic.
- */
-void loop() {
-  mb.task();
-  unsigned long currentMillis = millis();
-  if (currentMillis - previousMillis >= interval) {
-    previousMillis = currentMillis;
-    unsigned long startTime = millis();
-    EquipmentInstance.update();
-    unsigned long endTime = millis();
-    unsigned long elapsedTime = endTime - startTime;
-    Serial.printf("Control Execution time: %d ms\n", elapsedTime);
-  } 
-}
diff --git a/src/EPMS/Harmonic_Filter/Harmonic_Guard_RTU_PHXA7/README.md b/src/EPMS/Harmonic_Filter/Harmonic_Guard_RTU_PHXA7/README.md
deleted file mode 100644
index 630cf02..0000000
--- a/src/EPMS/Harmonic_Filter/Harmonic_Guard_RTU_PHXA7/README.md
+++ /dev/null
@@ -1,35 +0,0 @@
-# EQUIPMENT_TYPE MANUFACTURER MODEL RTU
-
-## Brief Introduction
-Equipment specifc details that make it different from other devices
-
-## List of Equipmentt
-This cofiguration has been used for these models:
-* **Model**: 09-15-22 
-* **Model**: 09-15-23 
-* **Model**: 09-15-25 
-
-## Hardware Prerequisites
-
-The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities and at least one hardware serial port for RS485 communication.
-
-* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html) 
-* **RS485 Transceiver**: [RS485 Shield for Arduino.](https://www.dfrobot.com/product-1024.html)
-
----
-
-## States and Strategies
-Provide a brief description of what variables and strategies were used in this configuraiton
-
-### Standby State
-* **Equipment running**: set to 0
-* **Common Alarm**: set to 0
-* **SAT temperature**: set to 85
-
-### Running State
-* **Equipment running**: set to 1
-* **SAT temperature**: **Ramp Strategy** set to 65 deg setpoint
-
-### Fail State
-* **Commong Alarm**: set to 1
-* **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset
diff --git a/src/EPMS/Harmonic_Filter/Harmonic_Guard_RTU_PHXA7/State_Fail.cpp b/src/EPMS/Harmonic_Filter/Harmonic_Guard_RTU_PHXA7/State_Fail.cpp
deleted file mode 100644
index 6d85f9a..0000000
--- a/src/EPMS/Harmonic_Filter/Harmonic_Guard_RTU_PHXA7/State_Fail.cpp
+++ /dev/null
@@ -1,77 +0,0 @@
-/**
- * @file State_Fail.cpp
- * @brief Implementation of the FailState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the FailState, which defines
- * the behavior of the equipment when it has entered a fault condition.
- */
-#include "States/State_Standby.h"
-#include "States/State_Fail.h"
-#include "ModbusPoints/Modbus_Point.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_PID.h"
-
-#include <vector>
-#include <string>
-
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new FailState object.
- *
- * This constructor receives a list of alarm descriptions and creates strategies
- * to set the corresponding Modbus points to a value of 1, indicating an
- * active alarm. It also initializes a PID strategy for the valve position.
- */
-template<>
-FailState<ModbusRTU>::FailState(const std::vector<std::string>& activeAlarms) {
-    // Simulate a failure: set common alarm and a specific fan alarm.
-}
-
-/**
- * @brief Executes the fail state's logic for one update cycle.
- *
- * This method checks the "Clear Alm" Modbus point for a command to transition
- * back to Standby, which would typically happen after a fault is cleared by a
- * user. If no transition is requested, it continues to apply the failure strategies.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusRTU>* FailState<ModbusRTU>::update(Equipment<ModbusRTU>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Fail update function");
-    
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the fail state. Sets the main alarm bit.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusRTU>::enterState(Equipment<ModbusRTU>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Fail State...");
-    
-}
-
-/**
- * @brief Logic to execute once when exiting the fail state. Clears the main alarm bit.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusRTU>::exitState(Equipment<ModbusRTU>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Fail State...");
-    
-}
\ No newline at end of file
diff --git a/src/EPMS/Harmonic_Filter/Harmonic_Guard_RTU_PHXA7/State_Running.cpp b/src/EPMS/Harmonic_Filter/Harmonic_Guard_RTU_PHXA7/State_Running.cpp
deleted file mode 100644
index 4299d0b..0000000
--- a/src/EPMS/Harmonic_Filter/Harmonic_Guard_RTU_PHXA7/State_Running.cpp
+++ /dev/null
@@ -1,89 +0,0 @@
-/**
- * @file State_Running.cpp
- * @brief Implementation of the RunningState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the RunningState, which defines
- * the behavior of the equipment when it is actively running.
- */
-
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "Strategies/Strategy_Behavior.h"
-#include "Strategies/Strategy_PID.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Totalizer.h"
-#include "Equipment/Equipment.h"
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-
-#include <vector>
-#include <string>
-
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new RunningState object.
- *
- * This constructor initializes behavior strategies active during the running
- * state, such as a PID controller for the 'CW Valve Position' and totalizers
- * for the run-hours of each EC fan.
- */
-template<>
-RunningState<ModbusRTU>::RunningState() {
-    //Add strategies 
-    //addStrategy("Actual Capacity", new PIDStrategy("Active SP", 1000, "Supply Temp"));
-    
-}
-
-/**
- * @brief Executes the running state's logic for one update cycle.
- *
- * This method first checks for state transition commands:
- * 1. It reads the "ON/OFF Command By BMS" point. If it's 0, it transitions to StandbyState.
- * 2. It reads the "Fault Code" point. If it's non-zero, it transitions to FailState,
- *    passing the corresponding alarm description.
- *
- * If no transition occurs, it applies the strategies defined for the running state.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusRTU>* RunningState<ModbusRTU>::update(Equipment<ModbusRTU>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Running update function");
-    
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the running state.
- * Sets the "Chiller Sts" point to indicate the unit is running.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusRTU>::enterState(Equipment<ModbusRTU>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Running State...");
-    
-}
-
-/**
- * @brief Logic to execute once when exiting the running state.
- * Sets the "Chiller Sts" point to indicate the unit is no longer running.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusRTU>::exitState(Equipment<ModbusRTU>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Running State...");
-}
\ No newline at end of file
diff --git a/src/EPMS/Harmonic_Filter/Harmonic_Guard_RTU_PHXA7/State_Standby.cpp b/src/EPMS/Harmonic_Filter/Harmonic_Guard_RTU_PHXA7/State_Standby.cpp
deleted file mode 100644
index 1d4dfef..0000000
--- a/src/EPMS/Harmonic_Filter/Harmonic_Guard_RTU_PHXA7/State_Standby.cpp
+++ /dev/null
@@ -1,136 +0,0 @@
-/**
- * @file State_Standby.cpp
- * @brief Implementation of the StandbyState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the StandbyState, which defines
- * the behavior of the equipment when it is in an idle or standby mode.
- */
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new StandbyState object.
- *
- * In this state, the equipment is idle. This constructor initializes several
- * strategies to generate random values for various status points, simulating
- * a live but non-operational unit.
- */
-template<>
-StandbyState<ModbusRTU>::StandbyState() {
-  addStrategy("V_LINE_AB_THD", new SingleValueStrategy(50.0f, 5.0f, 1000));
-  addStrategy("V_LINE_BC_THD", new SingleValueStrategy(50.0f, 5.0f, 1000));
-  addStrategy("V_LINE_CA_THD", new SingleValueStrategy(50.0f, 5.0f, 1000));
-  addStrategy("I_LINE_A_THD", new SingleValueStrategy(50.0f, 5.0f, 1000));
-  addStrategy("I_LINE_B_THD", new SingleValueStrategy(50.0f, 5.0f, 1000));
-  addStrategy("I_LINE_C_THD", new SingleValueStrategy(50.0f, 5.0f, 1000));
-  addStrategy("I_LINE_A_TDD", new SingleValueStrategy(50.0f, 5.0f, 1000));
-  addStrategy("I_LINE_B_TDD", new SingleValueStrategy(50.0f, 5.0f, 1000));
-  addStrategy("I_LINE_C_TDD", new SingleValueStrategy(50.0f, 5.0f, 1000));
-  addStrategy("V_LOAD_AB_THD", new SingleValueStrategy(50.0f, 5.0f, 1000));
-  addStrategy("V_LOAD_BC_THD", new SingleValueStrategy(50.0f, 5.0f, 1000));
-  addStrategy("V_LOAD_CA_THD", new SingleValueStrategy(50.0f, 5.0f, 1000));
-  addStrategy("I_LOAD_AB_THD", new SingleValueStrategy(50.0f, 5.0f, 1000));
-  addStrategy("I_LOAD_BC_THD", new SingleValueStrategy(50.0f, 5.0f, 1000));
-  addStrategy("I_LOAD_CA_THD", new SingleValueStrategy(50.0f, 5.0f, 1000));
-  addStrategy("V_TUNE_AB_THD", new SingleValueStrategy(50.0f, 5.0f, 1000));
-  addStrategy("V_TUNE_BC_THD", new SingleValueStrategy(50.0f, 5.0f, 1000));
-  addStrategy("V_TUNE_CA_THD", new SingleValueStrategy(50.0f, 5.0f, 1000));
-  addStrategy("I_TUNE_A_THD", new SingleValueStrategy(50.0f, 5.0f, 1000));
-  addStrategy("I_TUNE_B_THD", new SingleValueStrategy(50.0f, 5.0f, 1000));
-  addStrategy("I_TUNE_C_THD", new SingleValueStrategy(50.0f, 5.0f, 1000));
-  addStrategy("P_LINE_APPARENT_TOTAL", new SingleValueStrategy(5000.0f, 50.0f, 1000));
-  addStrategy("P_LINE_REAL_TOTAL", new SingleValueStrategy(5000.0f, 50.0f, 1000));
-  addStrategy("P_LINE_REACTIVE_TOTAL", new SingleValueStrategy(5000.0f, 50.0f, 1000));
-  addStrategy("P_LINE_POWER_FACTOR", new SingleValueStrategy(80.0f, 5.0f, 1000));
-  addStrategy("P_LOAD_APPARENT_TOTAL", new SingleValueStrategy(5000.0f, 50.0f, 1000));
-  addStrategy("P_LOAD_REAL_TOTAL", new SingleValueStrategy(5000.0f, 50.0f, 1000));
-  addStrategy("P_LOAD_REACTIVE_TOTAL", new SingleValueStrategy(5000.0f, 50.0f, 1000));
-  addStrategy("P_LOAD_POWER_FACTOR", new SingleValueStrategy(80.0f, 5.0f, 1000));
-  addStrategy("P_LOAD_REAL_MEAS", new SingleValueStrategy(5000.0f, 50.0f, 1000));
-  addStrategy("I_LINE_A_HARM_1", new SingleValueStrategy(55.0f, 5.0f, 1000));
-  addStrategy("I_LINE_A_HARM_3", new SingleValueStrategy(50.0f, 5.0f, 1000));
-  addStrategy("I_LINE_A_HARM_5", new SingleValueStrategy(45.0f, 5.0f, 1000));
-  addStrategy("I_LINE_A_HARM_7", new SingleValueStrategy(40.0f, 5.0f, 1000));
-  addStrategy("I_LINE_A_HARM_11", new SingleValueStrategy(35.0f, 5.0f, 1000));
-  addStrategy("I_LINE_A_HARM_13", new SingleValueStrategy(30.0f, 5.0f, 1000));
-  addStrategy("I_LINE_A_HARM_17", new SingleValueStrategy(25.0f, 5.0f, 1000));
-  addStrategy("I_LINE_A_HARM_19", new SingleValueStrategy(20.0f, 5.0f, 1000));
-  addStrategy("I_LINE_A_HARM_23", new SingleValueStrategy(15.0f, 5.0f, 1000));
-  addStrategy("I_LINE_A_HARM_25", new SingleValueStrategy(10.0f, 5.0f, 1000));
-  addStrategy("I_LINE_B_HARM_1", new SingleValueStrategy(55.0f, 5.0f, 1000));
-  addStrategy("I_LINE_B_HARM_3", new SingleValueStrategy(50.0f, 5.0f, 1000));
-  addStrategy("I_LINE_B_HARM_5", new SingleValueStrategy(45.0f, 5.0f, 1000));
-  addStrategy("I_LINE_B_HARM_7", new SingleValueStrategy(40.0f, 5.0f, 1000));
-  addStrategy("I_LINE_B_HARM_11", new SingleValueStrategy(35.0f, 5.0f, 1000));
-  addStrategy("I_LINE_B_HARM_13", new SingleValueStrategy(30.0f, 5.0f, 1000));
-  addStrategy("I_LINE_B_HARM_17", new SingleValueStrategy(25.0f, 5.0f, 1000));
-  addStrategy("I_LINE_B_HARM_19", new SingleValueStrategy(20.0f, 5.0f, 1000));
-  addStrategy("I_LINE_B_HARM_23", new SingleValueStrategy(15.0f, 5.0f, 1000));
-  addStrategy("I_LINE_B_HARM_25", new SingleValueStrategy(10.0f, 5.0f, 1000));
-  addStrategy("I_LINE_C_HARM_1", new SingleValueStrategy(55.0f, 5.0f, 1000));
-  addStrategy("I_LINE_C_HARM_3", new SingleValueStrategy(50.0f, 5.0f, 1000));
-  addStrategy("I_LINE_C_HARM_5", new SingleValueStrategy(45.0f, 5.0f, 1000));
-  addStrategy("I_LINE_C_HARM_7", new SingleValueStrategy(40.0f, 5.0f, 1000));
-  addStrategy("I_LINE_C_HARM_11", new SingleValueStrategy(35.0f, 5.0f, 1000));
-  addStrategy("I_LINE_C_HARM_13", new SingleValueStrategy(30.0f, 5.0f, 1000));
-  addStrategy("I_LINE_C_HARM_17", new SingleValueStrategy(25.0f, 5.0f, 1000));
-  addStrategy("I_LINE_C_HARM_19", new SingleValueStrategy(20.0f, 5.0f, 1000));
-  addStrategy("I_LINE_C_HARM_23", new SingleValueStrategy(15.0f, 5.0f, 1000));
-  addStrategy("I_LINE_C_HARM_25", new SingleValueStrategy(10.0f, 5.0f, 1000));
-}
-
-/**
- * @brief Executes the standby state's logic for one update cycle.
- *
- * This method checks the "Chiller On-Off" Modbus point for a command to
- * transition to the Running state. If no transition is requested, it applies
- * the strategies defined for the standby state.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusRTU>* StandbyState<ModbusRTU>::update(Equipment<ModbusRTU>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Standby update function");
-    
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the standby state.
- * Sets the "Chiller Sts" point to indicate the unit is not running.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusRTU>::enterState(Equipment<ModbusRTU>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Standby State...");
-   
-}
-
-/**
- * @brief Logic to execute once when exiting the standby state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusRTU>::exitState(Equipment<ModbusRTU>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-   
-}
\ No newline at end of file
diff --git a/src/EPMS/Harmonic_Filter/Harmonic_Guard_RTU_PHXA7/config.h b/src/EPMS/Harmonic_Filter/Harmonic_Guard_RTU_PHXA7/config.h
deleted file mode 100644
index 86defb5..0000000
--- a/src/EPMS/Harmonic_Filter/Harmonic_Guard_RTU_PHXA7/config.h
+++ /dev/null
@@ -1,142 +0,0 @@
-/**
- * @file config.h
- * @brief Main configuration file for the Daikin Chiller (RTU) emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * This file contains important configurations for the Modbus RTU communication
- * and the specific register map for the emulated device.
- */
-
-#ifndef CONFIG_H
-#define CONFIG_H
-#include <ModbusRTU.h>
-#include "core.h"
-#include "Equipment/Equipment.h"
-
-
-#if defined(USE_MODBUS_IP)
-/**
-   * @defgroup ModbusTCPConfig Modbus IP Configuration
-   * @brief Parameters for Modbus TCP communication.
-   * @{
-   */
-  #include <ModbusIP_ESP8266.h>
-  const char *ssid = "wifi_name";       /**< @brief The SSID of the WiFi network. */
-  const char *password = "wifi_password";   /**< @brief The password for the WiFi network. */
-  IPAddress local_IP(192, 168, 1, 234);       /**< @brief The static IP address for the device. */
-  IPAddress gateway(192, 168, 1, 1);          /**< @brief The gateway IP address. */
-  IPAddress subnet(255, 255, 255, 0);         /**< @brief The subnet mask. */
-  
-  ModbusIP mb;
-#else
-  /**
-   * @defgroup ModbusRTUConfig Modbus RTU Configuration
-   * @brief Parameters for serial Modbus RTU communication.
-   * @{
-   */
-  #include <ModbusRTU.h>
-  const int BAUDRATE = 9600;   /**< @brief The serial communication speed in bits per second. */
-  const int RX_PIN = 17;        /**< @brief The GPIO pin used for receiving data (RX). */
-  const int TX_PIN = 16;        /**< @brief The GPIO pin used for transmitting data (TX). */
-  const int RST_PIN = 4;        /**< @brief The GPIO pin connected to the RS485 driver's DE/RE pins for direction control. */
-  const int MODBUS_ID = 1;      /**< @brief The unique slave ID for this device on the Modbus bus. */
-  /** @} */
-
-  /** @brief Global instance of the Modbus RTU server. */
-  ModbusRTU mb;
-#endif
-
-/**
- * @brief The Modbus map for the Equipment device.
- * This array defines all the Modbus points available on the emulated device.
- * The `description` field is crucial as it's used to look up points within the application logic.
- */
-modbusMap mb_map[] =
-{   
-  {HR,        32,    0,  "V_LINE_AB_THD"},
-  {HR,        33,    0,  "V_LINE_BC_THD"},
-  {HR,        34,    0,  "V_LINE_CA_THD"},
-  {HR,        38,    0,  "I_LINE_A_THD"},
-  {HR,        39,    0,  "I_LINE_B_THD"},
-  {HR,        40,    0,  "I_LINE_C_THD"},
-  {HR,        41,    0,  "I_LINE_A_TDD"},
-  {HR,        42,    0,  "I_LINE_B_TDD"},
-  {HR,        43,    0,  "I_LINE_C_TDD"},
-  {HR,        52,    0,  "V_LOAD_AB_THD"},
-  {HR,        53,    0,  "V_LOAD_BC_THD"},
-  {HR,        54,    0,  "V_LOAD_CA_THD"},
-  {HR,        58,    0,  "I_LOAD_A_THD"},
-  {HR,        59,    0,  "I_LOAD_B_THD"},
-  {HR,        60,    0,  "I_LOAD_C_THD"},
-  {HR,        72,    0,  "V_TUNE_AB_THD"},
-  {HR,        73,    0,  "V_TUNE_BC_THD"},
-  {HR,        74,    0,  "V_TUNE_CA_THD"},
-  {HR,        78,    0,  "I_TUNE_A_THD"},
-  {HR,        79,    0,  "I_TUNE_B_THD"},
-  {HR,        80,    0,  "I_TUNE_C_THD"},
-  {HR,        99,    0,  "P_LINE_APPARENT_TOTAL"},
-  {HR,        100,    0,  "P_LINE_REAL_TOTAL"},
-  {HR,        102,    0,  "P_LINE_REACTIVE_TOTAL"},
-  {HR,        103,    0,  "P_LINE_POWER_FACTOR"},
-  {HR,        119,    0,  "P_LOAD_APPARENT_TOTAL"},
-  {HR,        120,    0,  "P_LOAD_REAL_TOTAL"},
-  {HR,        121,    0,  "P_LOAD_REACTIVE_TOTAL"},
-  {HR,        122,    0,  "P_LOAD_POWER_FACTOR"},
-  {HR,        123,    0,  "P_LOAD_REAL_MEAS"},
-  {HR,        139,    0,  "I_LINE_A_HARM_1"},
-  {HR,        140,    0,  "I_LINE_A_HARM_3"},
-  {HR,        141,    0,  "I_LINE_A_HARM_5"},
-  {HR,        142,    0,  "I_LINE_A_HARM_7"},
-  {HR,        143,    0,  "I_LINE_A_HARM_11"},
-  {HR,        144,    0,  "I_LINE_A_HARM_13"},
-  {HR,        145,    0,  "I_LINE_A_HARM_17"},
-  {HR,        146,    0,  "I_LINE_A_HARM_19"},
-  {HR,        147,    0,  "I_LINE_A_HARM_23"},
-  {HR,        148,    0,  "I_LINE_A_HARM_25"},
-  {HR,        159,    0,  "I_LINE_B_HARM_1"},
-  {HR,        160,    0,  "I_LINE_B_HARM_3"},
-  {HR,        161,    0,  "I_LINE_B_HARM_5"},
-  {HR,        162,    0,  "I_LINE_B_HARM_7"},
-  {HR,        163,    0,  "I_LINE_B_HARM_11"},
-  {HR,        164,    0,  "I_LINE_B_HARM_13"},
-  {HR,        165,    0,  "I_LINE_B_HARM_17"},
-  {HR,        166,    0,  "I_LINE_B_HARM_19"},
-  {HR,        167,    0,  "I_LINE_B_HARM_23"},
-  {HR,        168,    0,  "I_LINE_B_HARM_25"},
-  {HR,        179,    0,  "I_LINE_C_HARM_1"},
-  {HR,        180,    0,  "I_LINE_C_HARM_3"},
-  {HR,        181,    0,  "I_LINE_C_HARM_5"},
-  {HR,        182,    0,  "I_LINE_C_HARM_7"},
-  {HR,        183,    0,  "I_LINE_C_HARM_11"},
-  {HR,        184,    0,  "I_LINE_C_HARM_13"},
-  {HR,        185,    0,  "I_LINE_C_HARM_17"},
-  {HR,        186,    0,  "I_LINE_C_HARM_19"},
-  {HR,        187,    0,  "I_LINE_C_HARM_23"},
-  {HR,        188,    0,  "I_LINE_C_HARM_25"},
-  {HR,        199,    0,  "CNT_OPENED"},
-  {HR,        200,    0,  "SYS_POWER_ON"},
-  {HR,        201,    0,  "SYS_STATUS_OK"},
-  {HR,        202,    0,  "SYS_AT_CAPACITY"},
-  {HR,        203,    0,  "T_AMBIENT"},
-  {HR,        209,    0,  "Alm_group_1"},
-  {HR,        210,    0,  "Alm_group_2"},
-  {HR,        211,    0,  "Alm_group_3"},
-  {HR,        249,    0,  "SYS_CONTROL_MODE"},
-  {HR,        250,    0,  "TRACE_GO_DONE"},
-  {HR,        255,    0,  "SYS_STATE"},
-};                     
- 
-//Size of modbus map used in FOR cycles, automatically calculated.
-/**
- * @brief The total number of entries in the `mb_map` array.
- * This is calculated at compile time and used for iterating over the map.
- */
-const int map_size = sizeof(mb_map) / sizeof(mb_map[0]);
-
-/**
- * @brief The main loop update interval in milliseconds.
- */
-int interval = 250; 
-
-#endif // CONFIG_H
diff --git a/src/EPMS/Harmonic_Filter/Harmonic_Guard_RTU_PHXA7/main.cpp b/src/EPMS/Harmonic_Filter/Harmonic_Guard_RTU_PHXA7/main.cpp
deleted file mode 100644
index 5dbc9f1..0000000
--- a/src/EPMS/Harmonic_Filter/Harmonic_Guard_RTU_PHXA7/main.cpp
+++ /dev/null
@@ -1,78 +0,0 @@
-/**
- * @file main.cpp
- * @brief Main execution program for the Daikin Chiller (RTU) Emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * @details This file contains the main execution program for an Arduino-based
- * emulator of a Daikin Chiller unit. The program communicates via the
- * Modbus RTU protocol over a serial connection.
- *
- * The setup() function initializes the following:
- * - Serial communication for debugging.
- * - A Modbus RTU server with parameters from config.h.
- * - Modbus points (Coils, Holding Registers, etc.) based on a predefined map in config.h.
- *
- * The loop() function continuously:
- * - Services the Modbus RTU server to handle incoming requests.
- * - Periodically calls the main update loop for the emulated equipment, which
- *   manages state transitions and behavior strategies.
- *
- * @see config.h for Modbus RTU and register map configuration.
- * @see Equipment.h for the main equipment logic.
- * @see State.h for different equipment states.
- * @see Strategies/Strategy_Behavior.h for value generation strategies.
- * @see Modbus_Point.h for the base class for all Modbus points.
- */
-//=================================================================================================================================
-//Libraries and declaration of variables.
-#include <Arduino.h>
-#include "config.h"
-#include "ModbusPoints/Modbus_PointFactory.h"
-
-//=================================================================================================================================
-/** 
- * @brief Initializes the application.
- * @details This function runs once at startup. It configures the serial communication
- * for debugging and the Modbus RTU server. It then creates and initializes all
- * the Modbus points based on the `mb_map` array in `config.h`.
- */
-const int rtsPin = 4;
-void setup() {
-  Serial.begin(115200);
-  Serial.println("Setup function started");
-
-  Serial2.begin(BAUDRATE, SERIAL_8N1, RX_PIN, TX_PIN);
-  mb.begin(&Serial2, RST_PIN); // Start the server
-  mb.slave(MODBUS_ID); // Set the slave ID
-   
-  for(int i = 0; i < map_size; i++){
-    Modbus_Point<ModbusRTU>* point = createModbus_Point(&mb, mb_map[i].category, mb_map[i].address, mb_map[i].value, mb_map[i].description);
-    if (point) {
-      point->addToModbusServer();
-      EquipmentInstance.addModbus_Point(mb_map[i].description, point);
-    }
-  }
-  Serial.println("Setup function ended"); 
-}
-//=================================================================================================================================
-/** 
- * @brief The main application loop.
- * @details This function runs repeatedly after setup() has completed. It performs two main actions:
- * 1. It continuously services the Modbus server by calling `mb.task()` to handle
- *    incoming requests from a Modbus master.
- * 2. At a fixed interval (defined in `config.h`), it calls `EquipmentInstance.update()`
- *    to run the emulator's internal state machine and behavior logic.
- */
-void loop() {
-  mb.task();
-  unsigned long currentMillis = millis();
-  if (currentMillis - previousMillis >= interval) {
-    previousMillis = currentMillis;
-    unsigned long startTime = millis();
-    EquipmentInstance.update();
-    unsigned long endTime = millis();
-    unsigned long elapsedTime = endTime - startTime;
-    Serial.printf("Control Execution time: %d ms\n", elapsedTime);
-  } 
-}
diff --git a/src/EPMS/MVG/MVG_SC_EC_M505_TCP/README.md b/src/EPMS/MVG/MVG_SC_EC_M505_TCP/README.md
deleted file mode 100644
index 4f156e3..0000000
--- a/src/EPMS/MVG/MVG_SC_EC_M505_TCP/README.md
+++ /dev/null
@@ -1,48 +0,0 @@
-# Daikin Chiller (RTU) Emulator
-
-This project is an Arduino-based emulator for a Daikin Chiller unit, communicating over Modbus RTU. It is designed to be a flexible template that can be adapted to simulate different types of chillers by modifying the configuration and state logic.
-
-The emulator operates on a state machine with three core states:
-* **Standby**: The chiller is idle but ready.
-* **Running**: The chiller is active and operational.
-* **Fail**: The chiller has encountered a fault condition.
-
-## Features
-
-* **Modbus RTU Communication**: Emulates a Modbus slave device.
-* **State Machine Logic**: Simulates different operational states (Standby, Running, Fail).
-* **Dynamic Value Simulation**: Uses "Strategies" (e.g., PID, Ramp) to generate realistic, changing values for Modbus points.
-* **Configurable Modbus Map**: The entire Modbus register map is defined in a single, easy-to-modify file (`config.h`).
-* **Extensible Design**: The structure allows for the addition of new states and behaviors.
-
-## Hardware Prerequisites
-
-The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities and at least one hardware serial port for RS485 communication.
-
-* **Microcontroller**: ESP8266, ESP32, or similar.
-* **RS485 Transceiver**: A module like the MAX485 to interface with the Modbus RTU bus.
-
-## Software Dependencies
-
-This project relies on a Modbus library. Ensure you have the correct library installed in your Arduino IDE.
-
-* **Modbus Library**: The code uses a library that provides `ModbusRTU.h` and optionally `ModbusIP_ESP8266.h`.
-
----
-
-## How to Customize for a New Chiller
-
-To adapt this template for a new chiller, follow these steps.
-
-### 1. Configure Device-Specific Parameters (`config.h`)
-
-Open `CH_Daikin_AWV026B_RTU/config.h`. This is the main file for device-specific settings.
-
-#### Modbus RTU Settings
-Update the following constants for your device's serial communication setup.
-```c++
-const int BAUDRATE = 19200;   // The serial communication speed
-const int RX_PIN = 17;        // The GPIO pin for receiving data (RX)
-const int TX_PIN = 16;        // The GPIO pin for transmitting data (TX)
-const int RST_PIN = 4;        // The GPIO pin for RS485 direction control
-const int MODBUS_ID = 1;      // The unique slave ID for this device
\ No newline at end of file
diff --git a/src/EPMS/MVG/MVG_SC_EC_M505_TCP/State_Fail.cpp b/src/EPMS/MVG/MVG_SC_EC_M505_TCP/State_Fail.cpp
deleted file mode 100644
index 8bc0385..0000000
--- a/src/EPMS/MVG/MVG_SC_EC_M505_TCP/State_Fail.cpp
+++ /dev/null
@@ -1,81 +0,0 @@
-/**
- * @file State_Fail.cpp
- * @brief Implementation of the FailState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the FailState, which defines
- * the behavior of the equipment when it has entered a fault condition.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new FailState object with a list of active alarms.
- *
- * This constructor receives a list of alarm descriptions and creates strategies
- * to set the corresponding Modbus points to a value of 1, indicating an
- * active alarm. It also initializes a PID strategy for the 'CW Valve Position'
- * to maintain its state during the fault.
- * @param activeAlarms A vector of strings, where each string is the
- *                     description of a Modbus point to be set as an active alarm.
- */
-template<>
-FailState<ModbusIP>::FailState(const std::vector<std::string>& activeAlarms) {
-    // Simulate a failure: set common alarm and a specific fan alarm.
-
-    
-}
-
-/**
- * @brief Executes the fail state's logic for one update cycle.
- *
- * This method checks the "Alarm Reset" Modbus point for a command to
- * transition back to Standby, which would typically happen after a fault
- * is cleared by a user. If no transition is requested, it continues to apply
- * the failure strategies (e.g., keeping alarm bits active).
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* FailState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Fail update function");
-    
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the fail state.
- * Sets the "Alarm Common" point to 1 to indicate a general fault condition.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Fail State...");
-}
-
-/**
- * @brief Logic to execute once when exiting the fail state.
- * Clears the "Alarm Common" point to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Fail State...");
-}
\ No newline at end of file
diff --git a/src/EPMS/MVG/MVG_SC_EC_M505_TCP/State_Running.cpp b/src/EPMS/MVG/MVG_SC_EC_M505_TCP/State_Running.cpp
deleted file mode 100644
index f3faa44..0000000
--- a/src/EPMS/MVG/MVG_SC_EC_M505_TCP/State_Running.cpp
+++ /dev/null
@@ -1,271 +0,0 @@
-/**
- * @file State_Running.cpp
- * @brief Implementation of the RunningState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the RunningState, which defines
- * the behavior of the equipment when it is actively running.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "Strategies/Strategy_Totalizer.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new RunningState object.
- *
- * This constructor initializes behavior strategies active during the running
- * state, such as a PID controller for the 'CW Valve Position' and totalizers
- * for the run-hours of each EC fan.
- */
-template<>
-RunningState<ModbusIP>::RunningState() {
-
-}
-
-/**
- * @brief Executes the running state's logic for one update cycle.
- *
- * This method first checks for state transition commands:
- * 1. It reads the "ON/OFF Command By BMS" point. If it's 0, it transitions to StandbyState.
- * 2. It reads the "Fault Code" point. If it's non-zero, it transitions to FailState,
- *    passing the corresponding alarm description.
- *
- * If no transition occurs, it applies the strategies defined for the running state.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* RunningState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Running update function");
-    float StateCtrl = getPointValue(equipment, "Px_Mode");
-    if (StateCtrl == 1.0f) {
-      return new StandbyState<ModbusIP>();
-    }
-
-    float W1 = getPointValue(equipment, "Px_W1");
-    float W2 = getPointValue(equipment, "Px_W2");
-    float W3 = getPointValue(equipment, "Px_W3");
-    float W4 = getPointValue(equipment, "Px_W4");
-    float W5 = getPointValue(equipment, "Px_W5");
-    float W6 = getPointValue(equipment, "Px_W6");
-    // Apply any strategies defined for the standby state
-
-    switch (static_cast<int>(W1)){
-      case 0:
-        setBitValue(equipment, "MVG_STS_01", 0, false);
-        setBitValue(equipment, "MVG_STS_01", 1, false);
-        setBitValue(equipment, "MVG_STS_01", 2, false);
-        break;
-      case 1:
-        setBitValue(equipment, "MVG_STS_01", 0, true);
-        setBitValue(equipment, "MVG_STS_01", 1, false);
-        setBitValue(equipment, "MVG_STS_01", 2, false);
-        break;
-      case 2:
-        setBitValue(equipment, "MVG_STS_01", 0, false);
-        setBitValue(equipment, "MVG_STS_01", 1, true);
-        setBitValue(equipment, "MVG_STS_01", 2, false);
-        break;
-      case 3:
-        setBitValue(equipment, "MVG_STS_01", 0, true);
-        setBitValue(equipment, "MVG_STS_01", 1, false);
-        setBitValue(equipment, "MVG_STS_01", 2, true);
-        break;
-      default:
-        setBitValue(equipment, "MVG_STS_01", 0, false);
-        setBitValue(equipment, "MVG_STS_01", 1, false);
-        setBitValue(equipment, "MVG_STS_01", 2, false);
-        break;
-    }
-
-    switch (static_cast<int>(W2)){
-      case 0:
-        setBitValue(equipment, "MVG_STS_01", 3, false);
-        setBitValue(equipment, "MVG_STS_01", 4, false);
-        setBitValue(equipment, "MVG_STS_01", 5, false);
-        break;
-      case 1:
-        setBitValue(equipment, "MVG_STS_01", 3, true);
-        setBitValue(equipment, "MVG_STS_01", 4, false);
-        setBitValue(equipment, "MVG_STS_01", 5, false);
-        break;
-      case 2:
-        setBitValue(equipment, "MVG_STS_01", 3, false);
-        setBitValue(equipment, "MVG_STS_01", 4, true);
-        setBitValue(equipment, "MVG_STS_01", 5, false);
-        break;
-      case 3:
-        setBitValue(equipment, "MVG_STS_01", 3, true);
-        setBitValue(equipment, "MVG_STS_01", 4, false);
-        setBitValue(equipment, "MVG_STS_01", 5, true);
-        break;
-      default:
-        setBitValue(equipment, "MVG_STS_01", 3, false);
-        setBitValue(equipment, "MVG_STS_01", 4, false);
-        setBitValue(equipment, "MVG_STS_01", 5, false);
-        break;
-    }
-
-    switch (static_cast<int>(W3)){
-      case 0:
-        setBitValue(equipment, "MVG_STS_01", 6, false);
-        setBitValue(equipment, "MVG_STS_01", 7, false);
-        setBitValue(equipment, "MVG_STS_02", 0, false);
-        break;
-      case 1:
-        setBitValue(equipment, "MVG_STS_01", 6, true);
-        setBitValue(equipment, "MVG_STS_01", 7, false);
-        setBitValue(equipment, "MVG_STS_02", 0, false);
-        break;
-      case 2:
-        setBitValue(equipment, "MVG_STS_01", 6, false);
-        setBitValue(equipment, "MVG_STS_01", 7, true);
-        setBitValue(equipment, "MVG_STS_02", 0, false);
-        break;
-      case 3:
-        setBitValue(equipment, "MVG_STS_01", 6, true);
-        setBitValue(equipment, "MVG_STS_01", 7, false);
-        setBitValue(equipment, "MVG_STS_02", 0, true);
-        break;
-      default:
-        setBitValue(equipment, "MVG_STS_01", 6, false);
-        setBitValue(equipment, "MVG_STS_01", 7, false);
-        setBitValue(equipment, "MVG_STS_02", 0, false);
-        break;
-    }
-
-    switch (static_cast<int>(W4)){
-      case 0:
-        setBitValue(equipment, "MVG_STS_02", 1, false);
-        setBitValue(equipment, "MVG_STS_02", 2, false);
-        setBitValue(equipment, "MVG_STS_02", 3, false);
-        break;
-      case 1:
-        setBitValue(equipment, "MVG_STS_02", 1, true);
-        setBitValue(equipment, "MVG_STS_02", 2, false);
-        setBitValue(equipment, "MVG_STS_02", 3, false);
-        break;
-      case 2:
-        setBitValue(equipment, "MVG_STS_02", 1, false);
-        setBitValue(equipment, "MVG_STS_02", 2, true);
-        setBitValue(equipment, "MVG_STS_02", 3, false);
-        break;
-      case 3:
-        setBitValue(equipment, "MVG_STS_02", 1, true);
-        setBitValue(equipment, "MVG_STS_02", 2, false);
-        setBitValue(equipment, "MVG_STS_02", 3, true);
-        break;
-      default:
-        setBitValue(equipment, "MVG_STS_02", 1, false);
-        setBitValue(equipment, "MVG_STS_02", 2, false);
-        setBitValue(equipment, "MVG_STS_02", 3, false);
-        break;
-    }
-
-    switch (static_cast<int>(W5)){
-      case 0:
-        setBitValue(equipment, "MVG_STS_02", 4, false);
-        setBitValue(equipment, "MVG_STS_02", 5, false);
-        setBitValue(equipment, "MVG_STS_02", 6, false);
-        break;
-      case 1:
-        setBitValue(equipment, "MVG_STS_02", 4, true);
-        setBitValue(equipment, "MVG_STS_02", 5, false);
-        setBitValue(equipment, "MVG_STS_02", 6, false);
-        break;
-      case 2:
-        setBitValue(equipment, "MVG_STS_02", 4, false);
-        setBitValue(equipment, "MVG_STS_02", 5, true);
-        setBitValue(equipment, "MVG_STS_02", 6, false);
-        break;
-      case 3:
-        setBitValue(equipment, "MVG_STS_02", 4, true);
-        setBitValue(equipment, "MVG_STS_02", 5, false);
-        setBitValue(equipment, "MVG_STS_02", 6, true);
-        break;
-      default:
-        setBitValue(equipment, "MVG_STS_02", 4, false);
-        setBitValue(equipment, "MVG_STS_02", 5, false);
-        setBitValue(equipment, "MVG_STS_02", 6, false);
-        break;
-    }
-
-    switch (static_cast<int>(W6)){
-      case 0:
-        setBitValue(equipment, "MVG_STS_02", 7, false);
-        setBitValue(equipment, "MVG_STS_03", 0, false);
-        setBitValue(equipment, "MVG_STS_03", 1, false);
-        break;
-      case 1:
-        setBitValue(equipment, "MVG_STS_02", 7, true);
-        setBitValue(equipment, "MVG_STS_03", 0, false);
-        setBitValue(equipment, "MVG_STS_03", 1, false);
-        break;
-      case 2:
-        setBitValue(equipment, "MVG_STS_02", 7, false);
-        setBitValue(equipment, "MVG_STS_03", 0, true);
-        setBitValue(equipment, "MVG_STS_03", 1, false);
-        break;
-      case 3:
-        setBitValue(equipment, "MVG_STS_02", 7, true);
-        setBitValue(equipment, "MVG_STS_03", 0, false);
-        setBitValue(equipment, "MVG_STS_03", 1, true);
-        break;
-      default:
-        setBitValue(equipment, "MVG_STS_02", 7, false);
-        setBitValue(equipment, "MVG_STS_03", 0, false);
-        setBitValue(equipment, "MVG_STS_03", 1, false);
-        break;
-    }
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the running state.
- * Sets the "Run Status" for all EC fans to 1 to indicate they are active.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Running State...");
-    // You could also update a Modbus register to show the "standby" state
-    
-}
-
-/**
- * @brief Logic to execute once when exiting the running state.
- * Sets the "Run Status" for all EC fans to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Running State...");
-    setPointValue(equipment, "MVG_STS_01", 0);
-    setPointValue(equipment, "MVG_STS_02", 0);
-    setPointValue(equipment, "MVG_STS_03", 0);
-   
-}
\ No newline at end of file
diff --git a/src/EPMS/MVG/MVG_SC_EC_M505_TCP/State_Standby.cpp b/src/EPMS/MVG/MVG_SC_EC_M505_TCP/State_Standby.cpp
deleted file mode 100644
index 6dad7d4..0000000
--- a/src/EPMS/MVG/MVG_SC_EC_M505_TCP/State_Standby.cpp
+++ /dev/null
@@ -1,88 +0,0 @@
-/**
- * @file State_Standby.cpp
- * @brief Implementation of the StandbyState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the StandbyState, which defines
- * the behavior of the equipment when it is in an idle or standby mode.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-/**
- * @brief Constructs a new StandbyState object.
- *
- * In this state, the equipment is idle. This constructor initializes strategies
- * to bring the system to a safe, idle condition. It sets a stable value for
- * the SAT reading and creates ramp strategies to bring the CW valve and all
- * EC fan speeds down to zero.
- */
-template<>
-StandbyState<ModbusIP>::StandbyState() {
-    // You can add initialization code here if needed
-  
-}
-
-/**
- * @brief Executes the standby state's logic for one update cycle.
- *
- * This method applies the strategies defined for the standby state (e.g.,
- * ramping values to zero).
- *
- * @warning This method currently does not check for a command to transition to the
- *          Running state. This logic needs to be added to allow the unit to start.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* StandbyState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Standby update function");
-    float StateCtrl = getPointValue(equipment, "Px_Mode");
-    if (StateCtrl == 2.0f) {
-      return new RunningState<ModbusIP>();
-    }
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the standby state.
- * This method performs cleanup by setting all alarm points and all EC fan
- * run status points to 0.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Standby State...");
-
-    
-    
-}
-/**
- * @brief Logic to execute once when exiting the standby state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Standby State...");
-}
\ No newline at end of file
diff --git a/src/EPMS/MVG/MVG_SC_EC_M505_TCP/config.h b/src/EPMS/MVG/MVG_SC_EC_M505_TCP/config.h
deleted file mode 100644
index 3be4ccc..0000000
--- a/src/EPMS/MVG/MVG_SC_EC_M505_TCP/config.h
+++ /dev/null
@@ -1,86 +0,0 @@
-/**
- * @file config.h
- * @brief Main configuration file for the CRAH Unit (TCP) emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * This file contains two important configurations: WiFi network parameters
- * and the Modbus register map for the device.
- */
-
-#ifndef CONFIG_H
-#define CONFIG_H
-
-#include "core.h"
-#include "Equipment/Equipment.h"
-
-#if defined(USE_MODBUS_IP)
-/**
-   * @defgroup ModbusTCPConfig Modbus IP Configuration
-   * @brief Parameters for Modbus TCP communication.
-   * @{
-   */
-  #include <ModbusIP_ESP8266.h>
-  const char *ssid = "ArduinoWifiB";       /**< @brief The SSID of the WiFi network. */
-  const char *password = "123abc456";   /**< @brief The password for the WiFi network. */
-  IPAddress local_IP(172, 17, 32, 82);       /**< @brief The static IP address for the device. */
-  IPAddress gateway(172, 17, 32, 1);          /**< @brief The gateway IP address. */
-  IPAddress subnet(255, 255, 255, 0);         /**< @brief The subnet mask. */
-  
-  ModbusIP mb;
-#else
-  /**
-   * @defgroup ModbusRTUConfig Modbus RTU Configuration
-   * @brief Parameters for serial Modbus RTU communication.
-   * @{
-   */
-  #include <ModbusRTU.h>
-  const int BAUDRATE = 19200;   /**< @brief The serial communication speed in bits per second. */
-  const int RX_PIN = 17;        /**< @brief The GPIO pin used for receiving data (RX). */
-  const int TX_PIN = 16;        /**< @brief The GPIO pin used for transmitting data (TX). */
-  const int RST_PIN = 4;        /**< @brief The GPIO pin connected to the RS485 driver's DE/RE pins for direction control. */
-  const int MODBUS_ID = 1;      /**< @brief The unique slave ID for this device on the Modbus bus. */
-  /** @} */
-
-  /** @brief Global instance of the Modbus RTU server. */
-  ModbusRTU mb;
-#endif
-
-
-
-/**
- * @defgroup ModbusMapConfig Modbus Map Configuration
- * @brief Defines the Modbus register map and related parameters for the emulator.
- * @{
- */
-/**
- * @brief The Modbus map for the Equipment device.
- * This array defines all the Modbus points available on the emulated device.
- * The `description` field is crucial as it's used to look up points within the application logic.
- */
-modbusMap mb_map[] =
-{   
-  {HR,           9,    0,  "Px_Mode"},
-  {HR,          10,    0,  "Px_W1"},
-  {HR,          11,    0,  "Px_W2"},
-  {HR,          12,    0,  "Px_W3"},
-  {HR,          13,    0,  "Px_W4"},
-  {HR,          14,    0,  "Px_W5"},
-  {HR,          15,    0,  "Px_W6"},
-  {HR,        1049,    0,  "MVG_STS_01"},
-  {HR,        1050,    0,  "MVG_STS_02"},
-  {HR,        1051,    0,  "MVG_STS_03"},
-};
-//Size of modbus map used in FOR cycles, automatically calculated.
-
-/**
- * @brief The total number of entries in the `mb_map` array.
- * This is calculated at compile time and used for iterating over the map.
- */
-const int map_size = sizeof(mb_map) / sizeof(mb_map[0]);
-
-/** @brief The main loop update interval in milliseconds. */
-int interval = 250; 
-/** @} */ // End of ModbusMapConfig group
-
-#endif // CONFIG_H
diff --git a/src/EPMS/MVG/MVG_SC_EC_M505_TCP/main.cpp b/src/EPMS/MVG/MVG_SC_EC_M505_TCP/main.cpp
deleted file mode 100644
index 286a98c..0000000
--- a/src/EPMS/MVG/MVG_SC_EC_M505_TCP/main.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-/**
- * @file main.cpp
- * @brief Main execution program for the CRAH Unit (TCP) Emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * @details This file contains the main execution program for an Arduino-based emulator of a CRAH unit. 
- * The program uses a Wi-Fi connection to communicate via the Modbus IP protocol.
- *
- * The setup() function initializes the following:
- * - Serial communication for debugging.
- * - Wi-Fi connection using credentials from config.h.
- * - A Modbus TCP server.
- * - Modbus points (Coils, Holding Registers, etc.) based on a predefined map in config.h.
- *
- * The loop() function continuously:
- * - Services the Modbus TCP server to handle incoming requests.
- * - Periodically calls the main update loop for the emulated equipment, which
- *   manages state transitions and behavior strategies.
- *
- * @see config.h for Wi-Fi and Modbus configuration.
- * @see Equipment.h for the main equipment logic.
- * @see State.h for different equipment states.
- * @see Strategies/Strategy_Behavior.h for value generation strategies.
- * @see Modbus_Point.h for the base class for all Modbus points.
- */
-//=================================================================================================================================
-//Libraries and declaration of variables.
-#include <WiFi.h>
-#include "config.h"
-#include "ModbusPoints/Modbus_PointFactory.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-//=================================================================================================================================
-/** 
- * @brief Initializes the application.
- * @details This function runs once at startup. It configures the serial communication, 
- * Wi-Fi, and the Modbus server. It also creates and initializes all the Modbus points 
- * based on the `mb_map` array in `config.h`.
- */
-void setup() {
-  Serial.begin(115200);                       //Serial comm start
-  WiFi.config(local_IP, gateway, subnet);     // Wifi service start
-  WiFi.begin(ssid, password);
-  while (WiFi.status() != WL_CONNECTED) {
-    delay(1000);
-    Serial.print(".");
-  }
-  Serial.println("Connected!!");
-  mb.server();                                //Modbus server start
-  Serial.println("Server Created");
-  Serial.println(map_size);
-  for(int i = 0; i < map_size; i++){
-    Modbus_Point<ModbusIP>* point = createModbus_Point(&mb, mb_map[i].category, mb_map[i].address, mb_map[i].value, mb_map[i].description);
-    if (point) {
-      point->addToModbusServer();
-      EquipmentInstance.addModbus_Point(mb_map[i].description, point);
-    }
-  }
-  Serial.println("All modbus Points created");
-  Serial.println("Setup function ended");
-}
-//=================================================================================================================================
-/** 
- * @brief The main application loop.
- * @details This function runs repeatedly after setup() has completed. It performs two main actions:
- * 1. It continuously services the Modbus server by calling `mb.task()` to handle
- *    incoming requests from a Modbus master.
- * 2. At a fixed interval (defined in `config.h`), it calls `EquipmentInstance.update()`
- *    to run the emulator's internal state machine and behavior logic.
- */
-void loop() {
-  mb.task();
-  unsigned long currentMillis = millis();
-  if (currentMillis - previousMillis >= interval) {
-    previousMillis = currentMillis;
-    unsigned long startTime = millis();
-    EquipmentInstance.update();
-    unsigned long endTime = millis();
-    unsigned long elapsedTime = endTime - startTime;
-    Serial.printf("Control Execution time: %d ms\n", elapsedTime);
-  } 
-}
diff --git a/src/EPMS/MVG/MVG_SEL2440_TCP/README.md b/src/EPMS/MVG/MVG_SEL2440_TCP/README.md
deleted file mode 100644
index 355156f..0000000
--- a/src/EPMS/MVG/MVG_SEL2440_TCP/README.md
+++ /dev/null
@@ -1,33 +0,0 @@
-# EQUIPMENT_TYPE MANUFACTURER MODEL TCP
-
-## Brief Introduction
-Equipment specifc details that make it different from other devices
-
-## List of Equipmentt
-This cofiguration has been used for these models:
-* **Model**: 09-15-22 
-* **Model**: 09-15-23 
-* **Model**: 09-15-25 
-
-## Hardware Prerequisites
-
-The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities.
-* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html) 
-
----
-
-## States and Strategies
-Provide a brief description of what variables and strategies were used in this configuraiton
-
-### Standby State
-* **Equipment running**: set to 0
-* **Common Alarm**: set to 0
-* **SAT temperature**: set to 85
-
-### Running State
-* **Equipment running**: set to 1
-* **SAT temperature**: **Ramp Strategy** set to 65 deg setpoint
-
-### Fail State
-* **Commong Alarm**: set to 1
-* **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset
diff --git a/src/EPMS/MVG/MVG_SEL2440_TCP/State_Fail.cpp b/src/EPMS/MVG/MVG_SEL2440_TCP/State_Fail.cpp
deleted file mode 100644
index 8bc0385..0000000
--- a/src/EPMS/MVG/MVG_SEL2440_TCP/State_Fail.cpp
+++ /dev/null
@@ -1,81 +0,0 @@
-/**
- * @file State_Fail.cpp
- * @brief Implementation of the FailState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the FailState, which defines
- * the behavior of the equipment when it has entered a fault condition.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new FailState object with a list of active alarms.
- *
- * This constructor receives a list of alarm descriptions and creates strategies
- * to set the corresponding Modbus points to a value of 1, indicating an
- * active alarm. It also initializes a PID strategy for the 'CW Valve Position'
- * to maintain its state during the fault.
- * @param activeAlarms A vector of strings, where each string is the
- *                     description of a Modbus point to be set as an active alarm.
- */
-template<>
-FailState<ModbusIP>::FailState(const std::vector<std::string>& activeAlarms) {
-    // Simulate a failure: set common alarm and a specific fan alarm.
-
-    
-}
-
-/**
- * @brief Executes the fail state's logic for one update cycle.
- *
- * This method checks the "Alarm Reset" Modbus point for a command to
- * transition back to Standby, which would typically happen after a fault
- * is cleared by a user. If no transition is requested, it continues to apply
- * the failure strategies (e.g., keeping alarm bits active).
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* FailState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Fail update function");
-    
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the fail state.
- * Sets the "Alarm Common" point to 1 to indicate a general fault condition.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Fail State...");
-}
-
-/**
- * @brief Logic to execute once when exiting the fail state.
- * Clears the "Alarm Common" point to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Fail State...");
-}
\ No newline at end of file
diff --git a/src/EPMS/MVG/MVG_SEL2440_TCP/State_Running.cpp b/src/EPMS/MVG/MVG_SEL2440_TCP/State_Running.cpp
deleted file mode 100644
index b9e4a99..0000000
--- a/src/EPMS/MVG/MVG_SEL2440_TCP/State_Running.cpp
+++ /dev/null
@@ -1,89 +0,0 @@
-/**
- * @file State_Running.cpp
- * @brief Implementation of the RunningState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the RunningState, which defines
- * the behavior of the equipment when it is actively running.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "Strategies/Strategy_Totalizer.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new RunningState object.
- *
- * This constructor initializes behavior strategies active during the running
- * state, such as a PID controller for the 'CW Valve Position' and totalizers
- * for the run-hours of each EC fan.
- */
-template<>
-RunningState<ModbusIP>::RunningState() {
-}
-
-/**
- * @brief Executes the running state's logic for one update cycle.
- *
- * This method first checks for state transition commands:
- * 1. It reads the "ON/OFF Command By BMS" point. If it's 0, it transitions to StandbyState.
- * 2. It reads the "Fault Code" point. If it's non-zero, it transitions to FailState,
- *    passing the corresponding alarm description.
- *
- * If no transition occurs, it applies the strategies defined for the running state.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* RunningState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Running update function");
-    
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the running state.
- * Sets the "Run Status" for all EC fans to 1 to indicate they are active.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Running State...");
-    // You could also update a Modbus register to show the "standby" state
-
-}
-
-/**
- * @brief Logic to execute once when exiting the running state.
- * Sets the "Run Status" for all EC fans to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Running State...");
-   
-}
\ No newline at end of file
diff --git a/src/EPMS/MVG/MVG_SEL2440_TCP/State_Standby.cpp b/src/EPMS/MVG/MVG_SEL2440_TCP/State_Standby.cpp
deleted file mode 100644
index 20029d1..0000000
--- a/src/EPMS/MVG/MVG_SEL2440_TCP/State_Standby.cpp
+++ /dev/null
@@ -1,85 +0,0 @@
-/**
- * @file State_Standby.cpp
- * @brief Implementation of the StandbyState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the StandbyState, which defines
- * the behavior of the equipment when it is in an idle or standby mode.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-/**
- * @brief Constructs a new StandbyState object.
- *
- * In this state, the equipment is idle. This constructor initializes strategies
- * to bring the system to a safe, idle condition. It sets a stable value for
- * the SAT reading and creates ramp strategies to bring the CW valve and all
- * EC fan speeds down to zero.
- */
-template<>
-StandbyState<ModbusIP>::StandbyState() {
-    // You can add initialization code here if needed
-    
-
-}
-
-/**
- * @brief Executes the standby state's logic for one update cycle.
- *
- * This method applies the strategies defined for the standby state (e.g.,
- * ramping values to zero).
- *
- * @warning This method currently does not check for a command to transition to the
- *          Running state. This logic needs to be added to allow the unit to start.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* StandbyState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Standby update function");
-    
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the standby state.
- * This method performs cleanup by setting all alarm points and all EC fan
- * run status points to 0.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Standby State...");
-}
-
-/**
- * @brief Logic to execute once when exiting the standby state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Standby State...");
-}
\ No newline at end of file
diff --git a/src/EPMS/MVG/MVG_SEL2440_TCP/config.h b/src/EPMS/MVG/MVG_SEL2440_TCP/config.h
deleted file mode 100644
index 461d904..0000000
--- a/src/EPMS/MVG/MVG_SEL2440_TCP/config.h
+++ /dev/null
@@ -1,112 +0,0 @@
-/**
- * @file config.h
- * @brief Main configuration file for the MVG SEL 2440
- * @author Zach Gutierrez
- * @date 2025-09-02
- *
- * This file contains two important configurations: WiFi network parameters
- * and the Modbus register map for the device.
- */
-
-#ifndef CONFIG_H
-#define CONFIG_H
-
-#include "core.h"
-#include "Equipment/Equipment.h"
-
-#if defined(USE_MODBUS_IP)
-/**
-   * @defgroup ModbusTCPConfig Modbus IP Configuration
-   * @brief Parameters for Modbus TCP communication.
-   * @{
-   */
-  #include <ModbusIP_ESP8266.h>
-  const char *ssid = "wifi_name";       /**< @brief The SSID of the WiFi network. */
-  const char *password = "wifi_password";   /**< @brief The password for the WiFi network. */
-  IPAddress local_IP(192, 168, 1, 234);       /**< @brief The static IP address for the device. */
-  IPAddress gateway(192, 168, 1, 1);          /**< @brief The gateway IP address. */
-  IPAddress subnet(255, 255, 255, 0);         /**< @brief The subnet mask. */
-  
-  ModbusIP mb;
-#else
-  /**
-   * @defgroup ModbusRTUConfig Modbus RTU Configuration
-   * @brief Parameters for serial Modbus RTU communication.
-   * @{
-   */
-  #include <ModbusRTU.h>
-  const int BAUDRATE = 19200;   /**< @brief The serial communication speed in bits per second. */
-  const int RX_PIN = 17;        /**< @brief The GPIO pin used for receiving data (RX). */
-  const int TX_PIN = 16;        /**< @brief The GPIO pin used for transmitting data (TX). */
-  const int RST_PIN = 4;        /**< @brief The GPIO pin connected to the RS485 driver's DE/RE pins for direction control. */
-  const int MODBUS_ID = 1;      /**< @brief The unique slave ID for this device on the Modbus bus. */
-  /** @} */
-
-  /** @brief Global instance of the Modbus RTU server. */
-  ModbusRTU mb;
-#endif
-
-
-
-/**
- * @defgroup ModbusMapConfig Modbus Map Configuration
- * @brief Defines the Modbus register map and related parameters for the emulator.
- * @{
- */
-/**
- * @brief The Modbus map for the Equipment device.
- * This array defines all the Modbus points available on the emulated device.
- * The `description` field is crucial as it's used to look up points within the application logic.
- */
-modbusMap mb_map[] = {
-  // ESP8266 Modbus server uses 0-based addressing, while Modbus Poll uses 1-based addressing.
-  // Convert from ESP8266 to traditional Modbus addressing: subtract 30001/40001.
-  {IR, 548, 0, "Way2_Grounded" },  // 300549.0 Way2_Grounded
-  {IR, 548, 0, "Way2_Open" },      // 300549.1 Way2_Open
-  {IR, 548, 0, "Way2_Closed" },    // 300549.2 Way2_Closed
-  {IR, 548, 0, "Way1_Tripped" },   // 300549.3 Way1_Tripped
-  {IR, 548, 0, "Way1_Grounded" },  // 300549.4 Way1_Grounded
-  {IR, 548, 0, "Way1_Open" },      // 300549.5 Way1_Open
-  {IR, 548, 0, "Way1_Closed" },    // 300549.6 Way1_Closed
-  {IR, 548, 0, "Tank_Pressure" },  // 300549.7 Tank_Pressure
-  {IR, 549, 0, "Way2_Tripped" },   // 300550.0 Way2_Tripped
-  {IR, 549, 0, "Way4_Open" },      // 300550.1 Way4_Open
-  {IR, 549, 0, "Way4_Closed" },    // 300550.2 Way4_Closed
-  {IR, 549, 0, "Way3_Tripped" },   // 300550.4 Way3_Tripped
-  {IR, 549, 0, "Way3_Open" },      // 300550.5 Way3_Open
-  {IR, 549, 0, "Way3_Closed" },    // 300550.6 Way3_Closed
-  {IR, 550, 0, "Way5_Tripped" },   // 300551.3 Way5_Tripped
-  {IR, 550, 0, "Way5_Grounded" },  // 300551.4 Way5_Grounded
-  {IR, 550, 0, "Way5_Open" },      // 300551.5 Way5_Open
-  {IR, 550, 0, "Way5_Closed" },    // 300551.6 Way5_Closed
-  {IR, 550, 0, "Way4_Tripped" },   // 300551.7 Way4_Tripped
-  {HR, 350, 0, "Amps_A" },    // 40351 Amps_A
-  {HR, 354, 0, "Amps_C" },    // 40355 Amps_C
-  {HR, 352, 0, "Amps_B" },    // 40353 Amps_B
-  {HR, 372, 0, "kVA" },       // 40373 kVA
-  {HR, 358, 0, "Volts_AN" },  // 40359 Volts_AN
-  {HR, 366, 0, "Volts_BC" },  // 40367 Volts_BC
-  {HR, 362, 0, "Volts_CN" },  // 40363 Volts_CN
-  {HR, 910, 0, "PF" },        // 40911 PF
-  {HR, 900, 0, "Freq" },      // 40901 Freq
-  {HR, 600, 0, "kWh" },       // 40601 kWh
-  {HR, 364, 0, "Volts_AB" },  // 40365 Volts_AB
-  {HR, 360, 0, "Volts_BN" },  // 40361 Volts_BN
-  {HR, 356, 0, "Amps_N" },    // 40357 Amps_N
-  {HR, 368, 0, "Volts_CA" },  // 40369 Volts_CA
-  {HR, 370, 0, "kW" }         // 40371 kW
-
-};
-//Size of modbus map used in FOR cycles, automatically calculated.
-
-/**
- * @brief The total number of entries in the `mb_map` array.
- * This is calculated at compile time and used for iterating over the map.
- */
-const int map_size = sizeof(mb_map) / sizeof(mb_map[0]);
-
-/** @brief The main loop update interval in milliseconds. */
-int interval = 250; 
-/** @} */ // End of ModbusMapConfig group
-
-#endif // CONFIG_H
diff --git a/src/EPMS/MVG/MVG_SEL2440_TCP/main.cpp b/src/EPMS/MVG/MVG_SEL2440_TCP/main.cpp
deleted file mode 100644
index 286a98c..0000000
--- a/src/EPMS/MVG/MVG_SEL2440_TCP/main.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-/**
- * @file main.cpp
- * @brief Main execution program for the CRAH Unit (TCP) Emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * @details This file contains the main execution program for an Arduino-based emulator of a CRAH unit. 
- * The program uses a Wi-Fi connection to communicate via the Modbus IP protocol.
- *
- * The setup() function initializes the following:
- * - Serial communication for debugging.
- * - Wi-Fi connection using credentials from config.h.
- * - A Modbus TCP server.
- * - Modbus points (Coils, Holding Registers, etc.) based on a predefined map in config.h.
- *
- * The loop() function continuously:
- * - Services the Modbus TCP server to handle incoming requests.
- * - Periodically calls the main update loop for the emulated equipment, which
- *   manages state transitions and behavior strategies.
- *
- * @see config.h for Wi-Fi and Modbus configuration.
- * @see Equipment.h for the main equipment logic.
- * @see State.h for different equipment states.
- * @see Strategies/Strategy_Behavior.h for value generation strategies.
- * @see Modbus_Point.h for the base class for all Modbus points.
- */
-//=================================================================================================================================
-//Libraries and declaration of variables.
-#include <WiFi.h>
-#include "config.h"
-#include "ModbusPoints/Modbus_PointFactory.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-//=================================================================================================================================
-/** 
- * @brief Initializes the application.
- * @details This function runs once at startup. It configures the serial communication, 
- * Wi-Fi, and the Modbus server. It also creates and initializes all the Modbus points 
- * based on the `mb_map` array in `config.h`.
- */
-void setup() {
-  Serial.begin(115200);                       //Serial comm start
-  WiFi.config(local_IP, gateway, subnet);     // Wifi service start
-  WiFi.begin(ssid, password);
-  while (WiFi.status() != WL_CONNECTED) {
-    delay(1000);
-    Serial.print(".");
-  }
-  Serial.println("Connected!!");
-  mb.server();                                //Modbus server start
-  Serial.println("Server Created");
-  Serial.println(map_size);
-  for(int i = 0; i < map_size; i++){
-    Modbus_Point<ModbusIP>* point = createModbus_Point(&mb, mb_map[i].category, mb_map[i].address, mb_map[i].value, mb_map[i].description);
-    if (point) {
-      point->addToModbusServer();
-      EquipmentInstance.addModbus_Point(mb_map[i].description, point);
-    }
-  }
-  Serial.println("All modbus Points created");
-  Serial.println("Setup function ended");
-}
-//=================================================================================================================================
-/** 
- * @brief The main application loop.
- * @details This function runs repeatedly after setup() has completed. It performs two main actions:
- * 1. It continuously services the Modbus server by calling `mb.task()` to handle
- *    incoming requests from a Modbus master.
- * 2. At a fixed interval (defined in `config.h`), it calls `EquipmentInstance.update()`
- *    to run the emulator's internal state machine and behavior logic.
- */
-void loop() {
-  mb.task();
-  unsigned long currentMillis = millis();
-  if (currentMillis - previousMillis >= interval) {
-    previousMillis = currentMillis;
-    unsigned long startTime = millis();
-    EquipmentInstance.update();
-    unsigned long endTime = millis();
-    unsigned long elapsedTime = endTime - startTime;
-    Serial.printf("Control Execution time: %d ms\n", elapsedTime);
-  } 
-}
diff --git a/src/EPMS/MVG/SEL_2440_MVG/README.md b/src/EPMS/MVG/SEL_2440_MVG/README.md
deleted file mode 100644
index 4f156e3..0000000
--- a/src/EPMS/MVG/SEL_2440_MVG/README.md
+++ /dev/null
@@ -1,48 +0,0 @@
-# Daikin Chiller (RTU) Emulator
-
-This project is an Arduino-based emulator for a Daikin Chiller unit, communicating over Modbus RTU. It is designed to be a flexible template that can be adapted to simulate different types of chillers by modifying the configuration and state logic.
-
-The emulator operates on a state machine with three core states:
-* **Standby**: The chiller is idle but ready.
-* **Running**: The chiller is active and operational.
-* **Fail**: The chiller has encountered a fault condition.
-
-## Features
-
-* **Modbus RTU Communication**: Emulates a Modbus slave device.
-* **State Machine Logic**: Simulates different operational states (Standby, Running, Fail).
-* **Dynamic Value Simulation**: Uses "Strategies" (e.g., PID, Ramp) to generate realistic, changing values for Modbus points.
-* **Configurable Modbus Map**: The entire Modbus register map is defined in a single, easy-to-modify file (`config.h`).
-* **Extensible Design**: The structure allows for the addition of new states and behaviors.
-
-## Hardware Prerequisites
-
-The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities and at least one hardware serial port for RS485 communication.
-
-* **Microcontroller**: ESP8266, ESP32, or similar.
-* **RS485 Transceiver**: A module like the MAX485 to interface with the Modbus RTU bus.
-
-## Software Dependencies
-
-This project relies on a Modbus library. Ensure you have the correct library installed in your Arduino IDE.
-
-* **Modbus Library**: The code uses a library that provides `ModbusRTU.h` and optionally `ModbusIP_ESP8266.h`.
-
----
-
-## How to Customize for a New Chiller
-
-To adapt this template for a new chiller, follow these steps.
-
-### 1. Configure Device-Specific Parameters (`config.h`)
-
-Open `CH_Daikin_AWV026B_RTU/config.h`. This is the main file for device-specific settings.
-
-#### Modbus RTU Settings
-Update the following constants for your device's serial communication setup.
-```c++
-const int BAUDRATE = 19200;   // The serial communication speed
-const int RX_PIN = 17;        // The GPIO pin for receiving data (RX)
-const int TX_PIN = 16;        // The GPIO pin for transmitting data (TX)
-const int RST_PIN = 4;        // The GPIO pin for RS485 direction control
-const int MODBUS_ID = 1;      // The unique slave ID for this device
\ No newline at end of file
diff --git a/src/EPMS/MVG/SEL_2440_MVG/State_Fail.cpp b/src/EPMS/MVG/SEL_2440_MVG/State_Fail.cpp
deleted file mode 100644
index 8bc0385..0000000
--- a/src/EPMS/MVG/SEL_2440_MVG/State_Fail.cpp
+++ /dev/null
@@ -1,81 +0,0 @@
-/**
- * @file State_Fail.cpp
- * @brief Implementation of the FailState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the FailState, which defines
- * the behavior of the equipment when it has entered a fault condition.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new FailState object with a list of active alarms.
- *
- * This constructor receives a list of alarm descriptions and creates strategies
- * to set the corresponding Modbus points to a value of 1, indicating an
- * active alarm. It also initializes a PID strategy for the 'CW Valve Position'
- * to maintain its state during the fault.
- * @param activeAlarms A vector of strings, where each string is the
- *                     description of a Modbus point to be set as an active alarm.
- */
-template<>
-FailState<ModbusIP>::FailState(const std::vector<std::string>& activeAlarms) {
-    // Simulate a failure: set common alarm and a specific fan alarm.
-
-    
-}
-
-/**
- * @brief Executes the fail state's logic for one update cycle.
- *
- * This method checks the "Alarm Reset" Modbus point for a command to
- * transition back to Standby, which would typically happen after a fault
- * is cleared by a user. If no transition is requested, it continues to apply
- * the failure strategies (e.g., keeping alarm bits active).
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* FailState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Fail update function");
-    
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the fail state.
- * Sets the "Alarm Common" point to 1 to indicate a general fault condition.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Fail State...");
-}
-
-/**
- * @brief Logic to execute once when exiting the fail state.
- * Clears the "Alarm Common" point to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Fail State...");
-}
\ No newline at end of file
diff --git a/src/EPMS/MVG/SEL_2440_MVG/State_Running.cpp b/src/EPMS/MVG/SEL_2440_MVG/State_Running.cpp
deleted file mode 100644
index b9e4a99..0000000
--- a/src/EPMS/MVG/SEL_2440_MVG/State_Running.cpp
+++ /dev/null
@@ -1,89 +0,0 @@
-/**
- * @file State_Running.cpp
- * @brief Implementation of the RunningState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the RunningState, which defines
- * the behavior of the equipment when it is actively running.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "Strategies/Strategy_Totalizer.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new RunningState object.
- *
- * This constructor initializes behavior strategies active during the running
- * state, such as a PID controller for the 'CW Valve Position' and totalizers
- * for the run-hours of each EC fan.
- */
-template<>
-RunningState<ModbusIP>::RunningState() {
-}
-
-/**
- * @brief Executes the running state's logic for one update cycle.
- *
- * This method first checks for state transition commands:
- * 1. It reads the "ON/OFF Command By BMS" point. If it's 0, it transitions to StandbyState.
- * 2. It reads the "Fault Code" point. If it's non-zero, it transitions to FailState,
- *    passing the corresponding alarm description.
- *
- * If no transition occurs, it applies the strategies defined for the running state.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* RunningState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Running update function");
-    
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the running state.
- * Sets the "Run Status" for all EC fans to 1 to indicate they are active.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Running State...");
-    // You could also update a Modbus register to show the "standby" state
-
-}
-
-/**
- * @brief Logic to execute once when exiting the running state.
- * Sets the "Run Status" for all EC fans to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Running State...");
-   
-}
\ No newline at end of file
diff --git a/src/EPMS/MVG/SEL_2440_MVG/State_Standby.cpp b/src/EPMS/MVG/SEL_2440_MVG/State_Standby.cpp
deleted file mode 100644
index 20029d1..0000000
--- a/src/EPMS/MVG/SEL_2440_MVG/State_Standby.cpp
+++ /dev/null
@@ -1,85 +0,0 @@
-/**
- * @file State_Standby.cpp
- * @brief Implementation of the StandbyState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the StandbyState, which defines
- * the behavior of the equipment when it is in an idle or standby mode.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-/**
- * @brief Constructs a new StandbyState object.
- *
- * In this state, the equipment is idle. This constructor initializes strategies
- * to bring the system to a safe, idle condition. It sets a stable value for
- * the SAT reading and creates ramp strategies to bring the CW valve and all
- * EC fan speeds down to zero.
- */
-template<>
-StandbyState<ModbusIP>::StandbyState() {
-    // You can add initialization code here if needed
-    
-
-}
-
-/**
- * @brief Executes the standby state's logic for one update cycle.
- *
- * This method applies the strategies defined for the standby state (e.g.,
- * ramping values to zero).
- *
- * @warning This method currently does not check for a command to transition to the
- *          Running state. This logic needs to be added to allow the unit to start.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* StandbyState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Standby update function");
-    
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the standby state.
- * This method performs cleanup by setting all alarm points and all EC fan
- * run status points to 0.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Standby State...");
-}
-
-/**
- * @brief Logic to execute once when exiting the standby state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Standby State...");
-}
\ No newline at end of file
diff --git a/src/EPMS/MVG/SEL_2440_MVG/config.h b/src/EPMS/MVG/SEL_2440_MVG/config.h
deleted file mode 100644
index 88714a4..0000000
--- a/src/EPMS/MVG/SEL_2440_MVG/config.h
+++ /dev/null
@@ -1,81 +0,0 @@
-/**
- * @file config.h
- * @brief Main configuration file for the CRAH Unit (TCP) emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * This file contains two important configurations: WiFi network parameters
- * and the Modbus register map for the device.
- */
-
-#ifndef CONFIG_H
-#define CONFIG_H
-
-#include "core.h"
-#include "Equipment/Equipment.h"
-
-#if defined(USE_MODBUS_IP)
-/**
-   * @defgroup ModbusTCPConfig Modbus IP Configuration
-   * @brief Parameters for Modbus TCP communication.
-   * @{
-   */
-  #include <ModbusIP_ESP8266.h>
-  const char *ssid = "ArduinoWifiB";       /**< @brief The SSID of the WiFi network. */
-  const char *password = "123abc456";   /**< @brief The password for the WiFi network. */
-  IPAddress local_IP(172, 17, 32, 88);       /**< @brief The static IP address for the device. */
-  IPAddress gateway(172, 17, 32, 1);          /**< @brief The gateway IP address. */
-  IPAddress subnet(255, 255, 255, 0);         /**< @brief The subnet mask. */
-  
-  ModbusIP mb;
-#else
-  /**
-   * @defgroup ModbusRTUConfig Modbus RTU Configuration
-   * @brief Parameters for serial Modbus RTU communication.
-   * @{
-   */
-  #include <ModbusRTU.h>
-  const int BAUDRATE = 19200;   /**< @brief The serial communication speed in bits per second. */
-  const int RX_PIN = 17;        /**< @brief The GPIO pin used for receiving data (RX). */
-  const int TX_PIN = 16;        /**< @brief The GPIO pin used for transmitting data (TX). */
-  const int RST_PIN = 4;        /**< @brief The GPIO pin connected to the RS485 driver's DE/RE pins for direction control. */
-  const int MODBUS_ID = 1;      /**< @brief The unique slave ID for this device on the Modbus bus. */
-  /** @} */
-
-  /** @brief Global instance of the Modbus RTU server. */
-  ModbusRTU mb;
-#endif
-
-
-
-/**
- * @defgroup ModbusMapConfig Modbus Map Configuration
- * @brief Defines the Modbus register map and related parameters for the emulator.
- * @{
- */
-/**
- * @brief The Modbus map for the Equipment device.
- * This array defines all the Modbus points available on the emulated device.
- * The `description` field is crucial as it's used to look up points within the application logic.
- */
-modbusMap mb_map[] =
-{   
-  {HR,        15,     0,  "State Control"},  //Internal to control from Modscan
-  {HR,        16,     0,  "Fault Code"},     //Internal Fault code from Modscan       
-  {HR,        549,   0,  "Word 1"},         
-  {HR,        550,   0,  "Word 2"},        
-  {HR,        551,   0,  "Word 3"},                            
-};
-//Size of modbus map used in FOR cycles, automatically calculated.
-
-/**
- * @brief The total number of entries in the `mb_map` array.
- * This is calculated at compile time and used for iterating over the map.
- */
-const int map_size = sizeof(mb_map) / sizeof(mb_map[0]);
-
-/** @brief The main loop update interval in milliseconds. */
-int interval = 250; 
-/** @} */ // End of ModbusMapConfig group
-
-#endif // CONFIG_H
diff --git a/src/EPMS/MVG/SEL_2440_MVG/main.cpp b/src/EPMS/MVG/SEL_2440_MVG/main.cpp
deleted file mode 100644
index 286a98c..0000000
--- a/src/EPMS/MVG/SEL_2440_MVG/main.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-/**
- * @file main.cpp
- * @brief Main execution program for the CRAH Unit (TCP) Emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * @details This file contains the main execution program for an Arduino-based emulator of a CRAH unit. 
- * The program uses a Wi-Fi connection to communicate via the Modbus IP protocol.
- *
- * The setup() function initializes the following:
- * - Serial communication for debugging.
- * - Wi-Fi connection using credentials from config.h.
- * - A Modbus TCP server.
- * - Modbus points (Coils, Holding Registers, etc.) based on a predefined map in config.h.
- *
- * The loop() function continuously:
- * - Services the Modbus TCP server to handle incoming requests.
- * - Periodically calls the main update loop for the emulated equipment, which
- *   manages state transitions and behavior strategies.
- *
- * @see config.h for Wi-Fi and Modbus configuration.
- * @see Equipment.h for the main equipment logic.
- * @see State.h for different equipment states.
- * @see Strategies/Strategy_Behavior.h for value generation strategies.
- * @see Modbus_Point.h for the base class for all Modbus points.
- */
-//=================================================================================================================================
-//Libraries and declaration of variables.
-#include <WiFi.h>
-#include "config.h"
-#include "ModbusPoints/Modbus_PointFactory.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-//=================================================================================================================================
-/** 
- * @brief Initializes the application.
- * @details This function runs once at startup. It configures the serial communication, 
- * Wi-Fi, and the Modbus server. It also creates and initializes all the Modbus points 
- * based on the `mb_map` array in `config.h`.
- */
-void setup() {
-  Serial.begin(115200);                       //Serial comm start
-  WiFi.config(local_IP, gateway, subnet);     // Wifi service start
-  WiFi.begin(ssid, password);
-  while (WiFi.status() != WL_CONNECTED) {
-    delay(1000);
-    Serial.print(".");
-  }
-  Serial.println("Connected!!");
-  mb.server();                                //Modbus server start
-  Serial.println("Server Created");
-  Serial.println(map_size);
-  for(int i = 0; i < map_size; i++){
-    Modbus_Point<ModbusIP>* point = createModbus_Point(&mb, mb_map[i].category, mb_map[i].address, mb_map[i].value, mb_map[i].description);
-    if (point) {
-      point->addToModbusServer();
-      EquipmentInstance.addModbus_Point(mb_map[i].description, point);
-    }
-  }
-  Serial.println("All modbus Points created");
-  Serial.println("Setup function ended");
-}
-//=================================================================================================================================
-/** 
- * @brief The main application loop.
- * @details This function runs repeatedly after setup() has completed. It performs two main actions:
- * 1. It continuously services the Modbus server by calling `mb.task()` to handle
- *    incoming requests from a Modbus master.
- * 2. At a fixed interval (defined in `config.h`), it calls `EquipmentInstance.update()`
- *    to run the emulator's internal state machine and behavior logic.
- */
-void loop() {
-  mb.task();
-  unsigned long currentMillis = millis();
-  if (currentMillis - previousMillis >= interval) {
-    previousMillis = currentMillis;
-    unsigned long startTime = millis();
-    EquipmentInstance.update();
-    unsigned long endTime = millis();
-    unsigned long elapsedTime = endTime - startTime;
-    Serial.printf("Control Execution time: %d ms\n", elapsedTime);
-  } 
-}
diff --git a/src/EPMS/MVG/SPSO_4523 (IMVG)/README.md b/src/EPMS/MVG/SPSO_4523 (IMVG)/README.md
deleted file mode 100644
index 4f156e3..0000000
--- a/src/EPMS/MVG/SPSO_4523 (IMVG)/README.md	
+++ /dev/null
@@ -1,48 +0,0 @@
-# Daikin Chiller (RTU) Emulator
-
-This project is an Arduino-based emulator for a Daikin Chiller unit, communicating over Modbus RTU. It is designed to be a flexible template that can be adapted to simulate different types of chillers by modifying the configuration and state logic.
-
-The emulator operates on a state machine with three core states:
-* **Standby**: The chiller is idle but ready.
-* **Running**: The chiller is active and operational.
-* **Fail**: The chiller has encountered a fault condition.
-
-## Features
-
-* **Modbus RTU Communication**: Emulates a Modbus slave device.
-* **State Machine Logic**: Simulates different operational states (Standby, Running, Fail).
-* **Dynamic Value Simulation**: Uses "Strategies" (e.g., PID, Ramp) to generate realistic, changing values for Modbus points.
-* **Configurable Modbus Map**: The entire Modbus register map is defined in a single, easy-to-modify file (`config.h`).
-* **Extensible Design**: The structure allows for the addition of new states and behaviors.
-
-## Hardware Prerequisites
-
-The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities and at least one hardware serial port for RS485 communication.
-
-* **Microcontroller**: ESP8266, ESP32, or similar.
-* **RS485 Transceiver**: A module like the MAX485 to interface with the Modbus RTU bus.
-
-## Software Dependencies
-
-This project relies on a Modbus library. Ensure you have the correct library installed in your Arduino IDE.
-
-* **Modbus Library**: The code uses a library that provides `ModbusRTU.h` and optionally `ModbusIP_ESP8266.h`.
-
----
-
-## How to Customize for a New Chiller
-
-To adapt this template for a new chiller, follow these steps.
-
-### 1. Configure Device-Specific Parameters (`config.h`)
-
-Open `CH_Daikin_AWV026B_RTU/config.h`. This is the main file for device-specific settings.
-
-#### Modbus RTU Settings
-Update the following constants for your device's serial communication setup.
-```c++
-const int BAUDRATE = 19200;   // The serial communication speed
-const int RX_PIN = 17;        // The GPIO pin for receiving data (RX)
-const int TX_PIN = 16;        // The GPIO pin for transmitting data (TX)
-const int RST_PIN = 4;        // The GPIO pin for RS485 direction control
-const int MODBUS_ID = 1;      // The unique slave ID for this device
\ No newline at end of file
diff --git a/src/EPMS/MVG/SPSO_4523 (IMVG)/State_Fail.cpp b/src/EPMS/MVG/SPSO_4523 (IMVG)/State_Fail.cpp
deleted file mode 100644
index 8bc0385..0000000
--- a/src/EPMS/MVG/SPSO_4523 (IMVG)/State_Fail.cpp	
+++ /dev/null
@@ -1,81 +0,0 @@
-/**
- * @file State_Fail.cpp
- * @brief Implementation of the FailState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the FailState, which defines
- * the behavior of the equipment when it has entered a fault condition.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new FailState object with a list of active alarms.
- *
- * This constructor receives a list of alarm descriptions and creates strategies
- * to set the corresponding Modbus points to a value of 1, indicating an
- * active alarm. It also initializes a PID strategy for the 'CW Valve Position'
- * to maintain its state during the fault.
- * @param activeAlarms A vector of strings, where each string is the
- *                     description of a Modbus point to be set as an active alarm.
- */
-template<>
-FailState<ModbusIP>::FailState(const std::vector<std::string>& activeAlarms) {
-    // Simulate a failure: set common alarm and a specific fan alarm.
-
-    
-}
-
-/**
- * @brief Executes the fail state's logic for one update cycle.
- *
- * This method checks the "Alarm Reset" Modbus point for a command to
- * transition back to Standby, which would typically happen after a fault
- * is cleared by a user. If no transition is requested, it continues to apply
- * the failure strategies (e.g., keeping alarm bits active).
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* FailState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Fail update function");
-    
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the fail state.
- * Sets the "Alarm Common" point to 1 to indicate a general fault condition.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Fail State...");
-}
-
-/**
- * @brief Logic to execute once when exiting the fail state.
- * Clears the "Alarm Common" point to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Fail State...");
-}
\ No newline at end of file
diff --git a/src/EPMS/MVG/SPSO_4523 (IMVG)/State_Running.cpp b/src/EPMS/MVG/SPSO_4523 (IMVG)/State_Running.cpp
deleted file mode 100644
index b9e4a99..0000000
--- a/src/EPMS/MVG/SPSO_4523 (IMVG)/State_Running.cpp	
+++ /dev/null
@@ -1,89 +0,0 @@
-/**
- * @file State_Running.cpp
- * @brief Implementation of the RunningState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the RunningState, which defines
- * the behavior of the equipment when it is actively running.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "Strategies/Strategy_Totalizer.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new RunningState object.
- *
- * This constructor initializes behavior strategies active during the running
- * state, such as a PID controller for the 'CW Valve Position' and totalizers
- * for the run-hours of each EC fan.
- */
-template<>
-RunningState<ModbusIP>::RunningState() {
-}
-
-/**
- * @brief Executes the running state's logic for one update cycle.
- *
- * This method first checks for state transition commands:
- * 1. It reads the "ON/OFF Command By BMS" point. If it's 0, it transitions to StandbyState.
- * 2. It reads the "Fault Code" point. If it's non-zero, it transitions to FailState,
- *    passing the corresponding alarm description.
- *
- * If no transition occurs, it applies the strategies defined for the running state.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* RunningState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Running update function");
-    
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the running state.
- * Sets the "Run Status" for all EC fans to 1 to indicate they are active.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Running State...");
-    // You could also update a Modbus register to show the "standby" state
-
-}
-
-/**
- * @brief Logic to execute once when exiting the running state.
- * Sets the "Run Status" for all EC fans to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Running State...");
-   
-}
\ No newline at end of file
diff --git a/src/EPMS/MVG/SPSO_4523 (IMVG)/State_Standby.cpp b/src/EPMS/MVG/SPSO_4523 (IMVG)/State_Standby.cpp
deleted file mode 100644
index 20029d1..0000000
--- a/src/EPMS/MVG/SPSO_4523 (IMVG)/State_Standby.cpp	
+++ /dev/null
@@ -1,85 +0,0 @@
-/**
- * @file State_Standby.cpp
- * @brief Implementation of the StandbyState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the StandbyState, which defines
- * the behavior of the equipment when it is in an idle or standby mode.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-/**
- * @brief Constructs a new StandbyState object.
- *
- * In this state, the equipment is idle. This constructor initializes strategies
- * to bring the system to a safe, idle condition. It sets a stable value for
- * the SAT reading and creates ramp strategies to bring the CW valve and all
- * EC fan speeds down to zero.
- */
-template<>
-StandbyState<ModbusIP>::StandbyState() {
-    // You can add initialization code here if needed
-    
-
-}
-
-/**
- * @brief Executes the standby state's logic for one update cycle.
- *
- * This method applies the strategies defined for the standby state (e.g.,
- * ramping values to zero).
- *
- * @warning This method currently does not check for a command to transition to the
- *          Running state. This logic needs to be added to allow the unit to start.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* StandbyState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Standby update function");
-    
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the standby state.
- * This method performs cleanup by setting all alarm points and all EC fan
- * run status points to 0.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Standby State...");
-}
-
-/**
- * @brief Logic to execute once when exiting the standby state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Standby State...");
-}
\ No newline at end of file
diff --git a/src/EPMS/MVG/SPSO_4523 (IMVG)/config.h b/src/EPMS/MVG/SPSO_4523 (IMVG)/config.h
deleted file mode 100644
index e4a6339..0000000
--- a/src/EPMS/MVG/SPSO_4523 (IMVG)/config.h	
+++ /dev/null
@@ -1,81 +0,0 @@
-/**
- * @file config.h
- * @brief Main configuration file for the CRAH Unit (TCP) emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * This file contains two important configurations: WiFi network parameters
- * and the Modbus register map for the device.
- */
-
-#ifndef CONFIG_H
-#define CONFIG_H
-
-#include "core.h"
-#include "Equipment/Equipment.h"
-
-#if defined(USE_MODBUS_IP)
-/**
-   * @defgroup ModbusTCPConfig Modbus IP Configuration
-   * @brief Parameters for Modbus TCP communication.
-   * @{
-   */
-  #include <ModbusIP_ESP8266.h>
-  const char *ssid = "wifi_name";       /**< @brief The SSID of the WiFi network. */
-  const char *password = "wifi_password";   /**< @brief The password for the WiFi network. */
-  IPAddress local_IP(192, 168, 1, 234);       /**< @brief The static IP address for the device. */
-  IPAddress gateway(192, 168, 1, 1);          /**< @brief The gateway IP address. */
-  IPAddress subnet(255, 255, 255, 0);         /**< @brief The subnet mask. */
-  
-  ModbusIP mb;
-#else
-  /**
-   * @defgroup ModbusRTUConfig Modbus RTU Configuration
-   * @brief Parameters for serial Modbus RTU communication.
-   * @{
-   */
-  #include <ModbusRTU.h>
-  const int BAUDRATE = 19200;   /**< @brief The serial communication speed in bits per second. */
-  const int RX_PIN = 17;        /**< @brief The GPIO pin used for receiving data (RX). */
-  const int TX_PIN = 16;        /**< @brief The GPIO pin used for transmitting data (TX). */
-  const int RST_PIN = 4;        /**< @brief The GPIO pin connected to the RS485 driver's DE/RE pins for direction control. */
-  const int MODBUS_ID = 1;      /**< @brief The unique slave ID for this device on the Modbus bus. */
-  /** @} */
-
-  /** @brief Global instance of the Modbus RTU server. */
-  ModbusRTU mb;
-#endif
-
-
-
-/**
- * @defgroup ModbusMapConfig Modbus Map Configuration
- * @brief Defines the Modbus register map and related parameters for the emulator.
- * @{
- */
-/**
- * @brief The Modbus map for the Equipment device.
- * This array defines all the Modbus points available on the emulated device.
- * The `description` field is crucial as it's used to look up points within the application logic.
- */
-modbusMap mb_map[] =
-{   
-  {HR,        15,     0,  "State Control"},  //Internal to control from Modscan
-  {HR,        16,     0,  "Fault Code"},     //Internal Fault code from Modscan       
-  {HR,        1050,   0,  "Word 1"},         
-  {HR,        1051,   0,  "Word 2"},        
-  {HR,        1052,   0,  "Word 3"},                            
-};
-//Size of modbus map used in FOR cycles, automatically calculated.
-
-/**
- * @brief The total number of entries in the `mb_map` array.
- * This is calculated at compile time and used for iterating over the map.
- */
-const int map_size = sizeof(mb_map) / sizeof(mb_map[0]);
-
-/** @brief The main loop update interval in milliseconds. */
-int interval = 250; 
-/** @} */ // End of ModbusMapConfig group
-
-#endif // CONFIG_H
diff --git a/src/EPMS/MVG/SPSO_4523 (IMVG)/main.cpp b/src/EPMS/MVG/SPSO_4523 (IMVG)/main.cpp
deleted file mode 100644
index 286a98c..0000000
--- a/src/EPMS/MVG/SPSO_4523 (IMVG)/main.cpp	
+++ /dev/null
@@ -1,86 +0,0 @@
-/**
- * @file main.cpp
- * @brief Main execution program for the CRAH Unit (TCP) Emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * @details This file contains the main execution program for an Arduino-based emulator of a CRAH unit. 
- * The program uses a Wi-Fi connection to communicate via the Modbus IP protocol.
- *
- * The setup() function initializes the following:
- * - Serial communication for debugging.
- * - Wi-Fi connection using credentials from config.h.
- * - A Modbus TCP server.
- * - Modbus points (Coils, Holding Registers, etc.) based on a predefined map in config.h.
- *
- * The loop() function continuously:
- * - Services the Modbus TCP server to handle incoming requests.
- * - Periodically calls the main update loop for the emulated equipment, which
- *   manages state transitions and behavior strategies.
- *
- * @see config.h for Wi-Fi and Modbus configuration.
- * @see Equipment.h for the main equipment logic.
- * @see State.h for different equipment states.
- * @see Strategies/Strategy_Behavior.h for value generation strategies.
- * @see Modbus_Point.h for the base class for all Modbus points.
- */
-//=================================================================================================================================
-//Libraries and declaration of variables.
-#include <WiFi.h>
-#include "config.h"
-#include "ModbusPoints/Modbus_PointFactory.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-//=================================================================================================================================
-/** 
- * @brief Initializes the application.
- * @details This function runs once at startup. It configures the serial communication, 
- * Wi-Fi, and the Modbus server. It also creates and initializes all the Modbus points 
- * based on the `mb_map` array in `config.h`.
- */
-void setup() {
-  Serial.begin(115200);                       //Serial comm start
-  WiFi.config(local_IP, gateway, subnet);     // Wifi service start
-  WiFi.begin(ssid, password);
-  while (WiFi.status() != WL_CONNECTED) {
-    delay(1000);
-    Serial.print(".");
-  }
-  Serial.println("Connected!!");
-  mb.server();                                //Modbus server start
-  Serial.println("Server Created");
-  Serial.println(map_size);
-  for(int i = 0; i < map_size; i++){
-    Modbus_Point<ModbusIP>* point = createModbus_Point(&mb, mb_map[i].category, mb_map[i].address, mb_map[i].value, mb_map[i].description);
-    if (point) {
-      point->addToModbusServer();
-      EquipmentInstance.addModbus_Point(mb_map[i].description, point);
-    }
-  }
-  Serial.println("All modbus Points created");
-  Serial.println("Setup function ended");
-}
-//=================================================================================================================================
-/** 
- * @brief The main application loop.
- * @details This function runs repeatedly after setup() has completed. It performs two main actions:
- * 1. It continuously services the Modbus server by calling `mb.task()` to handle
- *    incoming requests from a Modbus master.
- * 2. At a fixed interval (defined in `config.h`), it calls `EquipmentInstance.update()`
- *    to run the emulator's internal state machine and behavior logic.
- */
-void loop() {
-  mb.task();
-  unsigned long currentMillis = millis();
-  if (currentMillis - previousMillis >= interval) {
-    previousMillis = currentMillis;
-    unsigned long startTime = millis();
-    EquipmentInstance.update();
-    unsigned long endTime = millis();
-    unsigned long elapsedTime = endTime - startTime;
-    Serial.printf("Control Execution time: %d ms\n", elapsedTime);
-  } 
-}
diff --git a/src/EPMS/PDU/PDU_Manufacturer_Model_TCP/config.h b/src/EPMS/PDU/PDU_Manufacturer_Model_TCP/config.h
deleted file mode 100644
index de6c465..0000000
--- a/src/EPMS/PDU/PDU_Manufacturer_Model_TCP/config.h
+++ /dev/null
@@ -1,231 +0,0 @@
-/**
- * @file config.h
- * @brief Main configuration file for the CRAH Unit (TCP) emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * This file contains two important configurations: WiFi network parameters
- * and the Modbus register map for the device.
- */
-
-#ifndef CONFIG_H
-#define CONFIG_H
-
-#include "core.h"
-#include "Equipment/Equipment.h"
-
-#if defined(USE_MODBUS_IP)
-/**
-   * @defgroup ModbusTCPConfig Modbus IP Configuration
-   * @brief Parameters for Modbus TCP communication.
-   * @{
-   */
-  #include <ModbusIP_ESP8266.h>
-  const char *ssid = "wifi_name";       /**< @brief The SSID of the WiFi network. */
-  const char *password = "wifi_password";   /**< @brief The password for the WiFi network. */
-  IPAddress local_IP(192, 168, 1, 234);       /**< @brief The static IP address for the device. */
-  IPAddress gateway(192, 168, 1, 1);          /**< @brief The gateway IP address. */
-  IPAddress subnet(255, 255, 255, 0);         /**< @brief The subnet mask. */
-  
-  ModbusIP mb;
-#else
-  /**
-   * @defgroup ModbusRTUConfig Modbus RTU Configuration
-   * @brief Parameters for serial Modbus RTU communication.
-   * @{
-   */
-  #include <ModbusRTU.h>
-  const int BAUDRATE = 19200;   /**< @brief The serial communication speed in bits per second. */
-  const int RX_PIN = 17;        /**< @brief The GPIO pin used for receiving data (RX). */
-  const int TX_PIN = 16;        /**< @brief The GPIO pin used for transmitting data (TX). */
-  const int RST_PIN = 4;        /**< @brief The GPIO pin connected to the RS485 driver's DE/RE pins for direction control. */
-  const int MODBUS_ID = 1;      /**< @brief The unique slave ID for this device on the Modbus bus. */
-  /** @} */
-
-  /** @brief Global instance of the Modbus RTU server. */
-  ModbusRTU mb;
-#endif
-
-
-
-/**
- * @defgroup ModbusMapConfig Modbus Map Configuration
- * @brief Defines the Modbus register map and related parameters for the emulator.
- * @{
- */
-/**
- * @brief The Modbus map for the Equipment device.
- * This array defines all the Modbus points available on the emulated device.
- * The `description` field is crucial as it's used to look up points within the application logic.
- */
-modbusMap mb_map[] =
-{   
-  {HR,        15,     0,  "State Control"},  //Internal to control from Modscan
-  {HR,        16,     0,  "Fault Code"},
-  {HR,        1,      0,  "Alarm Status Word 1"},     //Internal Fault code from Modscan  
-  {HR,        2,      0,  "Alarm Status Word 2"},
-  {HR,        6,      0,  "Alarm Status Word 3"}, 
-  {IR,        1551,   0,  "CB Closed Feedback Word"},
-  {IR,        1552,   0,  "Alarm Status Word 4"},                    
-  {IR,        7,      0,  "Input Amps A"},                   
-  {IR,        9,      0,  "Input Amps B"},                 
-  {IR,        11,     0,  "Input Amps C"},                  
-  {IR,        71,     0,  "Total kVA"},                 
-  {IR,        69,     0,  "Total kVAR"},                  
-  {IR,        67,     0,  "Total kW"},                 
-  {IR,        93,     0,  "kWh"},                  
-  {IR,        73,     0,  "Total Power Factor"},   
-  {IR,        61,     0,  "Input Volts A-B"},   
-  {IR,        1,      0,  "Input Volts A-N"},              
-  {IR,        63,     0,  "Input Volts B-C"},          
-  {IR,        3,      0,  "Input Volts B-N"},         
-  {IR,        65,     0,  "Input Volts C-A"},        
-  {IR,        5,      0,  "Input Volts C-N"},        
-  {IR,        89,     0,  "Input Volts LL Average"},  
-  {IR,        87,     0,  "Input Volts LN Average"},                  
-  {IR,        107,    0,  "CB01 Amps A"},            
-  {IR,        109,    0,  "CB01 Amps B"},                
-  {IR,        111,    0,  "CB01 Amps C"},                 
-  {IR,        171,    0,  "CB01 Total kVA"},                 
-  {IR,        125,    0,  "CB01 kVA Phase A"},                  
-  {IR,        127,    0,  "CB01 kVA Phase B"},                
-  {IR,        129,    0,  "CB01 kVA Phase C"},                 
-  {IR,        169,    0,  "CB01 Total kVAR"},                  
-  {IR,        167,    0,  "CB01 Total kW"},            
-  {IR,        113,    0,  "CB01 kW Phase A"},         
-  {IR,        115,    0,  "CB01 kW Phase B"},                   
-  {IR,        117,    0,  "CB01 kW Phase C"},                    
-  {IR_LONG,   1114,   0,  "CB01 kWh"},       //Word is a double and may need to be adjusted from long         
-  {IR,        273,    0,  "CB02 Power Factor"},                
-  {IR,        207,    0,  "CB02 Amps A"},            
-  {IR,        209,    0,  "CB02 Amps B"},                
-  {IR,        211,    0,  "CB02 Amps C"},                 
-  {IR,        271,    0,  "CB02 Total kVA"},                 
-  {IR,        225,    0,  "CB02 kVA Phase A"},                  
-  {IR,        227,    0,  "CB02 kVA Phase B"},                
-  {IR,        229,    0,  "CB02 kVA Phase C"},                 
-  {IR,        269,    0,  "CB02 Total kVAR"},                  
-  {IR,        267,    0,  "CB02 Total kW"},            
-  {IR,        213,    0,  "CB02 kW Phase A"},         
-  {IR,        215,    0,  "CB02 kW Phase B"},                   
-  {IR,        217,    0,  "CB02 kW Phase C"},                    
-  {IR_LONG,   1169,   0,  "CB02 kWh"},       //Word is a double and may need to be adjusted from long         
-  {IR,        273,    0,  "CB02 Power Factor"},
-  {IR,        307,    0,  "CB03 Amps A"},            
-  {IR,        309,    0,  "CB03 Amps B"},                
-  {IR,        311,    0,  "CB03 Amps C"},                 
-  {IR,        371,    0,  "CB03 Total kVA"},                 
-  {IR,        325,    0,  "CB03 kVA Phase A"},                  
-  {IR,        327,    0,  "CB03 kVA Phase B"},                
-  {IR,        329,    0,  "CB03 kVA Phase C"},                 
-  {IR,        369,    0,  "CB03 Total kVAR"},                  
-  {IR,        367,    0,  "CB03 Total kW"},            
-  {IR,        313,    0,  "CB03 kW Phase A"},         
-  {IR,        315,    0,  "CB03 kW Phase B"},                   
-  {IR,        317,    0,  "CB03 kW Phase C"},                    
-  {IR_LONG,   1224,   0,  "CB03 kWh"},       //Word is a double and may need to be adjusted from long         
-  {IR,        373,    0,  "CB03 Power Factor"},
-  {IR,        407,    0,  "CB04 Amps A"},            
-  {IR,        409,    0,  "CB04 Amps B"},                
-  {IR,        411,    0,  "CB04 Amps C"},                 
-  {IR,        471,    0,  "CB04 Total kVA"},                 
-  {IR,        425,    0,  "CB04 kVA Phase A"},                  
-  {IR,        427,    0,  "CB04 kVA Phase B"},                
-  {IR,        429,    0,  "CB04 kVA Phase C"},                 
-  {IR,        469,    0,  "CB04 Total kVAR"},                  
-  {IR,        467,    0,  "CB04 Total kW"},            
-  {IR,        413,    0,  "CB04 kW Phase A"},         
-  {IR,        415,    0,  "CB04 kW Phase B"},                   
-  {IR,        417,    0,  "CB04 kW Phase C"},                    
-  {IR_LONG,   1279,   0,  "CB04 kWh"},       //Word is a double and may need to be adjusted from long         
-  {IR,        473,    0,  "CB04 Power Factor"}, 
-  {IR,        507,    0,  "CB05 Amps A"},            
-  {IR,        509,    0,  "CB05 Amps B"},                
-  {IR,        511,    0,  "CB05 Amps C"},                 
-  {IR,        571,    0,  "CB05 Total kVA"},                 
-  {IR,        525,    0,  "CB05 kVA Phase A"},                  
-  {IR,        527,    0,  "CB05 kVA Phase B"},                
-  {IR,        529,    0,  "CB05 kVA Phase C"},                 
-  {IR,        569,    0,  "CB05 Total kVAR"},                  
-  {IR,        567,    0,  "CB05 Total kW"},            
-  {IR,        513,    0,  "CB05 kW Phase A"},         
-  {IR,        515,    0,  "CB05 kW Phase B"},                   
-  {IR,        517,    0,  "CB05 kW Phase C"},                    
-  {IR_LONG,   1334,   0,  "CB05 kWh"},       //Word is a double and may need to be adjusted from long         
-  {IR,        573,    0,  "CB05 Power Factor"},
-  {IR,        607,    0,  "CB06 Amps A"},            
-  {IR,        609,    0,  "CB06 Amps B"},                
-  {IR,        611,    0,  "CB06 Amps C"},                 
-  {IR,        671,    0,  "CB06 Total kVA"},                 
-  {IR,        625,    0,  "CB06 kVA Phase A"},                  
-  {IR,        627,    0,  "CB06 kVA Phase B"},                
-  {IR,        629,    0,  "CB06 kVA Phase C"},                 
-  {IR,        669,    0,  "CB06 Total kVAR"},                  
-  {IR,        667,    0,  "CB06 Total kW"},            
-  {IR,        613,    0,  "CB06 kW Phase A"},         
-  {IR,        615,    0,  "CB06 kW Phase B"},                   
-  {IR,        617,    0,  "CB06 kW Phase C"},                    
-  {IR_LONG,   1389,   0,  "CB06 kWh"},       //Word is a double and may need to be adjusted from long         
-  {IR,        673,    0,  "CB06 Power Factor"},     
-  {IR,        707,    0,  "CB07 Amps A"},            
-  {IR,        709,    0,  "CB07 Amps B"},                
-  {IR,        711,    0,  "CB07 Amps C"},                 
-  {IR,        771,    0,  "CB07 Total kVA"},                 
-  {IR,        725,    0,  "CB07 kVA Phase A"},                  
-  {IR,        727,    0,  "CB07 kVA Phase B"},                
-  {IR,        729,    0,  "CB07 kVA Phase C"},                 
-  {IR,        769,    0,  "CB07 Total kVAR"},                  
-  {IR,        767,    0,  "CB07 Total kW"},            
-  {IR,        713,    0,  "CB07 kW Phase A"},         
-  {IR,        715,    0,  "CB07 kW Phase B"},                   
-  {IR,        717,    0,  "CB07 kW Phase C"},                    
-  {IR_LONG,   1444,   0,  "CB07 kWh"},       //Word is a double and may need to be adjusted from long         
-  {IR,        773,    0,  "CB07 Power Factor"},
-  {IR,        807,    0,  "CB08 Amps A"},            
-  {IR,        809,    0,  "CB08 Amps B"},                
-  {IR,        811,    0,  "CB08 Amps C"},                 
-  {IR,        871,    0,  "CB08 Total kVA"},                 
-  {IR,        825,    0,  "CB08 kVA Phase A"},                  
-  {IR,        827,    0,  "CB08 kVA Phase B"},                
-  {IR,        829,    0,  "CB08 kVA Phase C"},                 
-  {IR,        869,    0,  "CB08 Total kVAR"},                  
-  {IR,        867,    0,  "CB08 Total kW"},            
-  {IR,        813,    0,  "CB08 kW Phase A"},         
-  {IR,        815,    0,  "CB08 kW Phase B"},                   
-  {IR,        817,    0,  "CB08 kW Phase C"},                    
-  {IR_LONG,   1499,   0,  "CB08 kWh"},       //Word is a double and may need to be adjusted from long         
-  {IR,        873,    0,  "CB08 Power Factor"}, 
-  {IR,        907,    0,  "Trans-2nd Amps A"},
-  {IR,        909,    0,  "Trans-2nd Amps B"},
-  {IR,        911,    0,  "Trans-2nd Amps C"},
-  {IR_FLOAT,  1069,   0,  "Trans-2nd Amps G"},
-  {IR_FLOAT,  1067,   0,  "Trans-2nd Amps N"},
-  {IR,        925,    0,  "Trans-2nd kVA Phase A"},
-  {IR,        927,    0,  "Trans-2nd kVA Phase B"},
-  {IR,        929,    0,  "Trans-2nd kVA Phase C"},
-  {IR,        969,    0,  "Trans-2nd Total kVAR"},
-  {IR,        913,    0,  "Trans-2nd kW Phase A"},
-  {IR,        915,    0,  "Trans-2nd kW Phase B"},
-  {IR,        917,    0,  "Trans-2nd kW Phase C"},
-  {IR,        1087,   0,  "Trans-2nd Total kWh"},
-  {IR_FLOAT,  1092,   0,  "Trans-2nd Power Factor"},
-  {IR,        961,    0,  "Trans-2nd Output Volts A-B"},
-  {IR,        901,    0,  "Trans-2nd Output VOlts A-N"},
-  {IR,        963,    0,  "Trans-2nd Output Volts B-C"},
-  {IR,        903,    0,  "Trans-2nd Output Volts B-N"},
-  {IR,        965,    0,  "Trans-2nd Output Volts C-A"},
-  {IR,        905,    0,  "Trans-2nd Output Volts C-N"},                              
-};
-//Size of modbus map used in FOR cycles, automatically calculated.
-
-/**
- * @brief The total number of entries in the `mb_map` array.
- * This is calculated at compile time and used for iterating over the map.
- */
-const int map_size = sizeof(mb_map) / sizeof(mb_map[0]);
-
-/** @brief The main loop update interval in milliseconds. */
-int interval = 250; 
-/** @} */ // End of ModbusMapConfig group
-
-#endif // CONFIG_H
diff --git a/src/EPMS/PDU/PDU_Maverick_Power_TCP/README.md b/src/EPMS/PDU/PDU_Maverick_Power_TCP/README.md
deleted file mode 100644
index 355156f..0000000
--- a/src/EPMS/PDU/PDU_Maverick_Power_TCP/README.md
+++ /dev/null
@@ -1,33 +0,0 @@
-# EQUIPMENT_TYPE MANUFACTURER MODEL TCP
-
-## Brief Introduction
-Equipment specifc details that make it different from other devices
-
-## List of Equipmentt
-This cofiguration has been used for these models:
-* **Model**: 09-15-22 
-* **Model**: 09-15-23 
-* **Model**: 09-15-25 
-
-## Hardware Prerequisites
-
-The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities.
-* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html) 
-
----
-
-## States and Strategies
-Provide a brief description of what variables and strategies were used in this configuraiton
-
-### Standby State
-* **Equipment running**: set to 0
-* **Common Alarm**: set to 0
-* **SAT temperature**: set to 85
-
-### Running State
-* **Equipment running**: set to 1
-* **SAT temperature**: **Ramp Strategy** set to 65 deg setpoint
-
-### Fail State
-* **Commong Alarm**: set to 1
-* **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset
diff --git a/src/EPMS/PDU/PDU_Maverick_Power_TCP/State_Fail.cpp b/src/EPMS/PDU/PDU_Maverick_Power_TCP/State_Fail.cpp
deleted file mode 100644
index 8bc0385..0000000
--- a/src/EPMS/PDU/PDU_Maverick_Power_TCP/State_Fail.cpp
+++ /dev/null
@@ -1,81 +0,0 @@
-/**
- * @file State_Fail.cpp
- * @brief Implementation of the FailState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the FailState, which defines
- * the behavior of the equipment when it has entered a fault condition.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new FailState object with a list of active alarms.
- *
- * This constructor receives a list of alarm descriptions and creates strategies
- * to set the corresponding Modbus points to a value of 1, indicating an
- * active alarm. It also initializes a PID strategy for the 'CW Valve Position'
- * to maintain its state during the fault.
- * @param activeAlarms A vector of strings, where each string is the
- *                     description of a Modbus point to be set as an active alarm.
- */
-template<>
-FailState<ModbusIP>::FailState(const std::vector<std::string>& activeAlarms) {
-    // Simulate a failure: set common alarm and a specific fan alarm.
-
-    
-}
-
-/**
- * @brief Executes the fail state's logic for one update cycle.
- *
- * This method checks the "Alarm Reset" Modbus point for a command to
- * transition back to Standby, which would typically happen after a fault
- * is cleared by a user. If no transition is requested, it continues to apply
- * the failure strategies (e.g., keeping alarm bits active).
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* FailState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Fail update function");
-    
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the fail state.
- * Sets the "Alarm Common" point to 1 to indicate a general fault condition.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Fail State...");
-}
-
-/**
- * @brief Logic to execute once when exiting the fail state.
- * Clears the "Alarm Common" point to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Fail State...");
-}
\ No newline at end of file
diff --git a/src/EPMS/PDU/PDU_Maverick_Power_TCP/State_Running.cpp b/src/EPMS/PDU/PDU_Maverick_Power_TCP/State_Running.cpp
deleted file mode 100644
index 765a521..0000000
--- a/src/EPMS/PDU/PDU_Maverick_Power_TCP/State_Running.cpp
+++ /dev/null
@@ -1,416 +0,0 @@
-/**
- * @file State_Running.cpp
- * @brief Implementation of the RunningState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the RunningState, which defines
- * the behavior of the equipment when it is actively running.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "Strategies/Strategy_Totalizer.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new RunningState object.
- *
- * This constructor initializes behavior strategies active during the running
- * state, such as a PID controller for the 'CW Valve Position' and totalizers
- * for the run-hours of each EC fan.
- */
-std::string cbs[] = {"CB1", "CB2", "CB3", "CB4", "CB5", "CB6", "CB7", "CB8"};
-template<>
-RunningState<ModbusIP>::RunningState() {
-
-  addStrategy("Input_I1", new SingleValueStrategy(40.0f, 30.0f, 1000));
-  addStrategy("Input_I2", new SingleValueStrategy(40.0f, 30.0f, 1000));
-  addStrategy("Input_I3", new SingleValueStrategy(40.0f, 30.0f, 1000));
-  addStrategy("Input_kVA", new SingleValueStrategy(150.0f, 100.0f, 1000));
-  addStrategy("Input_kVAR", new SingleValueStrategy(150.0f, 100.0f, 1000));
-  addStrategy("Input_kW", new SingleValueStrategy(150.0f, 100.0f, 1000));
-  addStrategy("Input_kWh", new SingleValueStrategy(3.0f, 2.0f, 1000));
-  addStrategy("Input_PF", new SingleValueStrategy(150.0f, 100.0f, 1000));
-  addStrategy("Input_V_AB", new SingleValueStrategy(3.0f, 2.0f, 1000));
-  addStrategy("Input_V_AN", new SingleValueStrategy(3.0f, 2.0f, 1000));
-  addStrategy("Input_V_BC", new SingleValueStrategy(3.0f, 2.0f, 1000));
-  addStrategy("Input_V_BN", new SingleValueStrategy(3.0f, 2.0f, 1000));
-  addStrategy("Input_V_CA", new SingleValueStrategy(3.0f, 2.0f, 1000));
-  addStrategy("Input_V_CN", new SingleValueStrategy(3.0f, 2.0f, 1000));
-  addStrategy("Input_LL_Avg", new SingleValueStrategy(3.0f, 2.0f, 1000));
-  addStrategy("Input_LN_Avg", new SingleValueStrategy(3.0f, 2.0f, 1000));
-
-  for (const std::string& cb : cbs) {
-    std::string tag = "";
-    tag = "";
-    tag = cb + "_I1";
-    addStrategy(tag, new SingleValueStrategy(40.0f, 30.0f, 1000));
-    tag = "";
-    tag = cb + "_I2";
-    addStrategy(tag, new SingleValueStrategy(40.0f, 30.0f, 1000));
-    tag = "";
-    tag = cb + "_I3";
-    addStrategy(tag, new SingleValueStrategy(40.0f, 30.0f, 1000));
-    tag = "";
-    tag = cb + "_kVA";
-    addStrategy(tag, new SingleValueStrategy(150.0f, 100.0f, 1000));
-    tag = "";
-    tag = cb + "_kVA1";
-    addStrategy(tag, new SingleValueStrategy(150.0f, 100.0f, 1000));
-    tag = "";
-    tag = cb + "_kVA2";
-    addStrategy(tag, new SingleValueStrategy(150.0f, 100.0f, 1000));
-    tag = "";
-    tag = cb + "_kVA3";
-    addStrategy(tag, new SingleValueStrategy(150.0f, 100.0f, 1000));
-    tag = "";
-    tag = cb + "_kVAR";
-    addStrategy(tag, new SingleValueStrategy(150.0f, 100.0f, 1000));
-    tag = "";
-    tag = cb + "_kW";
-    addStrategy(tag, new SingleValueStrategy(150.0f, 100.0f, 1000));
-    tag = "";
-    tag = cb + "_kW1";
-    addStrategy(tag, new SingleValueStrategy(150.0f, 100.0f, 1000));
-    tag = "";
-    tag = cb + "_kW2";
-    addStrategy(tag, new SingleValueStrategy(150.0f, 100.0f, 1000));
-    tag = "";
-    tag = cb + "_kW3";
-    addStrategy(tag, new SingleValueStrategy(150.0f, 100.0f, 1000));
-    tag = "";
-    tag = cb + "_kWh";
-    addStrategy(tag, new SingleValueStrategy(0.1f, 100.0f, 1000));
-    tag = "";
-    tag = cb + "_PF";
-    addStrategy(tag, new SingleValueStrategy(150.0f, 100.0f, 1000));
-  }
-
-  
-  addStrategy("Output_I1", new SingleValueStrategy(30.0f, 20.0f, 1000));
-  addStrategy("Output_I2", new SingleValueStrategy(30.0f, 30.0f, 1000));
-  addStrategy("Output_I3", new SingleValueStrategy(30.0f, 20.0f, 1000));
-  addStrategy("Output_IG", new SingleValueStrategy(30.0f, 30.0f, 1000));
-  addStrategy("Output_IN", new SingleValueStrategy(30.0f, 20.0f, 1000));
-  addStrategy("Output_kVA1", new SingleValueStrategy(150.0f, 100.0f, 1000));
-  addStrategy("Output_kVA2", new SingleValueStrategy(150.0f, 100.0f, 1000));
-  addStrategy("Output_kVA3", new SingleValueStrategy(150.0f, 100.0f, 1000));
-  addStrategy("Output_kWh", new SingleValueStrategy(3.0f, 2.0f, 1000));
-  addStrategy("Output_PF", new SingleValueStrategy(150.0f, 100.0f, 1000));
-  addStrategy("Output_V_AB", new SingleValueStrategy(30.0f, 20.0f, 1000));
-  addStrategy("Output_V_AN", new SingleValueStrategy(30.0f, 30.0f, 1000));
-  addStrategy("Output_V_BC", new SingleValueStrategy(30.0f, 20.0f, 1000));
-  addStrategy("Output_V_BN", new SingleValueStrategy(30.0f, 30.0f, 1000));
-  addStrategy("Output_V_CA", new SingleValueStrategy(30.0f, 20.0f, 1000));
-  addStrategy("Output_V_CN", new SingleValueStrategy(30.0f, 30.0f, 1000));
-}
-
-/**
- * @brief Executes the running state's logic for one update cycle.
- *
- * This method first checks for state transition commands:
- * 1. It reads the "ON/OFF Command By BMS" point. If it's 0, it transitions to StandbyState.
- * 2. It reads the "Fault Code" point. If it's non-zero, it transitions to FailState,
- *    passing the corresponding alarm description.
- *
- * If no transition occurs, it applies the strategies defined for the running state.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* RunningState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Running update function");
-    float State_Ctrl = getPointValue(equipment, "Px Ctrl");
-    switch (static_cast<int>(State_Ctrl)) {
-      case 1:
-        return new StandbyState<ModbusIP>();
-        break;
-      default:
-        break;
-    }
-    float cb_count = 0.0f;
-    for (const std::string& cb :cbs){
-      std::string tag = "";
-      tag = "Px_" + cb;
-      float cb_status = getPointValue(equipment, tag);
-      if (cb_status == 1.0f){
-        cb_count += 1.0f;
-      }
-    }
-    Serial.printf("CB_ CLosed = %f \n", cb_count);
-    int cb_num = 1;
-    for (const std::string& cb : cbs) {
-      std::string tag = "";
-      Strategy_Behavior* strategy = nullptr;
-      tag = "";
-      tag = "Px_" + cb;
-      float cb_status = getPointValue(equipment, tag);
-      float percent_load = getPointValue(equipment, "Px Load");
-      float Rating = getPointValue(equipment, "Px Rating");
-      float cb_load = 400.0f * (percent_load /1000.0f);
-      
-      if (cb_status == 1.0f){
-        setBitValue(equipment, "CB_Status", cb_num, true);
-        setBitValue(equipment, "CB_Tripped", cb_num, false);
-        
-        tag = "";
-        tag = cb + "_I1";
-        setPointValue(equipment, tag, cb_load * 1000.0f);
-        tag = "";
-        tag = cb + "_I2";
-        setPointValue(equipment, tag, cb_load * 1000.0f);
-        tag = "";
-        tag = cb + "_I3";
-        setPointValue(equipment, tag, cb_load * 1000.0f);
-        tag = "";
-        tag = cb + "_PF";
-        setPointValue(equipment, tag, 910.0f);
-        tag = "";
-        tag = cb + "_PF";
-        float pf = getPointValue(equipment, tag);
-        
-
-        tag = "";
-        tag = cb + "_kW1";
-        setPointValue(equipment, tag, cb_load * 48000.0f * pf);
-        float kW1 = getPointValue(equipment, tag);
-        tag = "";
-        tag = cb + "_kW2";
-        setPointValue(equipment, tag, cb_load * 48000.0f * pf);
-        float kW2 = getPointValue(equipment, tag);
-        tag = "";
-        tag = cb + "_kW3";
-        setPointValue(equipment, tag, cb_load * 48000.0f * pf);
-        float kW3 = getPointValue(equipment, tag);
-        tag = "";
-        tag = cb + "_kW";
-        setPointValue(equipment, tag, ((kW1 + kW2 + kW3) / 3.0f)*1000.0f);
-        tag = "";
-        tag = cb + "_kWh";
-        setPointValue(equipment, tag, 1325.0f);
-        tag = "";
-        tag = cb + "_kVA";
-        setPointValue(equipment, tag, cb_load * 480.0f * 10000.0f);
-        tag = "";
-        tag = cb + "_kVA";
-        setPointValue(equipment, tag, cb_load * 480.0f * 10000.0f);
-        tag = "";
-        tag = cb + "_kVA";
-        setPointValue(equipment, tag, cb_load * 480.0f * 10000.0f);
-
-        tag = "";
-        tag = cb + "_kVA1";
-        float kVA1 = getPointValue(equipment, tag);
-        tag = "";
-        tag = cb + "_kVA2";
-        float kVA2 = getPointValue(equipment, tag);
-        tag = "";
-        tag = cb + "_kVA3";
-        float kVA3 = getPointValue(equipment, tag);
-        float kVA = (kVA1 + kVA2 + kVA3) * 1732.0f;
-        tag = "";
-        tag = cb + "_kVA";
-        setPointValue(equipment, tag, kVA);
-        tag = "";
-        tag = cb + "_kVAR";
-        setPointValue(equipment, tag, kVA / pf);
-
-
-      }
-      else{
-        if (cb_status == 2.0f){
-          setBitValue(equipment, "CB_Tripped", cb_num, true);
-        } else {
-          setBitValue(equipment, "CB_Tripped", cb_num, false);
-        }
-        setBitValue(equipment, "CB_Status", cb_num, false);
-          tag = "";
-          tag = cb + "_I1";
-          setPointValue(equipment, tag, 40.0f);
-          tag = "";
-          tag = cb + "_I2";
-          setPointValue(equipment, tag, 0.0f);
-          tag = "";
-          tag = cb + "_I3";
-          setPointValue(equipment, tag, 40.0f);
-          tag = "";
-          tag = cb + "_kVA";
-          setPointValue(equipment, tag, 150.0f);
-          tag = "";
-          tag = cb + "_kVA1";
-          setPointValue(equipment, tag, 150.0f);
-          tag = "";
-          tag = cb + "_kVA2";
-          setPointValue(equipment, tag, 150.0f);
-          tag = "";
-          tag = cb + "_kVA3";
-          setPointValue(equipment, tag, 150.0f);
-          tag = "";
-          tag = cb + "_kVAR";
-          setPointValue(equipment, tag, 150.0f);
-          tag = "";
-          tag = cb + "_kW";
-          setPointValue(equipment, tag, 150.0f);
-          tag = "";
-          tag = cb + "_kW1";
-          setPointValue(equipment, tag, 150.0f);
-          tag = "";
-          tag = cb + "_kW2";
-          setPointValue(equipment, tag, 150.0f);
-          tag = "";
-          tag = cb + "_kW3";
-          setPointValue(equipment, tag, 150.0f);
-          tag = "";
-          tag = cb + "_kWh";
-          setPointValue(equipment, tag, 0.5f);
-          tag = "";
-          tag = cb + "_PF";
-          setPointValue(equipment, tag, 150.0f);
-      }
-      cb_num++;
-
-      
-    }
-    Serial.printf("CB_ CLosed = %f \n", cb_count);
-    if (cb_count > 0.0f){
-      Serial.println("At least one breaker closed...");
-      float percent_load = getPointValue(equipment, "Px Load");
-      float cb_load = 400.0f * (percent_load /1000.0f);
-      setPointValue(equipment, "Input_I1", cb_count * cb_load *100.0f);
-      setPointValue(equipment, "Input_I2", cb_count * cb_load *100.0f);
-      setPointValue(equipment, "Input_I3", cb_count * cb_load *100.0f);
-      setPointValue(equipment, "Output_I1", cb_count * cb_load *100.0f);
-      setPointValue(equipment, "Output_I2", cb_count * cb_load*100.0f);
-      setPointValue(equipment, "Output_I3", cb_count * cb_load*100.0f);
-      setPointValue(equipment, "Output_IG", cb_count * 750.0f);
-      setPointValue(equipment, "Output_IN", cb_count * 482.0f);
-  
-      float pf = 0.92f;
-      setPointValue(equipment, "Input_PF", pf * 930.0f);
-      setPointValue(equipment, "Output_PF", pf);
-      float i1 = getPointValue(equipment, "Input_I1");
-      float i2 = getPointValue(equipment, "Input_I2");
-      float i3 = getPointValue(equipment, "Input_I3");
-  
-      setPointValue(equipment, "Input_kW", 480.0f * ((i1 + i2 + i3) / 3.0f));
-      float kW = getPointValue(equipment, "Input_kW");
-      setPointValue(equipment, "Input_kVA", kW * 1.732f);
-      setPointValue(equipment, "Output_kVA1", (kW * 1.732f)/3.0f);
-      setPointValue(equipment, "Output_kVA2", (kW * 1.732f)/3.0f);
-      setPointValue(equipment, "Output_kVA3", (kW * 1.732f)/3.0f);
-      setPointValue(equipment, "Input_kVAR", kW * 1.732f* pf);
-      setPointValue(equipment, "Output_kVAR", kW * 1.732f* pf);
-
-      setPointValue(equipment, "Output_kW1", kW /3.0f);
-      setPointValue(equipment, "Output_kW2", kW /3.0f);
-      setPointValue(equipment, "Output_kW3", kW /3.0f);
-        
-      setPointValue(equipment, "Output_kWh", 1423.0f);
-      
-  
-      setPointValue(equipment, "Input_V_AB", 4800.0f);
-      setPointValue(equipment, "Input_V_AN", 2700.0f);
-      setPointValue(equipment, "Input_V_BC", 4800.0f);
-      setPointValue(equipment, "Input_V_BN", 2700.0f);
-      setPointValue(equipment, "Input_V_CA", 4800.0f);
-      setPointValue(equipment, "Input_V_CN", 2700.0f);
-      setPointValue(equipment, "Input_LL_Avg", 4800.0f);
-      setPointValue(equipment, "Input_LN_Avg", 2700.0f);
-      setPointValue(equipment, "Output_V_AB", 4800.0f);
-      setPointValue(equipment, "Output_V_AN", 2700.0f);
-      setPointValue(equipment, "Output_V_BC", 4800.0f);
-      setPointValue(equipment, "Output_V_BN", 2700.0f);
-      setPointValue(equipment, "Output_V_CA", 4800.0f);
-      setPointValue(equipment, "Output_V_CN", 2700.0f);
-    } else {
-      Serial.println("No breaker closed...");
-      setPointValue(equipment, "Input_I1", 50.0f);
-      setPointValue(equipment, "Input_I2", 50.0f);
-      setPointValue(equipment, "Input_I3", 50.0f);
-      setPointValue(equipment, "Output_I1", 50.0f);
-      setPointValue(equipment, "Output_I2", 50.0f);
-      setPointValue(equipment, "Output_I3", 50.0f);
-      setPointValue(equipment, "Output_IG", 50.0f);
-      setPointValue(equipment, "Output_IN", 50.0f);
-      setPointValue(equipment, "Input_PF", 0.0f);
-      setPointValue(equipment, "Output_PF", 0.0f);
-      setPointValue(equipment, "Input_kW", 0.0f);
-      setPointValue(equipment, "Input_kVA", 0.0f);
-      setPointValue(equipment, "Output_kVA1", 0.0f);
-      setPointValue(equipment, "Output_kVA2", 0.0f);
-      setPointValue(equipment, "Output_kVA3", 0.0f);
-      setPointValue(equipment, "Input_kVAR", 0.0f);
-      setPointValue(equipment, "Output_kVAR", 0.0f);
-      setPointValue(equipment, "Output_kW1", 0.0f);
-      setPointValue(equipment, "Output_kW2", 0.0f);
-      setPointValue(equipment, "Output_kW3", 0.0f);
-      setPointValue(equipment, "Output_kWh", 1.0f);
-      setPointValue(equipment, "Input_V_AB", 4800.0f);
-      setPointValue(equipment, "Input_V_AN", 2700.0f);
-      setPointValue(equipment, "Input_V_BC", 4800.0f);
-      setPointValue(equipment, "Input_V_BN", 2700.0f);
-      setPointValue(equipment, "Input_V_CA", 4800.0f);
-      setPointValue(equipment, "Input_V_CN", 2700.0f);
-      setPointValue(equipment, "Input_LL_Avg", 4800.0f);
-      setPointValue(equipment, "Input_LN_Avg", 2700.0f);
-      setPointValue(equipment, "Output_V_AB", 10.0f);
-      setPointValue(equipment, "Output_V_AN", 10.0f);
-      setPointValue(equipment, "Output_V_BC", 10.0f);
-      setPointValue(equipment, "Output_V_BN", 10.0f);
-      setPointValue(equipment, "Output_V_CA", 10.0f);
-      setPointValue(equipment, "Output_V_CN", 10.0f);
-
-    }
-
-
-
-    
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the running state.
- * Sets the "Run Status" for all EC fans to 1 to indicate they are active.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Running State...");
-    // You could also update a Modbus register to show the "standby" state
-
-}
-
-/**
- * @brief Logic to execute once when exiting the running state.
- * Sets the "Run Status" for all EC fans to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Running State...");
-   
-}
-
diff --git a/src/EPMS/PDU/PDU_Maverick_Power_TCP/State_Standby.cpp b/src/EPMS/PDU/PDU_Maverick_Power_TCP/State_Standby.cpp
deleted file mode 100644
index b35142e..0000000
--- a/src/EPMS/PDU/PDU_Maverick_Power_TCP/State_Standby.cpp
+++ /dev/null
@@ -1,102 +0,0 @@
-/**
- * @file State_Standby.cpp
- * @brief Implementation of the StandbyState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the StandbyState, which defines
- * the behavior of the equipment when it is in an idle or standby mode.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-/**
- * @brief Constructs a new StandbyState object.
- *
- * In this state, the equipment is idle. This constructor initializes strategies
- * to bring the system to a safe, idle condition. It sets a stable value for
- * the SAT reading and creates ramp strategies to bring the CW valve and all
- * EC fan speeds down to zero.
- */
-template<>
-StandbyState<ModbusIP>::StandbyState() {
-    // You can add initialization code here if needed
-    
-
-}
-
-/**
- * @brief Executes the standby state's logic for one update cycle.
- *
- * This method applies the strategies defined for the standby state (e.g.,
- * ramping values to zero).
- *
- * @warning This method currently does not check for a command to transition to the
- *          Running state. This logic needs to be added to allow the unit to start.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* StandbyState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Standby update function");
-    float State_Ctrl = getPointValue(equipment, "Px Ctrl");
-    switch (static_cast<int>(State_Ctrl)) {
-      case 2:
-        return new RunningState<ModbusIP>();
-        break;
-      default:
-        break;
-    }
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the standby state.
- * This method performs cleanup by setting all alarm points and all EC fan
- * run status points to 0.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Standby State...");
-    setPointValue(equipment, "Input_V_AB", 0.0f);
-    setPointValue(equipment, "Input_V_AN", 0.0f);
-    setPointValue(equipment, "Input_V_BC", 0.0f);
-    setPointValue(equipment, "Input_V_BN", 0.0f);
-    setPointValue(equipment, "Input_V_CA", 0.0f);
-    setPointValue(equipment, "Input_V_CN", 0.0f);
-    setPointValue(equipment, "Input_LL_Avg", 0.0f);
-    setPointValue(equipment, "Input_LN_Avg", 0.0f);
-    setPointValue(equipment, "Output_PF", 0.0f);
-
-}
-
-/**
- * @brief Logic to execute once when exiting the standby state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Standby State...");
-}
\ No newline at end of file
diff --git a/src/EPMS/PDU/PDU_Maverick_Power_TCP/config.h b/src/EPMS/PDU/PDU_Maverick_Power_TCP/config.h
deleted file mode 100644
index cd8b96f..0000000
--- a/src/EPMS/PDU/PDU_Maverick_Power_TCP/config.h
+++ /dev/null
@@ -1,261 +0,0 @@
-/**
- * @file config.h
- * @brief Main configuration file for the PDU Maverick Power
- * @author Zach Gutierrez
- * @date 2025-09-02
- *
- * This file contains two important configurations: WiFi network parameters
- * and the Modbus register map for the device.
- */
-
-#ifndef CONFIG_H
-#define CONFIG_H
-
-#include "core.h"
-#include "Equipment/Equipment.h"
-
-#if defined(USE_MODBUS_IP)
-/**
-   * @defgroup ModbusTCPConfig Modbus IP Configuration
-   * @brief Parameters for Modbus TCP communication.
-   * @{
-   */
-  #include <ModbusIP_ESP8266.h>
-  const char *ssid = "QTS_CDR_Arduino";       /**< @brief The SSID of the WiFi network. */
-  const char *password = "123abc456";         /**< @brief The password for the WiFi network. */
-  IPAddress local_IP(172, 17, 33, 181);       /**< @brief The static IP address for the device. */
-  IPAddress gateway(172, 17, 33, 1);          /**< @brief The gateway IP address. */
-  IPAddress subnet(255, 255, 255, 0);         /**< @brief The subnet mask. */
-  
-  ModbusIP mb;
-#else
-  /**
-   * @defgroup ModbusRTUConfig Modbus RTU Configuration
-   * @brief Parameters for serial Modbus RTU communication.
-   * @{
-   */
-  #include <ModbusRTU.h>
-  const int BAUDRATE = 19200;   /**< @brief The serial communication speed in bits per second. */
-  const int RX_PIN = 17;        /**< @brief The GPIO pin used for receiving data (RX). */
-  const int TX_PIN = 16;        /**< @brief The GPIO pin used for transmitting data (TX). */
-  const int RST_PIN = 4;        /**< @brief The GPIO pin connected to the RS485 driver's DE/RE pins for direction control. */
-  const int MODBUS_ID = 1;      /**< @brief The unique slave ID for this device on the Modbus bus. */
-  /** @} */
-
-  /** @brief Global instance of the Modbus RTU server. */
-  ModbusRTU mb;
-#endif
-
-/**
- * @defgroup ModbusMapConfig Modbus Map Configuration
- * @brief Defines the Modbus register map and related parameters for the emulator.
- * @{
- */
-/**
- * @brief The Modbus map for the Equipment device.
- * This array defines all the Modbus points available on the emulated device.
- * The `description` field is crucial as it's used to look up points within the application logic.
- */
-modbusMap mb_map[] = {
-
-  //***************************************
-  // Write Registers (as Input Registers - 3X)
-  //***************************************
-  {HR,  9, 0, "Px Ctrl"},
-  {HR,  10, 0, "Px Rating"}, //Amps
-  {HR,  11, 0, "Px Load"},   //%load
-  {HR,  19, 0, "Px_Input"},
-  {HR,  20, 0, "Px_CB1"},
-  {HR,  21, 0, "Px_CB2"},
-  {HR,  22, 0, "Px_CB3"},
-  {HR,  23, 0, "Px_CB4"},
-  {HR,  24, 0, "Px_CB5"},
-  {HR,  25, 0, "Px_CB6"},
-  {HR,  26, 0, "Px_CB7"},
-  {HR,  27, 0, "Px_CB8"},
-  {HR,  28, 0, "Px_Output"},
-
-  // PDU Input
-  {IR_LONG, 6, 0,  "Input_I1" },    //0.01
-  {IR_LONG, 8, 0,  "Input_I2" },    //0.01
-  {IR_LONG, 10, 0, "Input_I3" },    //0.01
-  {IR_LONG, 70, 0, "Input_kVA" },   //0.001
-  {IR_LONG, 68, 0, "Input_KVAR" },  //0.001
-  {IR_LONG, 66, 0, "Input_kW" },    //0.001
-  {IR_LONG, 66, 0, "Input_kWh" },   //0.1
-  {IR_LONG, 72, 0, "Input_PF" },    //0.001
-  {IR_LONG, 60, 0, "Input_V_AB" },  //0.1
-  {IR_LONG, 0, 0,  "Input_V_AN" },  //0.1
-  {IR_LONG, 62, 0, "Input_V_BC" },  //0.1
-  {IR_LONG, 2, 0,  "Input_V_BN" },  //0.1
-  {IR_LONG, 64, 0, "Input_V_CA" },  //0.1
-  {IR_LONG, 4, 0,  "Input_V_CN" },  //0.1
-  {IR_LONG, 88, 0, "Input_LL_Avg" },//0.1
-  {IR_LONG, 86, 0, "Input_LN_Avg" },//0.1
-  
-  // Circuit Breaker 1 (CB1)
-  {IR_LONG, 106, 0, "CB1_I1" },   //0.01x
-  {IR_LONG, 108, 0, "CB1_I2" },   //0.01x
-  {IR_LONG, 110, 0, "CB1_I3" },   //0.01x
-  {IR_LONG, 170, 0, "CB1_kVA" },  //0.001x
-  {IR_LONG, 124, 0, "CB1_kVA1" }, //0.001x
-  {IR_LONG, 126, 0, "CB1_kVA2" }, //0.001x
-  {IR_LONG, 128, 0, "CB1_kVA3" }, //0.001x
-  {IR_LONG, 168, 0, "CB1_kVAR" }, //0.001x
-  {IR_LONG, 166, 0, "CB1_kW" },   //0.001x
-  {IR_LONG, 112, 0, "CB1_kW1" },  //0.001x
-  {IR_LONG, 114, 0, "CB1_kW2" },  //0.001x
-  {IR_LONG, 116, 0, "CB1_kW3" },  //0.001x
-  {IR_LONG, 1113, 0, "CB1_kWh" },
-  {IR_LONG, 172, 0, "CB1_PF" },   //0.001x
-
-    // Circuit Breaker 2 (CB1)
-  {IR_LONG, 206, 0, "CB2_I1" },   //0.01x
-  {IR_LONG, 208, 0, "CB2_I2" },   //0.01x
-  {IR_LONG, 210, 0, "CB2_I3" },   //0.01x
-  {IR_LONG, 270, 0, "CB2_kVA" },  //0.001x
-  {IR_LONG, 224, 0, "CB2_kVA1" }, //0.001x
-  {IR_LONG, 226, 0, "CB2_kVA2" }, //0.001x
-  {IR_LONG, 228, 0, "CB2_kVA3" }, //0.001x
-  {IR_LONG, 268, 0, "CB2_kVAR" }, //0.001x
-  {IR_LONG, 266, 0, "CB2_kW" },   //0.001x
-  {IR_LONG, 212, 0, "CB2_kW1" },  //0.001x
-  {IR_LONG, 214, 0, "CB2_kW2" },  //0.001x
-  {IR_LONG, 216, 0, "CB2_kW3" },  //0.001x
-  {IR_LONG, 1168, 0, "CB2_kWh" },
-  {IR_LONG, 272, 0, "CB2_PF" },   //0.001x
-
-    // Circuit Breaker 3 (CB1)
-  {IR_LONG, 306, 0, "CB3_I1" },   //0.01x
-  {IR_LONG, 308, 0, "CB3_I2" },   //0.01x
-  {IR_LONG, 310, 0, "CB3_I3" },   //0.01x
-  {IR_LONG, 370, 0, "CB3_kVA" },  //0.001x
-  {IR_LONG, 324, 0, "CB3_kVA1" }, //0.001x
-  {IR_LONG, 326, 0, "CB3_kVA2" }, //0.001x
-  {IR_LONG, 328, 0, "CB3_kVA3" }, //0.001x
-  {IR_LONG, 368, 0, "CB3_kVAR" }, //0.001x
-  {IR_LONG, 366, 0, "CB3_kW" },   //0.001x
-  {IR_LONG, 312, 0, "CB3_kW1" },  //0.001x
-  {IR_LONG, 314, 0, "CB3_kW2" },  //0.001x
-  {IR_LONG, 316, 0, "CB3_kW3" },  //0.001x
-  {IR_LONG, 1223, 0, "CB3_kWh" },
-  {IR_LONG, 372, 0, "CB3_PF" },   //0.001x
-
-    // Circuit Breaker 4 (CB1)
-  {IR_LONG, 406, 0, "CB4_I1" },   //0.01x
-  {IR_LONG, 408, 0, "CB4_I2" },   //0.01x
-  {IR_LONG, 410, 0, "CB4_I3" },   //0.01x
-  {IR_LONG, 470, 0, "CB4_kVA" },  //0.001x
-  {IR_LONG, 424, 0, "CB4_kVA1" }, //0.001x
-  {IR_LONG, 426, 0, "CB4_kVA2" }, //0.001x
-  {IR_LONG, 428, 0, "CB4_kVA3" }, //0.001x
-  {IR_LONG, 468, 0, "CB4_kVAR" }, //0.001x
-  {IR_LONG, 466, 0, "CB4_kW" },   //0.001x
-  {IR_LONG, 412, 0, "CB4_kW1" },  //0.001x
-  {IR_LONG, 414, 0, "CB4_kW2" },  //0.001x
-  {IR_LONG, 416, 0, "CB4_kW3" },  //0.001x
-  {IR_LONG, 1278, 0, "CB4_kWh" },
-  {IR_LONG, 472, 0, "CB4_PF" },   //0.001x
-
-    // Circuit Breaker 5 (CB1)
-  {IR_LONG, 506, 0, "CB5_I1" },   //0.01x
-  {IR_LONG, 508, 0, "CB5_I2" },   //0.01x
-  {IR_LONG, 510, 0, "CB5_I3" },   //0.01x
-  {IR_LONG, 570, 0, "CB5_kVA" },  //0.001x
-  {IR_LONG, 524, 0, "CB5_kVA1" }, //0.001x
-  {IR_LONG, 526, 0, "CB5_kVA2" }, //0.001x
-  {IR_LONG, 528, 0, "CB5_kVA3" }, //0.001x
-  {IR_LONG, 568, 0, "CB5_kVAR" }, //0.001x
-  {IR_LONG, 566, 0, "CB5_kW" },   //0.001x
-  {IR_LONG, 512, 0, "CB5_kW1" },  //0.001x
-  {IR_LONG, 514, 0, "CB5_kW2" },  //0.001x
-  {IR_LONG, 516, 0, "CB5_kW3" },  //0.001x
-  {IR_LONG, 1333, 0, "CB5_kWh" },
-  {IR_LONG, 572, 0, "CB5_PF" },   //0.001x
-
-    // Circuit Breaker 6 (CB1)
-  {IR_LONG, 606, 0, "CB6_I1" },   //0.01x
-  {IR_LONG, 608, 0, "CB6_I2" },   //0.01x
-  {IR_LONG, 610, 0, "CB6_I3" },   //0.01x
-  {IR_LONG, 670, 0, "CB6_kVA" },  //0.001x
-  {IR_LONG, 624, 0, "CB6_kVA1" }, //0.001x
-  {IR_LONG, 626, 0, "CB6_kVA2" }, //0.001x
-  {IR_LONG, 628, 0, "CB6_kVA3" }, //0.001x
-  {IR_LONG, 668, 0, "CB6_kVAR" }, //0.001x
-  {IR_LONG, 666, 0, "CB6_kW" },   //0.001x
-  {IR_LONG, 612, 0, "CB6_kW1" },  //0.001x
-  {IR_LONG, 614, 0, "CB6_kW2" },  //0.001x
-  {IR_LONG, 616, 0, "CB6_kW3" },  //0.001x
-  {IR_LONG, 1388, 0, "CB6_kWh" },
-  {IR_LONG, 672, 0, "CB6_PF" },   //0.001x
-
-    // Circuit Breaker 7 (CB1)
-  {IR_LONG, 706, 0, "CB7_I1" },   //0.01x
-  {IR_LONG, 708, 0, "CB7_I2" },   //0.01x
-  {IR_LONG, 710, 0, "CB7_I3" },   //0.01x
-  {IR_LONG, 770, 0, "CB7_kVA" },  //0.001x
-  {IR_LONG, 724, 0, "CB7_kVA1" }, //0.001x
-  {IR_LONG, 726, 0, "CB7_kVA2" }, //0.001x
-  {IR_LONG, 728, 0, "CB7_kVA3" }, //0.001x
-  {IR_LONG, 768, 0, "CB7_kVAR" }, //0.001x
-  {IR_LONG, 766, 0, "CB7_kW" },   //0.001x
-  {IR_LONG, 712, 0, "CB7_kW1" },  //0.001x
-  {IR_LONG, 714, 0, "CB7_kW2" },  //0.001x
-  {IR_LONG, 716, 0, "CB7_kW3" },  //0.001x
-  {IR_LONG, 1443, 0, "CB7_kWh" },
-  {IR_LONG, 772, 0, "CB7_PF" },   //0.001x
-  
-  // Circuit Breaker 8 (CB1)
-  {IR_LONG, 806, 0, "CB8_I1" },   //0.01x
-  {IR_LONG, 808, 0, "CB8_I2" },   //0.01x
-  {IR_LONG, 810, 0, "CB8_I3" },   //0.01x
-  {IR_LONG, 870, 0, "CB8_kVA" },  //0.001x
-  {IR_LONG, 824, 0, "CB8_kVA1" }, //0.001x
-  {IR_LONG, 826, 0, "CB8_kVA2" }, //0.001x
-  {IR_LONG, 828, 0, "CB8_kVA3" }, //0.001x
-  {IR_LONG, 868, 0, "CB8_kVAR" }, //0.001x
-  {IR_LONG, 866, 0, "CB8_kW" },   //0.001x
-  {IR_LONG, 812, 0, "CB8_kW1" },  //0.001x
-  {IR_LONG, 814, 0, "CB8_kW2" },  //0.001x
-  {IR_LONG, 816, 0, "CB8_kW3" },  //0.001x
-  {IR_LONG, 1498, 0, "CB8_kWh" },
-  {IR_LONG, 872, 0, "CB8_PF" },   //0.001x
-  
-  // PDU Output
-  {IR_LONG, 906, 0, "Output_I1" },       //0.01x
-  {IR_LONG, 908, 0, "Output_I2" },
-  {IR_LONG, 910, 0, "Output_I3" },
-  {IR_LONG, 1068, 0, "Output_IG" },
-  {IR_LONG, 1066, 0, "Output_IN" },
-  {IR_LONG, 924, 0, "Output_kVA1" },  //0.001
-  {IR_LONG, 926, 0, "Output_kVA2" },  
-  {IR_LONG, 928, 0, "Output_kVA3" },
-  {IR_LONG, 968, 0, "Output_kVAR" },      //0.001
-  {IR_LONG, 912, 0, "Output_kW1" },     //0.001x
-  {IR_LONG, 914, 0, "Output_kW2" },
-  {IR_LONG, 916, 0, "Output_kW3" },
-  {IR_LONG, 1086, 0, "Output_kWh" },
-  {IR_LONG, 1091, 0, "Output_PF" },        //0.001
-  {IR_LONG, 960, 0, "Output_V_AB" },
-  {IR_LONG, 900, 0, "Output_V_AN" },    //0.01x
-  {IR_LONG, 962, 0, "Output_V_BC" },
-  {IR_LONG, 902, 0, "Output_V_BN" },
-  {IR_LONG, 964, 0, "Output_V_CA" },
-  {IR_LONG, 904, 0, "Output_V_CN" },
-  
-  {IR, 1550, 0, "CB_Status" },
-  {IR, 1551, 0, "CB_Tripped" },
-};
-//Size of modbus map used in FOR cycles, automatically calculated.
-
-/**
- * @brief The total number of entries in the `mb_map` array.
- * This is calculated at compile time and used for iterating over the map.
- */
-const int map_size = sizeof(mb_map) / sizeof(mb_map[0]);
-
-/** @brief The main loop update interval in milliseconds. */
-int interval = 250; 
-/** @} */ // End of ModbusMapConfig group
-
-#endif // CONFIG_H
diff --git a/src/EPMS/PDU/PDU_Maverick_Power_TCP/main.cpp b/src/EPMS/PDU/PDU_Maverick_Power_TCP/main.cpp
deleted file mode 100644
index 286a98c..0000000
--- a/src/EPMS/PDU/PDU_Maverick_Power_TCP/main.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-/**
- * @file main.cpp
- * @brief Main execution program for the CRAH Unit (TCP) Emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * @details This file contains the main execution program for an Arduino-based emulator of a CRAH unit. 
- * The program uses a Wi-Fi connection to communicate via the Modbus IP protocol.
- *
- * The setup() function initializes the following:
- * - Serial communication for debugging.
- * - Wi-Fi connection using credentials from config.h.
- * - A Modbus TCP server.
- * - Modbus points (Coils, Holding Registers, etc.) based on a predefined map in config.h.
- *
- * The loop() function continuously:
- * - Services the Modbus TCP server to handle incoming requests.
- * - Periodically calls the main update loop for the emulated equipment, which
- *   manages state transitions and behavior strategies.
- *
- * @see config.h for Wi-Fi and Modbus configuration.
- * @see Equipment.h for the main equipment logic.
- * @see State.h for different equipment states.
- * @see Strategies/Strategy_Behavior.h for value generation strategies.
- * @see Modbus_Point.h for the base class for all Modbus points.
- */
-//=================================================================================================================================
-//Libraries and declaration of variables.
-#include <WiFi.h>
-#include "config.h"
-#include "ModbusPoints/Modbus_PointFactory.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-//=================================================================================================================================
-/** 
- * @brief Initializes the application.
- * @details This function runs once at startup. It configures the serial communication, 
- * Wi-Fi, and the Modbus server. It also creates and initializes all the Modbus points 
- * based on the `mb_map` array in `config.h`.
- */
-void setup() {
-  Serial.begin(115200);                       //Serial comm start
-  WiFi.config(local_IP, gateway, subnet);     // Wifi service start
-  WiFi.begin(ssid, password);
-  while (WiFi.status() != WL_CONNECTED) {
-    delay(1000);
-    Serial.print(".");
-  }
-  Serial.println("Connected!!");
-  mb.server();                                //Modbus server start
-  Serial.println("Server Created");
-  Serial.println(map_size);
-  for(int i = 0; i < map_size; i++){
-    Modbus_Point<ModbusIP>* point = createModbus_Point(&mb, mb_map[i].category, mb_map[i].address, mb_map[i].value, mb_map[i].description);
-    if (point) {
-      point->addToModbusServer();
-      EquipmentInstance.addModbus_Point(mb_map[i].description, point);
-    }
-  }
-  Serial.println("All modbus Points created");
-  Serial.println("Setup function ended");
-}
-//=================================================================================================================================
-/** 
- * @brief The main application loop.
- * @details This function runs repeatedly after setup() has completed. It performs two main actions:
- * 1. It continuously services the Modbus server by calling `mb.task()` to handle
- *    incoming requests from a Modbus master.
- * 2. At a fixed interval (defined in `config.h`), it calls `EquipmentInstance.update()`
- *    to run the emulator's internal state machine and behavior logic.
- */
-void loop() {
-  mb.task();
-  unsigned long currentMillis = millis();
-  if (currentMillis - previousMillis >= interval) {
-    previousMillis = currentMillis;
-    unsigned long startTime = millis();
-    EquipmentInstance.update();
-    unsigned long endTime = millis();
-    unsigned long elapsedTime = endTime - startTime;
-    Serial.printf("Control Execution time: %d ms\n", elapsedTime);
-  } 
-}
diff --git a/src/EPMS/POD/POD_MBB_Power_Meter_TCP/README.md b/src/EPMS/POD/POD_MBB_Power_Meter_TCP/README.md
deleted file mode 100644
index 355156f..0000000
--- a/src/EPMS/POD/POD_MBB_Power_Meter_TCP/README.md
+++ /dev/null
@@ -1,33 +0,0 @@
-# EQUIPMENT_TYPE MANUFACTURER MODEL TCP
-
-## Brief Introduction
-Equipment specifc details that make it different from other devices
-
-## List of Equipmentt
-This cofiguration has been used for these models:
-* **Model**: 09-15-22 
-* **Model**: 09-15-23 
-* **Model**: 09-15-25 
-
-## Hardware Prerequisites
-
-The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities.
-* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html) 
-
----
-
-## States and Strategies
-Provide a brief description of what variables and strategies were used in this configuraiton
-
-### Standby State
-* **Equipment running**: set to 0
-* **Common Alarm**: set to 0
-* **SAT temperature**: set to 85
-
-### Running State
-* **Equipment running**: set to 1
-* **SAT temperature**: **Ramp Strategy** set to 65 deg setpoint
-
-### Fail State
-* **Commong Alarm**: set to 1
-* **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset
diff --git a/src/EPMS/POD/POD_MBB_Power_Meter_TCP/State_Fail.cpp b/src/EPMS/POD/POD_MBB_Power_Meter_TCP/State_Fail.cpp
deleted file mode 100644
index 8bc0385..0000000
--- a/src/EPMS/POD/POD_MBB_Power_Meter_TCP/State_Fail.cpp
+++ /dev/null
@@ -1,81 +0,0 @@
-/**
- * @file State_Fail.cpp
- * @brief Implementation of the FailState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the FailState, which defines
- * the behavior of the equipment when it has entered a fault condition.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new FailState object with a list of active alarms.
- *
- * This constructor receives a list of alarm descriptions and creates strategies
- * to set the corresponding Modbus points to a value of 1, indicating an
- * active alarm. It also initializes a PID strategy for the 'CW Valve Position'
- * to maintain its state during the fault.
- * @param activeAlarms A vector of strings, where each string is the
- *                     description of a Modbus point to be set as an active alarm.
- */
-template<>
-FailState<ModbusIP>::FailState(const std::vector<std::string>& activeAlarms) {
-    // Simulate a failure: set common alarm and a specific fan alarm.
-
-    
-}
-
-/**
- * @brief Executes the fail state's logic for one update cycle.
- *
- * This method checks the "Alarm Reset" Modbus point for a command to
- * transition back to Standby, which would typically happen after a fault
- * is cleared by a user. If no transition is requested, it continues to apply
- * the failure strategies (e.g., keeping alarm bits active).
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* FailState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Fail update function");
-    
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the fail state.
- * Sets the "Alarm Common" point to 1 to indicate a general fault condition.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Fail State...");
-}
-
-/**
- * @brief Logic to execute once when exiting the fail state.
- * Clears the "Alarm Common" point to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Fail State...");
-}
\ No newline at end of file
diff --git a/src/EPMS/POD/POD_MBB_Power_Meter_TCP/State_Running.cpp b/src/EPMS/POD/POD_MBB_Power_Meter_TCP/State_Running.cpp
deleted file mode 100644
index b9e4a99..0000000
--- a/src/EPMS/POD/POD_MBB_Power_Meter_TCP/State_Running.cpp
+++ /dev/null
@@ -1,89 +0,0 @@
-/**
- * @file State_Running.cpp
- * @brief Implementation of the RunningState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the RunningState, which defines
- * the behavior of the equipment when it is actively running.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "Strategies/Strategy_Totalizer.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new RunningState object.
- *
- * This constructor initializes behavior strategies active during the running
- * state, such as a PID controller for the 'CW Valve Position' and totalizers
- * for the run-hours of each EC fan.
- */
-template<>
-RunningState<ModbusIP>::RunningState() {
-}
-
-/**
- * @brief Executes the running state's logic for one update cycle.
- *
- * This method first checks for state transition commands:
- * 1. It reads the "ON/OFF Command By BMS" point. If it's 0, it transitions to StandbyState.
- * 2. It reads the "Fault Code" point. If it's non-zero, it transitions to FailState,
- *    passing the corresponding alarm description.
- *
- * If no transition occurs, it applies the strategies defined for the running state.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* RunningState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Running update function");
-    
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the running state.
- * Sets the "Run Status" for all EC fans to 1 to indicate they are active.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Running State...");
-    // You could also update a Modbus register to show the "standby" state
-
-}
-
-/**
- * @brief Logic to execute once when exiting the running state.
- * Sets the "Run Status" for all EC fans to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Running State...");
-   
-}
\ No newline at end of file
diff --git a/src/EPMS/POD/POD_MBB_Power_Meter_TCP/State_Standby.cpp b/src/EPMS/POD/POD_MBB_Power_Meter_TCP/State_Standby.cpp
deleted file mode 100644
index 20029d1..0000000
--- a/src/EPMS/POD/POD_MBB_Power_Meter_TCP/State_Standby.cpp
+++ /dev/null
@@ -1,85 +0,0 @@
-/**
- * @file State_Standby.cpp
- * @brief Implementation of the StandbyState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the StandbyState, which defines
- * the behavior of the equipment when it is in an idle or standby mode.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-/**
- * @brief Constructs a new StandbyState object.
- *
- * In this state, the equipment is idle. This constructor initializes strategies
- * to bring the system to a safe, idle condition. It sets a stable value for
- * the SAT reading and creates ramp strategies to bring the CW valve and all
- * EC fan speeds down to zero.
- */
-template<>
-StandbyState<ModbusIP>::StandbyState() {
-    // You can add initialization code here if needed
-    
-
-}
-
-/**
- * @brief Executes the standby state's logic for one update cycle.
- *
- * This method applies the strategies defined for the standby state (e.g.,
- * ramping values to zero).
- *
- * @warning This method currently does not check for a command to transition to the
- *          Running state. This logic needs to be added to allow the unit to start.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* StandbyState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Standby update function");
-    
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the standby state.
- * This method performs cleanup by setting all alarm points and all EC fan
- * run status points to 0.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Standby State...");
-}
-
-/**
- * @brief Logic to execute once when exiting the standby state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Standby State...");
-}
\ No newline at end of file
diff --git a/src/EPMS/POD/POD_MBB_Power_Meter_TCP/config.h b/src/EPMS/POD/POD_MBB_Power_Meter_TCP/config.h
deleted file mode 100644
index 2eb6175..0000000
--- a/src/EPMS/POD/POD_MBB_Power_Meter_TCP/config.h
+++ /dev/null
@@ -1,93 +0,0 @@
-/**
- * @file config.h
- * @brief Main configuration file for the POD MBB Power Meter 
- * @author Zach Gutierrez
- * @date 2025-09-02
- *
- * This file contains two important configurations: WiFi network parameters
- * and the Modbus register map for the device.
- */
-
-#ifndef CONFIG_H
-#define CONFIG_H
-
-#include "core.h"
-#include "Equipment/Equipment.h"
-
-#if defined(USE_MODBUS_IP)
-/**
-   * @defgroup ModbusTCPConfig Modbus IP Configuration
-   * @brief Parameters for Modbus TCP communication.
-   * @{
-   */
-  #include <ModbusIP_ESP8266.h>
-  const char *ssid = "wifi_name";       /**< @brief The SSID of the WiFi network. */
-  const char *password = "wifi_password";   /**< @brief The password for the WiFi network. */
-  IPAddress local_IP(192, 168, 1, 234);       /**< @brief The static IP address for the device. */
-  IPAddress gateway(192, 168, 1, 1);          /**< @brief The gateway IP address. */
-  IPAddress subnet(255, 255, 255, 0);         /**< @brief The subnet mask. */
-  
-  ModbusIP mb;
-#else
-  /**
-   * @defgroup ModbusRTUConfig Modbus RTU Configuration
-   * @brief Parameters for serial Modbus RTU communication.
-   * @{
-   */
-  #include <ModbusRTU.h>
-  const int BAUDRATE = 19200;   /**< @brief The serial communication speed in bits per second. */
-  const int RX_PIN = 17;        /**< @brief The GPIO pin used for receiving data (RX). */
-  const int TX_PIN = 16;        /**< @brief The GPIO pin used for transmitting data (TX). */
-  const int RST_PIN = 4;        /**< @brief The GPIO pin connected to the RS485 driver's DE/RE pins for direction control. */
-  const int MODBUS_ID = 1;      /**< @brief The unique slave ID for this device on the Modbus bus. */
-  /** @} */
-
-  /** @brief Global instance of the Modbus RTU server. */
-  ModbusRTU mb;
-#endif
-
-
-
-/**
- * @defgroup ModbusMapConfig Modbus Map Configuration
- * @brief Defines the Modbus register map and related parameters for the emulator.
- * @{
- */
-/**
- * @brief The Modbus map for the Equipment device.
- * This array defines all the Modbus points available on the emulated device.
- * The `description` field is crucial as it's used to look up points within the application logic.
- */
-modbusMap mb_map[] = {
-  // ESP8266 Modbus server uses 0-based addressing, while Modbus Poll uses 1-based addressing.
-
-  // ANALOG VALUES (HOLDING REGISTERS - 4X) & 32-BIT (FLOATING POINT SPLIT INTO MOST SIGNIFICANT BIT + LEAST SIGNIFICANT BIT)
-  // HOLDING REGISTERS (4X) - FLOAT VALUES SPLIT INTO MSB & LSB
-  {HR_FLOAT, 99,  0, "Base Sts" },
-  {HR_FLOAT, 899, 0, "Freq" },
-  {HR_FLOAT, 910, 0, "PWR F" },
-  {HR_FLOAT, 199, 0, "Dev Tm" },
-  {HR_FLOAT, 350, 0, "Amp_A" },
-  {HR_FLOAT, 352, 0, "Arr_B" },
-  {HR_FLOAT, 354, 0, "Arr_C" },
-  {HR_FLOAT, 356, 0, "Amps_N" },
-  {HR_FLOAT, 364, 0, "Volts_AB" },
-  {HR_FLOAT, 366, 0, "Volts_BC" },
-  {HR_FLOAT, 368, 0, "Volts_CA" },
-  {HR_FLOAT, 370, 0, "kW" },
-  {HR_FLOAT, 372, 0, "kVA" },
-  {HR_FLOAT, 600, 0, "kWH" },
-};
-//Size of modbus map used in FOR cycles, automatically calculated.
-
-/**
- * @brief The total number of entries in the `mb_map` array.
- * This is calculated at compile time and used for iterating over the map.
- */
-const int map_size = sizeof(mb_map) / sizeof(mb_map[0]);
-
-/** @brief The main loop update interval in milliseconds. */
-int interval = 250; 
-/** @} */ // End of ModbusMapConfig group
-
-#endif // CONFIG_H
diff --git a/src/EPMS/POD/POD_MBB_Power_Meter_TCP/main.cpp b/src/EPMS/POD/POD_MBB_Power_Meter_TCP/main.cpp
deleted file mode 100644
index 286a98c..0000000
--- a/src/EPMS/POD/POD_MBB_Power_Meter_TCP/main.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-/**
- * @file main.cpp
- * @brief Main execution program for the CRAH Unit (TCP) Emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * @details This file contains the main execution program for an Arduino-based emulator of a CRAH unit. 
- * The program uses a Wi-Fi connection to communicate via the Modbus IP protocol.
- *
- * The setup() function initializes the following:
- * - Serial communication for debugging.
- * - Wi-Fi connection using credentials from config.h.
- * - A Modbus TCP server.
- * - Modbus points (Coils, Holding Registers, etc.) based on a predefined map in config.h.
- *
- * The loop() function continuously:
- * - Services the Modbus TCP server to handle incoming requests.
- * - Periodically calls the main update loop for the emulated equipment, which
- *   manages state transitions and behavior strategies.
- *
- * @see config.h for Wi-Fi and Modbus configuration.
- * @see Equipment.h for the main equipment logic.
- * @see State.h for different equipment states.
- * @see Strategies/Strategy_Behavior.h for value generation strategies.
- * @see Modbus_Point.h for the base class for all Modbus points.
- */
-//=================================================================================================================================
-//Libraries and declaration of variables.
-#include <WiFi.h>
-#include "config.h"
-#include "ModbusPoints/Modbus_PointFactory.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-//=================================================================================================================================
-/** 
- * @brief Initializes the application.
- * @details This function runs once at startup. It configures the serial communication, 
- * Wi-Fi, and the Modbus server. It also creates and initializes all the Modbus points 
- * based on the `mb_map` array in `config.h`.
- */
-void setup() {
-  Serial.begin(115200);                       //Serial comm start
-  WiFi.config(local_IP, gateway, subnet);     // Wifi service start
-  WiFi.begin(ssid, password);
-  while (WiFi.status() != WL_CONNECTED) {
-    delay(1000);
-    Serial.print(".");
-  }
-  Serial.println("Connected!!");
-  mb.server();                                //Modbus server start
-  Serial.println("Server Created");
-  Serial.println(map_size);
-  for(int i = 0; i < map_size; i++){
-    Modbus_Point<ModbusIP>* point = createModbus_Point(&mb, mb_map[i].category, mb_map[i].address, mb_map[i].value, mb_map[i].description);
-    if (point) {
-      point->addToModbusServer();
-      EquipmentInstance.addModbus_Point(mb_map[i].description, point);
-    }
-  }
-  Serial.println("All modbus Points created");
-  Serial.println("Setup function ended");
-}
-//=================================================================================================================================
-/** 
- * @brief The main application loop.
- * @details This function runs repeatedly after setup() has completed. It performs two main actions:
- * 1. It continuously services the Modbus server by calling `mb.task()` to handle
- *    incoming requests from a Modbus master.
- * 2. At a fixed interval (defined in `config.h`), it calls `EquipmentInstance.update()`
- *    to run the emulator's internal state machine and behavior logic.
- */
-void loop() {
-  mb.task();
-  unsigned long currentMillis = millis();
-  if (currentMillis - previousMillis >= interval) {
-    previousMillis = currentMillis;
-    unsigned long startTime = millis();
-    EquipmentInstance.update();
-    unsigned long endTime = millis();
-    unsigned long elapsedTime = endTime - startTime;
-    Serial.printf("Control Execution time: %d ms\n", elapsedTime);
-  } 
-}
diff --git a/src/EPMS/PQM/PQM_PM8000_TCP/README.md b/src/EPMS/PQM/PQM_PM8000_TCP/README.md
deleted file mode 100644
index 4f156e3..0000000
--- a/src/EPMS/PQM/PQM_PM8000_TCP/README.md
+++ /dev/null
@@ -1,48 +0,0 @@
-# Daikin Chiller (RTU) Emulator
-
-This project is an Arduino-based emulator for a Daikin Chiller unit, communicating over Modbus RTU. It is designed to be a flexible template that can be adapted to simulate different types of chillers by modifying the configuration and state logic.
-
-The emulator operates on a state machine with three core states:
-* **Standby**: The chiller is idle but ready.
-* **Running**: The chiller is active and operational.
-* **Fail**: The chiller has encountered a fault condition.
-
-## Features
-
-* **Modbus RTU Communication**: Emulates a Modbus slave device.
-* **State Machine Logic**: Simulates different operational states (Standby, Running, Fail).
-* **Dynamic Value Simulation**: Uses "Strategies" (e.g., PID, Ramp) to generate realistic, changing values for Modbus points.
-* **Configurable Modbus Map**: The entire Modbus register map is defined in a single, easy-to-modify file (`config.h`).
-* **Extensible Design**: The structure allows for the addition of new states and behaviors.
-
-## Hardware Prerequisites
-
-The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities and at least one hardware serial port for RS485 communication.
-
-* **Microcontroller**: ESP8266, ESP32, or similar.
-* **RS485 Transceiver**: A module like the MAX485 to interface with the Modbus RTU bus.
-
-## Software Dependencies
-
-This project relies on a Modbus library. Ensure you have the correct library installed in your Arduino IDE.
-
-* **Modbus Library**: The code uses a library that provides `ModbusRTU.h` and optionally `ModbusIP_ESP8266.h`.
-
----
-
-## How to Customize for a New Chiller
-
-To adapt this template for a new chiller, follow these steps.
-
-### 1. Configure Device-Specific Parameters (`config.h`)
-
-Open `CH_Daikin_AWV026B_RTU/config.h`. This is the main file for device-specific settings.
-
-#### Modbus RTU Settings
-Update the following constants for your device's serial communication setup.
-```c++
-const int BAUDRATE = 19200;   // The serial communication speed
-const int RX_PIN = 17;        // The GPIO pin for receiving data (RX)
-const int TX_PIN = 16;        // The GPIO pin for transmitting data (TX)
-const int RST_PIN = 4;        // The GPIO pin for RS485 direction control
-const int MODBUS_ID = 1;      // The unique slave ID for this device
\ No newline at end of file
diff --git a/src/EPMS/PQM/PQM_PM8000_TCP/State_Fail.cpp b/src/EPMS/PQM/PQM_PM8000_TCP/State_Fail.cpp
deleted file mode 100644
index 8bc0385..0000000
--- a/src/EPMS/PQM/PQM_PM8000_TCP/State_Fail.cpp
+++ /dev/null
@@ -1,81 +0,0 @@
-/**
- * @file State_Fail.cpp
- * @brief Implementation of the FailState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the FailState, which defines
- * the behavior of the equipment when it has entered a fault condition.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new FailState object with a list of active alarms.
- *
- * This constructor receives a list of alarm descriptions and creates strategies
- * to set the corresponding Modbus points to a value of 1, indicating an
- * active alarm. It also initializes a PID strategy for the 'CW Valve Position'
- * to maintain its state during the fault.
- * @param activeAlarms A vector of strings, where each string is the
- *                     description of a Modbus point to be set as an active alarm.
- */
-template<>
-FailState<ModbusIP>::FailState(const std::vector<std::string>& activeAlarms) {
-    // Simulate a failure: set common alarm and a specific fan alarm.
-
-    
-}
-
-/**
- * @brief Executes the fail state's logic for one update cycle.
- *
- * This method checks the "Alarm Reset" Modbus point for a command to
- * transition back to Standby, which would typically happen after a fault
- * is cleared by a user. If no transition is requested, it continues to apply
- * the failure strategies (e.g., keeping alarm bits active).
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* FailState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Fail update function");
-    
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the fail state.
- * Sets the "Alarm Common" point to 1 to indicate a general fault condition.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Fail State...");
-}
-
-/**
- * @brief Logic to execute once when exiting the fail state.
- * Clears the "Alarm Common" point to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Fail State...");
-}
\ No newline at end of file
diff --git a/src/EPMS/PQM/PQM_PM8000_TCP/State_Running.cpp b/src/EPMS/PQM/PQM_PM8000_TCP/State_Running.cpp
deleted file mode 100644
index e60e869..0000000
--- a/src/EPMS/PQM/PQM_PM8000_TCP/State_Running.cpp
+++ /dev/null
@@ -1,132 +0,0 @@
-/**
- * @file State_Running.cpp
- * @brief Implementation of the RunningState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the RunningState, which defines
- * the behavior of the equipment when it is actively running.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "Strategies/Strategy_Totalizer.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new RunningState object.
- *
- * This constructor initializes behavior strategies active during the running
- * state, such as a PID controller for the 'CW Valve Position' and totalizers
- * for the run-hours of each EC fan.
- */
-template<>
-RunningState<ModbusIP>::RunningState() {
-  addStrategy("Volts AB", new SingleValueStrategy(480.0F, 5.0f, 1000));
-  addStrategy("Volts BC", new SingleValueStrategy(480.0F, 5.0f, 1000));
-  addStrategy("Volts CA", new SingleValueStrategy(480.0F, 5.0f, 1000));
-
-  addStrategy("PF", new SingleValueStrategy(0.9f, 0.05f, 1000));
-
-  addStrategy("Amps A", new SingleValueStrategy(1.0f, 10.0f, 1000));
-  addStrategy("Amps B", new SingleValueStrategy(1.0f, 10.0f, 1000));
-  addStrategy("Amps C", new SingleValueStrategy(1.0f, 10.0f, 1000));
-}
-
-/**
- * @brief Executes the running state's logic for one update cycle.
- *
- * This method first checks for state transition commands:
- * 1. It reads the "ON/OFF Command By BMS" point. If it's 0, it transitions to StandbyState.
- * 2. It reads the "Fault Code" point. If it's non-zero, it transitions to FailState,
- *    passing the corresponding alarm description.
- *
- * If no transition occurs, it applies the strategies defined for the running state.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* RunningState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Running update function");
-    float State_Ctrl = getPointValue(equipment, "Powered");
-    if (State_Ctrl == 1){
-      return new StandbyState<ModbusIP>();
-    }
-    // Apply any strategies defined for the standby state
-    float volts_AB = getPointValue(equipment, "Volts AB");
-    float volts_BC = getPointValue(equipment, "Volts BC");
-    float volts_AC = getPointValue(equipment, "Volts CA");
-
-    setPointValue(equipment, "Volts AN", volts_AB/1.732);
-    setPointValue(equipment, "Volts BN", volts_BC/1.732);
-    setPointValue(equipment, "Volts CN", volts_AC/1.732);
-
-
-    int I_load = getPointValue(equipment, "Load");
-    int I_rating = getPointValue(equipment, "Rating");
-    float load = static_cast<float>(I_load);
-    float rating = static_cast<float>(I_rating);
-    float real_load = rating * (load/100.0f);
-    Strategy_Behavior* ampsA_svs = getStrategy("Amps A");
-    Strategy_Behavior* ampsB_svs = getStrategy("Amps B");
-    Strategy_Behavior* ampsC_svs = getStrategy("Amps C");
-
-    static_cast<SingleValueStrategy*>(ampsA_svs)->setSetpoint(real_load);
-    static_cast<SingleValueStrategy*>(ampsB_svs)->setSetpoint(real_load);
-    static_cast<SingleValueStrategy*>(ampsC_svs)->setSetpoint(real_load);
-
-    float pf = getPointValue(equipment, "PF");
-
-
-    float kw = (1.732f * ((volts_AB + volts_BC + volts_AC)/3.0f) * real_load * pf)/1000;
-    float kva = (1.732f * ((volts_AB + volts_BC + volts_AC)/3.0f) * real_load)/1000;
-
-    setPointValue(equipment, "kW", kw);
-    setPointValue(equipment, "kVA", kva);
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the running state.
- * Sets the "Run Status" for all EC fans to 1 to indicate they are active.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Running State...");
-    // You could also update a Modbus register to show the "standby" state
-
-}
-
-/**
- * @brief Logic to execute once when exiting the running state.
- * Sets the "Run Status" for all EC fans to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Running State...");
-   
-}
\ No newline at end of file
diff --git a/src/EPMS/PQM/PQM_PM8000_TCP/State_Standby.cpp b/src/EPMS/PQM/PQM_PM8000_TCP/State_Standby.cpp
deleted file mode 100644
index 0600853..0000000
--- a/src/EPMS/PQM/PQM_PM8000_TCP/State_Standby.cpp
+++ /dev/null
@@ -1,100 +0,0 @@
-/**
- * @file State_Standby.cpp
- * @brief Implementation of the StandbyState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the StandbyState, which defines
- * the behavior of the equipment when it is in an idle or standby mode.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-/**
- * @brief Constructs a new StandbyState object.
- *
- * In this state, the equipment is idle. This constructor initializes strategies
- * to bring the system to a safe, idle condition. It sets a stable value for
- * the SAT reading and creates ramp strategies to bring the CW valve and all
- * EC fan speeds down to zero.
- */
-template<>
-StandbyState<ModbusIP>::StandbyState() {
-    // You can add initialization code here if needed
-    
-
-}
-
-/**
- * @brief Executes the standby state's logic for one update cycle.
- *
- * This method applies the strategies defined for the standby state (e.g.,
- * ramping values to zero).
- *
- * @warning This method currently does not check for a command to transition to the
- *          Running state. This logic needs to be added to allow the unit to start.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* StandbyState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Standby update function");
-    float State_Ctrl = getPointValue(equipment, "Powered");
-    if (State_Ctrl == 2){
-      return new RunningState<ModbusIP>();
-    }
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the standby state.
- * This method performs cleanup by setting all alarm points and all EC fan
- * run status points to 0.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Standby State...");
-    setPointValue(equipment, "Volts AB", 0.0f);
-    setPointValue(equipment, "Volts BC", 0.0f);
-    setPointValue(equipment, "Volts CA", 0.0f);
-    setPointValue(equipment, "Volts AN", 0.0f);
-    setPointValue(equipment, "Volts BN", 0.0f);
-    setPointValue(equipment, "Volts CN", 0.0f);
-    setPointValue(equipment, "PF", 0.0f);
-    setPointValue(equipment, "Amps A", 0.0f);
-    setPointValue(equipment, "Amps B", 0.0f);
-    setPointValue(equipment, "Amps C", 0.0f);
-    setPointValue(equipment, "kW", 0.0f);
-    setPointValue(equipment, "kVA", 0.0f);
-}
-
-/**
- * @brief Logic to execute once when exiting the standby state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Standby State...");
-}
\ No newline at end of file
diff --git a/src/EPMS/PQM/PQM_PM8000_TCP/config.h b/src/EPMS/PQM/PQM_PM8000_TCP/config.h
deleted file mode 100644
index cbbabd6..0000000
--- a/src/EPMS/PQM/PQM_PM8000_TCP/config.h
+++ /dev/null
@@ -1,95 +0,0 @@
-/**
- * @file config.h
- * @brief Main configuration file for the CRAH Unit (TCP) emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * This file contains two important configurations: WiFi network parameters
- * and the Modbus register map for the device.
- */
-
-#ifndef CONFIG_H
-#define CONFIG_H
-
-#include "core.h"
-#include "Equipment/Equipment.h"
-
-#if defined(USE_MODBUS_IP)
-/**
-   * @defgroup ModbusTCPConfig Modbus IP Configuration
-   * @brief Parameters for Modbus TCP communication.
-   * @{
-   */
-  #include <ModbusIP_ESP8266.h>
-  const char *ssid = "QTS_CDR_Arduino";       /**< @brief The SSID of the WiFi network. */
-  const char *password = "123abc456";   /**< @brief The password for the WiFi network. */
-  IPAddress local_IP(172, 17, 30, 241);       /**< @brief The static IP address for the device. */
-  IPAddress gateway(172, 17, 30, 1);          /**< @brief The gateway IP address. */
-  IPAddress subnet(255, 255, 255, 0);         /**< @brief The subnet mask. */
-  
-  ModbusIP mb;
-#else
-  /**
-   * @defgroup ModbusRTUConfig Modbus RTU Configuration
-   * @brief Parameters for serial Modbus RTU communication.
-   * @{
-   */
-  #include <ModbusRTU.h>
-  const int BAUDRATE = 19200;   /**< @brief The serial communication speed in bits per second. */
-  const int RX_PIN = 17;        /**< @brief The GPIO pin used for receiving data (RX). */
-  const int TX_PIN = 16;        /**< @brief The GPIO pin used for transmitting data (TX). */
-  const int RST_PIN = 4;        /**< @brief The GPIO pin connected to the RS485 driver's DE/RE pins for direction control. */
-  const int MODBUS_ID = 1;      /**< @brief The unique slave ID for this device on the Modbus bus. */
-  /** @} */
-
-  /** @brief Global instance of the Modbus RTU server. */
-  ModbusRTU mb;
-#endif
-
-
-
-/**
- * @defgroup ModbusMapConfig Modbus Map Configuration
- * @brief Defines the Modbus register map and related parameters for the emulator.
- * @{
- */
-/**
- * @brief The Modbus map for the Equipment device.
- * This array defines all the Modbus points available on the emulated device.
- * The `description` field is crucial as it's used to look up points within the application logic.
- */
-modbusMap mb_map[] =
-{   
-  {HR,        9,     0,  "Powered"},
-  {HR,        10,     0,  "Load"},  //Internal to control from Modscan
-  {HR,        11,     0,  "Rating"},   //Internal Fault code from Modscan  
-  
-  {HR_FLOAT,  2699,   0,  "kWh"},                  
-  {HR_FLOAT,  2999,   0,  "Amps A"},                     
-  {HR_FLOAT,  3001,   0,  "Amps B"},                   
-  {HR_FLOAT,  3003,   0,  "Amps C"},                 
-  {HR_FLOAT,  3005,   0,  "Amps N"},                  
-  {HR_FLOAT,  3019,   0,  "Volts AB"},   
-  {HR_FLOAT,  3021,   0,  "Volts BC"},          
-  {HR_FLOAT,  3023,   0,  "Volts CA"},
-  {HR_FLOAT,  3027,   0,  "Volts AN"},              
-  {HR_FLOAT,  3029,   0,  "Volts BN"},         
-  {HR_FLOAT,  3031,   0,  "Volts CN"},         //May need to add moe points once I get clarification from Casne                   
-  {HR_FLOAT,  3059,   0,  "kW"},                 
-  {HR_FLOAT,  3075,   0,  "kVA"},                  
-  {HR_FLOAT,  3109,   0,  "Frequency"},                 
-  {HR_FLOAT,  3149,   0,  "PF"},   
-};
-//Size of modbus map used in FOR cycles, automatically calculated.
-
-/**
- * @brief The total number of entries in the `mb_map` array.
- * This is calculated at compile time and used for iterating over the map.
- */
-const int map_size = sizeof(mb_map) / sizeof(mb_map[0]);
-
-/** @brief The main loop update interval in milliseconds. */
-int interval = 250; 
-/** @} */ // End of ModbusMapConfig group
-
-#endif // CONFIG_H
diff --git a/src/EPMS/PQM/PQM_PM8000_TCP/main.cpp b/src/EPMS/PQM/PQM_PM8000_TCP/main.cpp
deleted file mode 100644
index 286a98c..0000000
--- a/src/EPMS/PQM/PQM_PM8000_TCP/main.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-/**
- * @file main.cpp
- * @brief Main execution program for the CRAH Unit (TCP) Emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * @details This file contains the main execution program for an Arduino-based emulator of a CRAH unit. 
- * The program uses a Wi-Fi connection to communicate via the Modbus IP protocol.
- *
- * The setup() function initializes the following:
- * - Serial communication for debugging.
- * - Wi-Fi connection using credentials from config.h.
- * - A Modbus TCP server.
- * - Modbus points (Coils, Holding Registers, etc.) based on a predefined map in config.h.
- *
- * The loop() function continuously:
- * - Services the Modbus TCP server to handle incoming requests.
- * - Periodically calls the main update loop for the emulated equipment, which
- *   manages state transitions and behavior strategies.
- *
- * @see config.h for Wi-Fi and Modbus configuration.
- * @see Equipment.h for the main equipment logic.
- * @see State.h for different equipment states.
- * @see Strategies/Strategy_Behavior.h for value generation strategies.
- * @see Modbus_Point.h for the base class for all Modbus points.
- */
-//=================================================================================================================================
-//Libraries and declaration of variables.
-#include <WiFi.h>
-#include "config.h"
-#include "ModbusPoints/Modbus_PointFactory.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-//=================================================================================================================================
-/** 
- * @brief Initializes the application.
- * @details This function runs once at startup. It configures the serial communication, 
- * Wi-Fi, and the Modbus server. It also creates and initializes all the Modbus points 
- * based on the `mb_map` array in `config.h`.
- */
-void setup() {
-  Serial.begin(115200);                       //Serial comm start
-  WiFi.config(local_IP, gateway, subnet);     // Wifi service start
-  WiFi.begin(ssid, password);
-  while (WiFi.status() != WL_CONNECTED) {
-    delay(1000);
-    Serial.print(".");
-  }
-  Serial.println("Connected!!");
-  mb.server();                                //Modbus server start
-  Serial.println("Server Created");
-  Serial.println(map_size);
-  for(int i = 0; i < map_size; i++){
-    Modbus_Point<ModbusIP>* point = createModbus_Point(&mb, mb_map[i].category, mb_map[i].address, mb_map[i].value, mb_map[i].description);
-    if (point) {
-      point->addToModbusServer();
-      EquipmentInstance.addModbus_Point(mb_map[i].description, point);
-    }
-  }
-  Serial.println("All modbus Points created");
-  Serial.println("Setup function ended");
-}
-//=================================================================================================================================
-/** 
- * @brief The main application loop.
- * @details This function runs repeatedly after setup() has completed. It performs two main actions:
- * 1. It continuously services the Modbus server by calling `mb.task()` to handle
- *    incoming requests from a Modbus master.
- * 2. At a fixed interval (defined in `config.h`), it calls `EquipmentInstance.update()`
- *    to run the emulator's internal state machine and behavior logic.
- */
-void loop() {
-  mb.task();
-  unsigned long currentMillis = millis();
-  if (currentMillis - previousMillis >= interval) {
-    previousMillis = currentMillis;
-    unsigned long startTime = millis();
-    EquipmentInstance.update();
-    unsigned long endTime = millis();
-    unsigned long elapsedTime = endTime - startTime;
-    Serial.printf("Control Execution time: %d ms\n", elapsedTime);
-  } 
-}
diff --git a/src/EPMS/PQM/PQM_PM9000_TCP/README.md b/src/EPMS/PQM/PQM_PM9000_TCP/README.md
deleted file mode 100644
index 4f156e3..0000000
--- a/src/EPMS/PQM/PQM_PM9000_TCP/README.md
+++ /dev/null
@@ -1,48 +0,0 @@
-# Daikin Chiller (RTU) Emulator
-
-This project is an Arduino-based emulator for a Daikin Chiller unit, communicating over Modbus RTU. It is designed to be a flexible template that can be adapted to simulate different types of chillers by modifying the configuration and state logic.
-
-The emulator operates on a state machine with three core states:
-* **Standby**: The chiller is idle but ready.
-* **Running**: The chiller is active and operational.
-* **Fail**: The chiller has encountered a fault condition.
-
-## Features
-
-* **Modbus RTU Communication**: Emulates a Modbus slave device.
-* **State Machine Logic**: Simulates different operational states (Standby, Running, Fail).
-* **Dynamic Value Simulation**: Uses "Strategies" (e.g., PID, Ramp) to generate realistic, changing values for Modbus points.
-* **Configurable Modbus Map**: The entire Modbus register map is defined in a single, easy-to-modify file (`config.h`).
-* **Extensible Design**: The structure allows for the addition of new states and behaviors.
-
-## Hardware Prerequisites
-
-The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities and at least one hardware serial port for RS485 communication.
-
-* **Microcontroller**: ESP8266, ESP32, or similar.
-* **RS485 Transceiver**: A module like the MAX485 to interface with the Modbus RTU bus.
-
-## Software Dependencies
-
-This project relies on a Modbus library. Ensure you have the correct library installed in your Arduino IDE.
-
-* **Modbus Library**: The code uses a library that provides `ModbusRTU.h` and optionally `ModbusIP_ESP8266.h`.
-
----
-
-## How to Customize for a New Chiller
-
-To adapt this template for a new chiller, follow these steps.
-
-### 1. Configure Device-Specific Parameters (`config.h`)
-
-Open `CH_Daikin_AWV026B_RTU/config.h`. This is the main file for device-specific settings.
-
-#### Modbus RTU Settings
-Update the following constants for your device's serial communication setup.
-```c++
-const int BAUDRATE = 19200;   // The serial communication speed
-const int RX_PIN = 17;        // The GPIO pin for receiving data (RX)
-const int TX_PIN = 16;        // The GPIO pin for transmitting data (TX)
-const int RST_PIN = 4;        // The GPIO pin for RS485 direction control
-const int MODBUS_ID = 1;      // The unique slave ID for this device
\ No newline at end of file
diff --git a/src/EPMS/PQM/PQM_PM9000_TCP/State_Fail.cpp b/src/EPMS/PQM/PQM_PM9000_TCP/State_Fail.cpp
deleted file mode 100644
index 8bc0385..0000000
--- a/src/EPMS/PQM/PQM_PM9000_TCP/State_Fail.cpp
+++ /dev/null
@@ -1,81 +0,0 @@
-/**
- * @file State_Fail.cpp
- * @brief Implementation of the FailState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the FailState, which defines
- * the behavior of the equipment when it has entered a fault condition.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new FailState object with a list of active alarms.
- *
- * This constructor receives a list of alarm descriptions and creates strategies
- * to set the corresponding Modbus points to a value of 1, indicating an
- * active alarm. It also initializes a PID strategy for the 'CW Valve Position'
- * to maintain its state during the fault.
- * @param activeAlarms A vector of strings, where each string is the
- *                     description of a Modbus point to be set as an active alarm.
- */
-template<>
-FailState<ModbusIP>::FailState(const std::vector<std::string>& activeAlarms) {
-    // Simulate a failure: set common alarm and a specific fan alarm.
-
-    
-}
-
-/**
- * @brief Executes the fail state's logic for one update cycle.
- *
- * This method checks the "Alarm Reset" Modbus point for a command to
- * transition back to Standby, which would typically happen after a fault
- * is cleared by a user. If no transition is requested, it continues to apply
- * the failure strategies (e.g., keeping alarm bits active).
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* FailState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Fail update function");
-    
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the fail state.
- * Sets the "Alarm Common" point to 1 to indicate a general fault condition.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Fail State...");
-}
-
-/**
- * @brief Logic to execute once when exiting the fail state.
- * Clears the "Alarm Common" point to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Fail State...");
-}
\ No newline at end of file
diff --git a/src/EPMS/PQM/PQM_PM9000_TCP/State_Running.cpp b/src/EPMS/PQM/PQM_PM9000_TCP/State_Running.cpp
deleted file mode 100644
index 8e3480f..0000000
--- a/src/EPMS/PQM/PQM_PM9000_TCP/State_Running.cpp
+++ /dev/null
@@ -1,132 +0,0 @@
-/**
- * @file State_Running.cpp
- * @brief Implementation of the RunningState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the RunningState, which defines
- * the behavior of the equipment when it is actively running.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "Strategies/Strategy_Totalizer.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new RunningState object.
- *
- * This constructor initializes behavior strategies active during the running
- * state, such as a PID controller for the 'CW Valve Position' and totalizers
- * for the run-hours of each EC fan.
- */
-template<>
-RunningState<ModbusIP>::RunningState() {
-  addStrategy("Volts AB", new SingleValueStrategy(480.0F, 5.0f, 1000));
-  addStrategy("Volts BC", new SingleValueStrategy(480.0F, 5.0f, 1000));
-  addStrategy("Volts CA", new SingleValueStrategy(480.0F, 5.0f, 1000));
-
-  addStrategy("PF", new SingleValueStrategy(0.9f, 0.05f, 1000));
-  addStrategy("Frequency", new SingleValueStrategy(60.0f, 0.7f, 1000));
-  addStrategy("Amps A", new SingleValueStrategy(1.0f, 10.0f, 1000));
-  addStrategy("Amps B", new SingleValueStrategy(1.0f, 10.0f, 1000));
-  addStrategy("Amps C", new SingleValueStrategy(1.0f, 10.0f, 1000));
-}
-
-/**
- * @brief Executes the running state's logic for one update cycle.
- *
- * This method first checks for state transition commands:
- * 1. It reads the "ON/OFF Command By BMS" point. If it's 0, it transitions to StandbyState.
- * 2. It reads the "Fault Code" point. If it's non-zero, it transitions to FailState,
- *    passing the corresponding alarm description.
- *
- * If no transition occurs, it applies the strategies defined for the running state.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* RunningState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Running update function");
-    float State_Ctrl = getPointValue(equipment, "Powered");
-    if (State_Ctrl == 1){
-      return new StandbyState<ModbusIP>();
-    }
-    // Apply any strategies defined for the standby state
-    float volts_AB = getPointValue(equipment, "Volts AB");
-    float volts_BC = getPointValue(equipment, "Volts BC");
-    float volts_AC = getPointValue(equipment, "Volts CA");
-
-    setPointValue(equipment, "Volts AN", volts_AB/1.732);
-    setPointValue(equipment, "Volts BN", volts_BC/1.732);
-    setPointValue(equipment, "Volts CN", volts_AC/1.732);
-
-
-    int I_load = getPointValue(equipment, "Load");
-    int I_rating = getPointValue(equipment, "Rating");
-    float load = static_cast<float>(I_load);
-    float rating = static_cast<float>(I_rating);
-    float real_load = rating * (load/100.0f);
-    Strategy_Behavior* ampsA_svs = getStrategy("Amps A");
-    Strategy_Behavior* ampsB_svs = getStrategy("Amps B");
-    Strategy_Behavior* ampsC_svs = getStrategy("Amps C");
-
-    static_cast<SingleValueStrategy*>(ampsA_svs)->setSetpoint(real_load);
-    static_cast<SingleValueStrategy*>(ampsB_svs)->setSetpoint(real_load);
-    static_cast<SingleValueStrategy*>(ampsC_svs)->setSetpoint(real_load);
-
-    float pf = getPointValue(equipment, "PF");
-
-
-    float kw = (1.732f * ((volts_AB + volts_BC + volts_AC)/3.0f) * real_load * pf)/1000;
-    float kva = (1.732f * ((volts_AB + volts_BC + volts_AC)/3.0f) * real_load)/1000;
-
-    setPointValue(equipment, "kW", kw);
-    setPointValue(equipment, "kVA", kva);
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the running state.
- * Sets the "Run Status" for all EC fans to 1 to indicate they are active.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Running State...");
-    // You could also update a Modbus register to show the "standby" state
-
-}
-
-/**
- * @brief Logic to execute once when exiting the running state.
- * Sets the "Run Status" for all EC fans to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Running State...");
-   
-}
\ No newline at end of file
diff --git a/src/EPMS/PQM/PQM_PM9000_TCP/State_Standby.cpp b/src/EPMS/PQM/PQM_PM9000_TCP/State_Standby.cpp
deleted file mode 100644
index 65ab9ca..0000000
--- a/src/EPMS/PQM/PQM_PM9000_TCP/State_Standby.cpp
+++ /dev/null
@@ -1,101 +0,0 @@
-/**
- * @file State_Standby.cpp
- * @brief Implementation of the StandbyState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the StandbyState, which defines
- * the behavior of the equipment when it is in an idle or standby mode.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-/**
- * @brief Constructs a new StandbyState object.
- *
- * In this state, the equipment is idle. This constructor initializes strategies
- * to bring the system to a safe, idle condition. It sets a stable value for
- * the SAT reading and creates ramp strategies to bring the CW valve and all
- * EC fan speeds down to zero.
- */
-template<>
-StandbyState<ModbusIP>::StandbyState() {
-    // You can add initialization code here if needed
-    
-
-}
-
-/**
- * @brief Executes the standby state's logic for one update cycle.
- *
- * This method applies the strategies defined for the standby state (e.g.,
- * ramping values to zero).
- *
- * @warning This method currently does not check for a command to transition to the
- *          Running state. This logic needs to be added to allow the unit to start.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* StandbyState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Standby update function");
-    float State_Ctrl = getPointValue(equipment, "Powered");
-    if (State_Ctrl == 2){
-      return new RunningState<ModbusIP>();
-    }
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the standby state.
- * This method performs cleanup by setting all alarm points and all EC fan
- * run status points to 0.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Standby State...");
-    setPointValue(equipment, "Volts AB", 0.0f);
-    setPointValue(equipment, "Volts BC", 0.0f);
-    setPointValue(equipment, "Volts CA", 0.0f);
-    setPointValue(equipment, "Volts AN", 0.0f);
-    setPointValue(equipment, "Volts BN", 0.0f);
-    setPointValue(equipment, "Volts CN", 0.0f);
-    setPointValue(equipment, "PF", 0.0f);
-    setPointValue(equipment, "Amps A", 0.0f);
-    setPointValue(equipment, "Amps B", 0.0f);
-    setPointValue(equipment, "Amps C", 0.0f);
-    setPointValue(equipment, "kW", 0.0f);
-    setPointValue(equipment, "kVA", 0.0f);
-    setPointValue(equipment, "Frequency", 0.0f);
-}
-
-/**
- * @brief Logic to execute once when exiting the standby state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Standby State...");
-}
\ No newline at end of file
diff --git a/src/EPMS/PQM/PQM_PM9000_TCP/config.h b/src/EPMS/PQM/PQM_PM9000_TCP/config.h
deleted file mode 100644
index 8886755..0000000
--- a/src/EPMS/PQM/PQM_PM9000_TCP/config.h
+++ /dev/null
@@ -1,97 +0,0 @@
-/**
- * @file config.h
- * @brief Main configuration file for the CRAH Unit (TCP) emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * This file contains two important configurations: WiFi network parameters
- * and the Modbus register map for the device.
- */
-
-#ifndef CONFIG_H
-#define CONFIG_H
-
-#include "core.h"
-#include "Equipment/Equipment.h"
-
-#if defined(USE_MODBUS_IP)
-/**
-   * @defgroup ModbusTCPConfig Modbus IP Configuration
-   * @brief Parameters for Modbus TCP communication.
-   * @{
-   */
-  #include <ModbusIP_ESP8266.h>
-  const char *ssid = "QTS_CDR_Arduino";       /**< @brief The SSID of the WiFi network. */
-  const char *password = "123abc456";   /**< @brief The password for the WiFi network. */
-  IPAddress local_IP(172, 17, 33, 174);       /**< @brief The static IP address for the device. */
-  IPAddress gateway(172, 17, 33, 1);          /**< @brief The gateway IP address. */
-  IPAddress subnet(255, 255, 255, 0);         /**< @brief The subnet mask. */
-  
-  ModbusIP mb;
-#else
-  /**
-   * @defgroup ModbusRTUConfig Modbus RTU Configuration
-   * @brief Parameters for serial Modbus RTU communication.
-   * @{
-   */
-  #include <ModbusRTU.h>
-  const int BAUDRATE = 19200;   /**< @brief The serial communication speed in bits per second. */
-  const int RX_PIN = 17;        /**< @brief The GPIO pin used for receiving data (RX). */
-  const int TX_PIN = 16;        /**< @brief The GPIO pin used for transmitting data (TX). */
-  const int RST_PIN = 4;        /**< @brief The GPIO pin connected to the RS485 driver's DE/RE pins for direction control. */
-  const int MODBUS_ID = 1;      /**< @brief The unique slave ID for this device on the Modbus bus. */
-  /** @} */
-
-  /** @brief Global instance of the Modbus RTU server. */
-  ModbusRTU mb;
-#endif
-
-
-
-/**
- * @defgroup ModbusMapConfig Modbus Map Configuration
- * @brief Defines the Modbus register map and related parameters for the emulator.
- * @{
- */
-/**
- * @brief The Modbus map for the Equipment device.
- * This array defines all the Modbus points available on the emulated device.
- * The `description` field is crucial as it's used to look up points within the application logic.
- */
-modbusMap mb_map[] =
-{   
-  {HR,        9,     0,  "Powered"},
-  {HR,        10,     0,  "Load"},  //Internal to control from Modscan
-  {HR,        11,     0,  "Rating"},   //Internal Fault code from Modscan  
-  
-  {HR_FLOAT,  2699,   0,  "kWh"},                  
-  {HR_FLOAT,  2999,   0,  "Amps A"},                     
-  {HR_FLOAT,  3001,   0,  "Amps B"},                   
-  {HR_FLOAT,  3003,   0,  "Amps C"},                 
-  {HR_FLOAT,  3005,   0,  "Amps N"},                  
-  {HR_FLOAT,  3019,   0,  "Volts AB"},   
-  {HR_FLOAT,  3021,   0,  "Volts BC"},          
-  {HR_FLOAT,  3023,   0,  "Volts CA"},
-  {HR_FLOAT,  3025,   0,  "Volts LL Avg"},
-  {HR_FLOAT,  3027,   0,  "Volts AN"},              
-  {HR_FLOAT,  3029,   0,  "Volts BN"},         
-  {HR_FLOAT,  3031,   0,  "Volts CN"},         //May need to add moe points once I get clarification from Casne                   
-  {HR_FLOAT,  3051,   0,  "Voltage Unbalanced"},                 
-  {HR_FLOAT,  3059,   0,  "kW"}, 
-  {HR_FLOAT,  3075,   0,  "kVA"},                  
-  {HR_FLOAT,  3109,   0,  "Frequency"},                 
-  {HR_FLOAT,  3149,   0,  "PF"},   
-};
-//Size of modbus map used in FOR cycles, automatically calculated.
-
-/**
- * @brief The total number of entries in the `mb_map` array.
- * This is calculated at compile time and used for iterating over the map.
- */
-const int map_size = sizeof(mb_map) / sizeof(mb_map[0]);
-
-/** @brief The main loop update interval in milliseconds. */
-int interval = 250; 
-/** @} */ // End of ModbusMapConfig group
-
-#endif // CONFIG_H
diff --git a/src/EPMS/PQM/PQM_PM9000_TCP/main.cpp b/src/EPMS/PQM/PQM_PM9000_TCP/main.cpp
deleted file mode 100644
index 286a98c..0000000
--- a/src/EPMS/PQM/PQM_PM9000_TCP/main.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-/**
- * @file main.cpp
- * @brief Main execution program for the CRAH Unit (TCP) Emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * @details This file contains the main execution program for an Arduino-based emulator of a CRAH unit. 
- * The program uses a Wi-Fi connection to communicate via the Modbus IP protocol.
- *
- * The setup() function initializes the following:
- * - Serial communication for debugging.
- * - Wi-Fi connection using credentials from config.h.
- * - A Modbus TCP server.
- * - Modbus points (Coils, Holding Registers, etc.) based on a predefined map in config.h.
- *
- * The loop() function continuously:
- * - Services the Modbus TCP server to handle incoming requests.
- * - Periodically calls the main update loop for the emulated equipment, which
- *   manages state transitions and behavior strategies.
- *
- * @see config.h for Wi-Fi and Modbus configuration.
- * @see Equipment.h for the main equipment logic.
- * @see State.h for different equipment states.
- * @see Strategies/Strategy_Behavior.h for value generation strategies.
- * @see Modbus_Point.h for the base class for all Modbus points.
- */
-//=================================================================================================================================
-//Libraries and declaration of variables.
-#include <WiFi.h>
-#include "config.h"
-#include "ModbusPoints/Modbus_PointFactory.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-//=================================================================================================================================
-/** 
- * @brief Initializes the application.
- * @details This function runs once at startup. It configures the serial communication, 
- * Wi-Fi, and the Modbus server. It also creates and initializes all the Modbus points 
- * based on the `mb_map` array in `config.h`.
- */
-void setup() {
-  Serial.begin(115200);                       //Serial comm start
-  WiFi.config(local_IP, gateway, subnet);     // Wifi service start
-  WiFi.begin(ssid, password);
-  while (WiFi.status() != WL_CONNECTED) {
-    delay(1000);
-    Serial.print(".");
-  }
-  Serial.println("Connected!!");
-  mb.server();                                //Modbus server start
-  Serial.println("Server Created");
-  Serial.println(map_size);
-  for(int i = 0; i < map_size; i++){
-    Modbus_Point<ModbusIP>* point = createModbus_Point(&mb, mb_map[i].category, mb_map[i].address, mb_map[i].value, mb_map[i].description);
-    if (point) {
-      point->addToModbusServer();
-      EquipmentInstance.addModbus_Point(mb_map[i].description, point);
-    }
-  }
-  Serial.println("All modbus Points created");
-  Serial.println("Setup function ended");
-}
-//=================================================================================================================================
-/** 
- * @brief The main application loop.
- * @details This function runs repeatedly after setup() has completed. It performs two main actions:
- * 1. It continuously services the Modbus server by calling `mb.task()` to handle
- *    incoming requests from a Modbus master.
- * 2. At a fixed interval (defined in `config.h`), it calls `EquipmentInstance.update()`
- *    to run the emulator's internal state machine and behavior logic.
- */
-void loop() {
-  mb.task();
-  unsigned long currentMillis = millis();
-  if (currentMillis - previousMillis >= interval) {
-    previousMillis = currentMillis;
-    unsigned long startTime = millis();
-    EquipmentInstance.update();
-    unsigned long endTime = millis();
-    unsigned long elapsedTime = endTime - startTime;
-    Serial.printf("Control Execution time: %d ms\n", elapsedTime);
-  } 
-}
diff --git a/src/EPMS/RPP/RPP_Cortex_TCP/README.md b/src/EPMS/RPP/RPP_Cortex_TCP/README.md
deleted file mode 100644
index 355156f..0000000
--- a/src/EPMS/RPP/RPP_Cortex_TCP/README.md
+++ /dev/null
@@ -1,33 +0,0 @@
-# EQUIPMENT_TYPE MANUFACTURER MODEL TCP
-
-## Brief Introduction
-Equipment specifc details that make it different from other devices
-
-## List of Equipmentt
-This cofiguration has been used for these models:
-* **Model**: 09-15-22 
-* **Model**: 09-15-23 
-* **Model**: 09-15-25 
-
-## Hardware Prerequisites
-
-The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities.
-* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html) 
-
----
-
-## States and Strategies
-Provide a brief description of what variables and strategies were used in this configuraiton
-
-### Standby State
-* **Equipment running**: set to 0
-* **Common Alarm**: set to 0
-* **SAT temperature**: set to 85
-
-### Running State
-* **Equipment running**: set to 1
-* **SAT temperature**: **Ramp Strategy** set to 65 deg setpoint
-
-### Fail State
-* **Commong Alarm**: set to 1
-* **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset
diff --git a/src/EPMS/RPP/RPP_Cortex_TCP/State_Fail.cpp b/src/EPMS/RPP/RPP_Cortex_TCP/State_Fail.cpp
deleted file mode 100644
index 8bc0385..0000000
--- a/src/EPMS/RPP/RPP_Cortex_TCP/State_Fail.cpp
+++ /dev/null
@@ -1,81 +0,0 @@
-/**
- * @file State_Fail.cpp
- * @brief Implementation of the FailState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the FailState, which defines
- * the behavior of the equipment when it has entered a fault condition.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new FailState object with a list of active alarms.
- *
- * This constructor receives a list of alarm descriptions and creates strategies
- * to set the corresponding Modbus points to a value of 1, indicating an
- * active alarm. It also initializes a PID strategy for the 'CW Valve Position'
- * to maintain its state during the fault.
- * @param activeAlarms A vector of strings, where each string is the
- *                     description of a Modbus point to be set as an active alarm.
- */
-template<>
-FailState<ModbusIP>::FailState(const std::vector<std::string>& activeAlarms) {
-    // Simulate a failure: set common alarm and a specific fan alarm.
-
-    
-}
-
-/**
- * @brief Executes the fail state's logic for one update cycle.
- *
- * This method checks the "Alarm Reset" Modbus point for a command to
- * transition back to Standby, which would typically happen after a fault
- * is cleared by a user. If no transition is requested, it continues to apply
- * the failure strategies (e.g., keeping alarm bits active).
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* FailState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Fail update function");
-    
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the fail state.
- * Sets the "Alarm Common" point to 1 to indicate a general fault condition.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Fail State...");
-}
-
-/**
- * @brief Logic to execute once when exiting the fail state.
- * Clears the "Alarm Common" point to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Fail State...");
-}
\ No newline at end of file
diff --git a/src/EPMS/RPP/RPP_Cortex_TCP/State_Running.cpp b/src/EPMS/RPP/RPP_Cortex_TCP/State_Running.cpp
deleted file mode 100644
index 5b5350c..0000000
--- a/src/EPMS/RPP/RPP_Cortex_TCP/State_Running.cpp
+++ /dev/null
@@ -1,99 +0,0 @@
-/**
- * @file State_Running.cpp
- * @brief Implementation of the RunningState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the RunningState, which defines
- * the behavior of the equipment when it is actively running.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "Strategies/Strategy_Totalizer.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new RunningState object.
- *
- * This constructor initializes behavior strategies active during the running
- * state, such as a PID controller for the 'CW Valve Position' and totalizers
- * for the run-hours of each EC fan.
- */
-template<>
-RunningState<ModbusIP>::RunningState() {
-    addStrategy("TT01", new SingleValueStrategy(870.0F, 10.0f, 1000));
-    
-}
-
-/**
- * @brief Executes the running state's logic for one update cycle.
- *
- * This method first checks for state transition commands:
- * 1. It reads the "ON/OFF Command By BMS" point. If it's 0, it transitions to StandbyState.
- * 2. It reads the "Fault Code" point. If it's non-zero, it transitions to FailState,
- *    passing the corresponding alarm description.
- *
- * If no transition occurs, it applies the strategies defined for the running state.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* RunningState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Running update function");
-    float State_Ctrl = getPointValue(equipment, "Remote_Start"); 
-    if (State_Ctrl == 0){
-      return new StandbyState<ModbusIP>();
-    }
-
-    float TT01 = getPointValue(equipment, "TT01");
-    float TT02 = getPointValue(equipment, "TT02");
-    setPointValue(equipment, "TT01_TT02", (TT01 + TT02)/2.0f);
-       
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the running state.
- * Sets the "Run Status" for all EC fans to 1 to indicate they are active.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Running State...");
-    // You could also update a Modbus register to show the "standby" state
-    setPointValue(equipment, "Status", 1);
-}
-
-/**
- * @brief Logic to execute once when exiting the running state.
- * Sets the "Run Status" for all EC fans to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Running State...");
-   
-}
\ No newline at end of file
diff --git a/src/EPMS/RPP/RPP_Cortex_TCP/State_Standby.cpp b/src/EPMS/RPP/RPP_Cortex_TCP/State_Standby.cpp
deleted file mode 100644
index f5f2792..0000000
--- a/src/EPMS/RPP/RPP_Cortex_TCP/State_Standby.cpp
+++ /dev/null
@@ -1,247 +0,0 @@
-/**
- * @file State_Standby.cpp
- * @brief Implementation of the StandbyState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the StandbyState, which defines
- * the behavior of the equipment when it is in an idle or standby mode.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-/**
- * @brief Constructs a new StandbyState object.
- *
- * In this state, the equipment is idle. This constructor initializes strategies
- * to bring the system to a safe, idle condition. It sets a stable value for
- * the SAT reading and creates ramp strategies to bring the CW valve and all
- * EC fan speeds down to zero.
- */
-template<>
-StandbyState<ModbusIP>::StandbyState() {
-    // You can add initialization code here if needed
-    addStrategy("In_freq", new SingleValueStrategy(60.0F, 1.0f, 1000));
-    addStrategy("InV_L1N", new SingleValueStrategy(220.0F, 1.0f, 1000));
-    addStrategy("InV_L2N", new SingleValueStrategy(220.0F, 1.0f, 1000));
-    addStrategy("InV_L3N", new SingleValueStrategy(220.0F, 1.0f, 1000));
-    addStrategy("InV_L12", new SingleValueStrategy(480.0F, 1.0f, 1000));
-    addStrategy("InV_L23", new SingleValueStrategy(480.0F, 1.0f, 1000));
-    addStrategy("InV_L31", new SingleValueStrategy(480.0F, 1.0f, 1000));
-    addStrategy("InTHD_L1N", new SingleValueStrategy(2.5F, 0.5f, 1000));
-    addStrategy("InTHD_L2N", new SingleValueStrategy(3.1F, 0.5f, 1000));
-    addStrategy("InTHD_L3N", new SingleValueStrategy(2.4F, 0.5f, 1000));
-    addStrategy("InTHD_L1_1st", new SingleValueStrategy(2.4F, 0.2f, 1000));
-    addStrategy("InTHD_L1_3rd", new SingleValueStrategy(2.1F, 0.2f, 1000));
-    addStrategy("InTHD_L1_5th", new SingleValueStrategy(1.9F, 0.2f, 1000));
-    addStrategy("InTHD_L1_7th", new SingleValueStrategy(2.1F, 0.2f, 1000));
-    addStrategy("InTHD_L1_9th", new SingleValueStrategy(1.8F, 0.2f, 1000));
-    addStrategy("InTHD_L2_1st", new SingleValueStrategy(2.3F, 0.2f, 1000));
-    addStrategy("InTHD_L2_3rd", new SingleValueStrategy(2.2F, 0.2f, 1000));
-    addStrategy("InTHD_L2_5th", new SingleValueStrategy(2.4F, 0.2f, 1000));
-    addStrategy("InTHD_L2_7th", new SingleValueStrategy(2.5F, 0.2f, 1000));
-    addStrategy("InTHD_L2_9th", new SingleValueStrategy(2.6F, 0.2f, 1000));
-    addStrategy("InTHD_L3_1st", new SingleValueStrategy(2.2F, 0.2f, 1000));
-    addStrategy("InTHD_L3_3rd", new SingleValueStrategy(2.3F, 0.2f, 1000));
-    addStrategy("InTHD_L3_5th", new SingleValueStrategy(2.1F, 0.2f, 1000));
-    addStrategy("InTHD_L3_7th", new SingleValueStrategy(2.4F, 0.2f, 1000));
-    addStrategy("InTHD_L3_9th", new SingleValueStrategy(2.5F, 0.2f, 1000));
-    addStrategy("InTHD_L12", new SingleValueStrategy(3.1F, 0.2f, 1000));
-    addStrategy("InTHD_L23", new SingleValueStrategy(2.1F, 0.2f, 1000));
-    addStrategy("InTHD_L31", new SingleValueStrategy(1.8F, 0.2f, 1000));
-   
-    addStrategy("CB1_kW", new SingleValueStrategy(3.1F, 3.0f, 1000));
-    addStrategy("CB2_kW", new SingleValueStrategy(3.1F, 3.0f, 1000));
-    addStrategy("CB3_kW", new SingleValueStrategy(3.1F, 3.0f, 1000));
-    addStrategy("CB4_kW", new SingleValueStrategy(3.1F, 3.0f, 1000));
-    addStrategy("CB5_kW", new SingleValueStrategy(3.1F, 3.0f, 1000));
-    addStrategy("CB6_kW", new SingleValueStrategy(3.1F, 3.0f, 1000));
-    addStrategy("CB7_kW", new SingleValueStrategy(3.1F, 3.0f, 1000));
-    addStrategy("CB8_kW", new SingleValueStrategy(3.1F, 3.0f, 1000));
-    addStrategy("CB9_kW", new SingleValueStrategy(3.1F, 3.0f, 1000));
-    addStrategy("CB10_kW", new SingleValueStrategy(3.1F, 3.0f, 1000));
-    addStrategy("CB11_kW", new SingleValueStrategy(3.1F, 3.0f, 1000));
-    addStrategy("CB12_kW", new SingleValueStrategy(3.1F, 3.0f, 1000));
-    addStrategy("CB13_kW", new SingleValueStrategy(3.1F, 3.0f, 1000));
-    addStrategy("CB14_kW", new SingleValueStrategy(3.1F, 3.0f, 1000));
-    addStrategy("CB15_kW", new SingleValueStrategy(3.1F, 3.0f, 1000));
-    addStrategy("CB16_kW", new SingleValueStrategy(3.1F, 3.0f, 1000));
-
-    addStrategy("CB1_PF", new SingleValueStrategy(0.9F, 0.05f, 1000));
-    addStrategy("CB2_PF", new SingleValueStrategy(0.9F, 0.05f, 1000));
-    addStrategy("CB3_PF", new SingleValueStrategy(0.9F, 0.05f, 1000));
-    addStrategy("CB4_PF", new SingleValueStrategy(0.9F, 0.05f, 1000));
-    addStrategy("CB5_PF", new SingleValueStrategy(0.9F, 0.05f, 1000));
-    addStrategy("CB6_PF", new SingleValueStrategy(0.9F, 0.05f, 1000));
-    addStrategy("CB7_PF", new SingleValueStrategy(0.9F, 0.05f, 1000));
-    addStrategy("CB8_PF", new SingleValueStrategy(0.9F, 0.05f, 1000));
-}
-
-/**
- * @brief Executes the standby state's logic for one update cycle.
- *
- * This method applies the strategies defined for the standby state (e.g.,
- * ramping values to zero).
- *
- * @warning This method currently does not check for a command to transition to the
- *          Running state. This logic needs to be added to allow the unit to start.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* StandbyState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Standby update function");
-
-    // Calculate Avergae for voltage LN points
-    float InV_L1N = getPointValue(equipment, "InV_L1N");
-    float InV_L2N = getPointValue(equipment, "InV_L2N");
-    float InV_L3N = getPointValue(equipment, "InV_L3N");
-    setPointValue(equipment, "InV_LN_avg", (InV_L1N + InV_L2N + InV_L3N)/3.0f);
-    // Calculate Avergae for voltage LL points
-    float InV_L12 = getPointValue(equipment, "InV_L12");
-    float InV_L23 = getPointValue(equipment, "InV_L23");
-    float InV_L31 = getPointValue(equipment, "InV_L31");
-    setPointValue(equipment, "InV_LL_avg", (InV_L12 + InV_L23 + InV_L31)/3.0f);
-
-
-    for (int i = 1; i <= 8; i++) {
-      std::string cb_name = "CB" + std::to_string(i);
-      std::string kw_name = cb_name + "_kW";
-      std::string max_kw_name = cb_name + "_max_kW";
-      std::string max_current_name = cb_name + "_maxCurrent";
-
-      float cb_value = getPointValue(equipment, cb_name.c_str());
-      if (cb_value == 1.0f){
-        float kw = 350.0f;
-        Strategy_Behavior* svs_cb_kW = getStrategy(kw_name.c_str());
-        static_cast<SingleValueStrategy*>(svs_cb_kW)->setSetpoint(kw);
-
-        float in_v_ll_avg = getPointValue(equipment, "InV_LL_avg");
-        float current = (kw*1000.0f)/(in_v_ll_avg*1.73f);
-        setPointValue(equipment, max_current_name.c_str(), current);
-
-        float max_kw = getPointValue(equipment, max_kw_name.c_str());
-        if (kw > max_kw){
-          setPointValue(equipment, max_kw_name.c_str(), kw);  
-        }
-
-        float max_current = getPointValue(equipment, max_current_name.c_str());
-        if (current > max_current){
-          setPointValue(equipment, max_current_name.c_str(), current);    
-        }
-      }
-
-           
-    }
-
-    float mainCB_total_kW = 0.0f;
-    float mainCB_maxCurrent = 0.0f;
-    float mainCB_neutralCurrent = 0.0f;
-    float mainCB_maxTotalKw = 0.0f;
-    float mainCB_maxTotalCurrent = 0.0f;
-    for (int i = 1; i <= 8; i++) {
-      std::string kw_name = "CB" + std::to_string(i) + "_kW";
-      std::string max_current_name = "CB" + std::to_string(i) + "_maxCurrent";
-      mainCB_total_kW += getPointValue(equipment, kw_name.c_str());
-      mainCB_maxCurrent += getPointValue(equipment, max_current_name.c_str());
-      float max_kw = getPointValue(equipment, ("CB" + std::to_string(i) + "_max_kW").c_str());
-      if (max_kw > mainCB_maxTotalKw) {
-        mainCB_maxTotalKw = max_kw;
-      }
-      float max_current = getPointValue(equipment, max_current_name.c_str());
-      if (max_current > mainCB_maxTotalCurrent) {
-        mainCB_maxTotalCurrent = max_current;
-      }
-    }
-
-    float mainCB_PF = getPointValue(equipment, "MainCB_PF");
-    setPointValue(equipment, "MainCB_Total_kW", mainCB_total_kW);
-    setPointValue(equipment, "MainCB_Total_kW", mainCB_total_kW);
-    setPointValue(equipment, "MainCB_Total_kVA", mainCB_total_kW * 1.3f);  
-    setPointValue(equipment, "MainCB_maxCurrent", mainCB_maxCurrent);
-    setPointValue(equipment, "MainCB_maxCurrent", mainCB_maxCurrent);
-    setPointValue(equipment, "MainCB_neutralCurrent", mainCB_neutralCurrent);
-    setPointValue(equipment, "MainCB_maxTotalkW", mainCB_maxTotalKw);
-    setPointValue(equipment, "MainCB_maxTotalCurrent", mainCB_maxTotalCurrent);
-    
-    setPointValue(equipment, "MainCB_L1_kW", mainCB_total_kW);
-    setPointValue(equipment, "MainCB_L1_kVA", mainCB_total_kW*1.3f);
-    setPointValue(equipment, "MainCB_L1_Current", mainCB_maxCurrent);
-    setPointValue(equipment, "MainCB_L1_PF", mainCB_PF);
-    setPointValue(equipment, "MainCB_L1_max_kW", mainCB_maxTotalKw);
-    setPointValue(equipment, "MainCB_L1_max_current", mainCB_maxTotalCurrent);
-    
-    setPointValue(equipment, "MainCB_L2_kW", mainCB_total_kW);
-    setPointValue(equipment, "MainCB_L2_kVA", mainCB_total_kW*1.3f);
-    setPointValue(equipment, "MainCB_L2_Current", mainCB_maxCurrent);
-    setPointValue(equipment, "MainCB_L2_PF", mainCB_PF);
-    setPointValue(equipment, "MainCB_L2_max_kW", mainCB_maxTotalKw);
-    setPointValue(equipment, "MainCB_L2_max_current", mainCB_maxTotalCurrent);
-
-    setPointValue(equipment, "MainCB_L3_kW", mainCB_total_kW);
-    setPointValue(equipment, "MainCB_L3_kVA", mainCB_total_kW*1.3f);
-    setPointValue(equipment, "MainCB_L3_Current", mainCB_maxCurrent);
-    setPointValue(equipment, "MainCB_L3_PF", mainCB_PF);
-    setPointValue(equipment, "MainCB_L3_max_kW", mainCB_maxTotalKw);
-    setPointValue(equipment, "MainCB_L3_max_current", mainCB_maxTotalCurrent);
-
-    static unsigned long lastMillis = millis();
-    unsigned long now = millis();
-    float dt_hours = (now - lastMillis) / 3600000.0f;
-    lastMillis = now;
-
-    for (int i = 1; i <= 8; i++) {
-        std::string kw_name    = "CB" + std::to_string(i) + "_kW";
-        std::string total_name = "CB" + std::to_string(i) + "_TotalKW";
-        std::string pf_name    = "CB" + std::to_string(i) + "_PF";
-
-        float kw = getPointValue(equipment, kw_name.c_str());
-        float accumulated = getPointValue(equipment, total_name.c_str());
-        setPointValue(equipment, total_name.c_str(), accumulated + kw * dt_hours);
-        setPointValue(equipment, pf_name.c_str(), getPointValue(equipment, pf_name.c_str()));
-    }
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the standby state.
- * This method performs cleanup by setting all alarm points and all EC fan
- * run status points to 0.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Standby State...");
-    setPointValue(equipment, "Status", 0);
-}
-
-/**
- * @brief Logic to execute once when exiting the standby state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Standby State...");
-}
-
diff --git a/src/EPMS/RPP/RPP_Cortex_TCP/config.h b/src/EPMS/RPP/RPP_Cortex_TCP/config.h
deleted file mode 100644
index e15c97b..0000000
--- a/src/EPMS/RPP/RPP_Cortex_TCP/config.h
+++ /dev/null
@@ -1,239 +0,0 @@
-/**
- * @file config.h
- * @brief Main configuration file for the CRAH Unit (TCP) emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * This file contains two important configurations: WiFi network parameters
- * and the Modbus register map for the device.
- */
-
-#ifndef CONFIG_H
-#define CONFIG_H
-
-#include "core.h"
-#include "Equipment/Equipment.h"
-
-#if defined(USE_MODBUS_IP)
-/**
-   * @defgroup ModbusTCPConfig Modbus IP Configuration
-   * @brief Parameters for Modbus TCP communication.
-   * @{
-   */
-  #include <ModbusIP_ESP8266.h>
-  const char *ssid = "Oracle_SA";       /**< @brief The SSID of the WiFi network. */
-  const char *password = "Prime!123";   /**< @brief The password for the WiFi network. */
-  IPAddress local_IP(172, 17, 38, 51);       /**< @brief The static IP address for the device. */
-  IPAddress gateway(172, 17, 38, 1);          /**< @brief The gateway IP address. */
-  IPAddress subnet(255, 255, 255, 0);         /**< @brief The subnet mask. */
-  
-  ModbusIP mb;
-#else
-  /**
-   * @defgroup ModbusRTUConfig Modbus RTU Configuration
-   * @brief Parameters for serial Modbus RTU communication.
-   * @{
-   */
-  #include <ModbusRTU.h>
-  const int BAUDRATE = 19200;   /**< @brief The serial communication speed in bits per second. */
-  const int RX_PIN = 17;        /**< @brief The GPIO pin used for receiving data (RX). */
-  const int TX_PIN = 16;        /**< @brief The GPIO pin used for transmitting data (TX). */
-  const int RST_PIN = 4;        /**< @brief The GPIO pin connected to the RS485 driver's DE/RE pins for direction control. */
-  const int MODBUS_ID = 1;      /**< @brief The unique slave ID for this device on the Modbus bus. */
-  /** @} */
-
-  /** @brief Global instance of the Modbus RTU server. */
-  ModbusRTU mb;
-#endif
-
-
-
-/**
- * @defgroup ModbusMapConfig Modbus Map Configuration
- * @brief Defines the Modbus register map and related parameters for the emulator.
- * @{
- */
-/**
- * @brief The Modbus map for the Equipment device.
- * This array defines all the Modbus points available on the emulated device.
- * The `description` field is crucial as it's used to look up points within the application logic.
- */
-modbusMap mb_map[] =
-{   
-  {HR,        2046,    0,   "CB1"},
-  {HR,        2047,    0,   "CB2"},
-  {HR,        2048,    0,   "CB3"},
-  {HR,        2049,    0,   "CB4"},
-  {HR,        2050,    0,   "CB5"},
-  {HR,        2051,    0,   "CB6"},
-  {HR,        2052,    0,   "CB7"},
-  {HR,        2053,    0,   "CB8"},
-  {HR,        2054,    0,   "CB9"},
-  {HR,        2055,    0,   "CB10"},
-  {HR,        2056,    0,   "CB11"},
-  {HR,        2057,    0,   "CB12"},
-  {HR,        2058,    0,   "CB13"},
-  {HR,        2059,    0,   "CB14"},
-  {HR,        2060,    0,   "CB15"},
-  {HR,        2061,    0,   "CB16"},
-  {HR_FLOAT,  9000,    0,   "In_freq"},
-  {HR_FLOAT,  9002,    0,   "InV_L1N"},
-  {HR_FLOAT,  9004,    0,   "InV_L2N"},
-  {HR_FLOAT,  9006,    0,   "InV_L3N"},
-  {HR_FLOAT,  9008,    0,   "InV_LN_avg"},
-  {HR_FLOAT,  9010,    0,   "InV_L12"},
-  {HR_FLOAT,  9012,    0,   "InV_L23"},
-  {HR_FLOAT,  9014,    0,   "InV_L31"},
-  {HR_FLOAT,  9016,    0,   "InV_LL_avg"},
-  {HR_FLOAT,  9018,    0,   "InTHD_L1N"},
-  {HR_FLOAT,  9020,    0,   "InTHD_L2N"},
-  {HR_FLOAT,  9022,    0,   "InTHD_L3N"},
-  {HR_FLOAT,  9036,    0,   "InTHD_L1_1st"},
-  {HR_FLOAT,  9040,    0,   "InTHD_L1_3rd"},
-  {HR_FLOAT,  9044,    0,   "InTHD_L1_5th"},
-  {HR_FLOAT,  9048,    0,   "InTHD_L1_7th"},
-  {HR_FLOAT,  9052,    0,   "InTHD_L1_9th"},
-  {HR_FLOAT,  9162,    0,   "InTHD_L2_1st"},
-  {HR_FLOAT,  9166,    0,   "InTHD_L2_3rd"},
-  {HR_FLOAT,  9170,    0,   "InTHD_L2_5th"},
-  {HR_FLOAT,  9174,    0,   "InTHD_L2_7th"},
-  {HR_FLOAT,  9178,    0,   "InTHD_L2_9th"},
-  {HR_FLOAT,  9288,    0,   "InTHD_L3_1st"},
-  {HR_FLOAT,  9292,    0,   "InTHD_L3_3rd"},
-  {HR_FLOAT,  9296,    0,   "InTHD_L3_5th"},
-  {HR_FLOAT,  9300,    0,   "InTHD_L3_7th"},
-  {HR_FLOAT,  9304,    0,   "InTHD_L3_9th"},
-  {HR_FLOAT,  9018,    0,   "InTHD_L12"},
-  {HR_FLOAT,  9020,    0,   "InTHD_L23"},
-  {HR_FLOAT,  9022,    0,   "InTHD_L31"},
-
-  {HR_FLOAT,  11920,   0,   "CB1_TotalKW"},
-  {HR_FLOAT,  11924,   0,   "CB2_TotalKW"},
-  {HR_FLOAT,  11928,   0,   "CB3_TotalKW"},
-  {HR_FLOAT,  11932,   0,   "CB4_TotalKW"},
-  {HR_FLOAT,  11936,   0,   "CB5_TotalKW"},
-  {HR_FLOAT,  11940,   0,   "CB6_TotalKW"},
-  {HR_FLOAT,  11944,   0,   "CB7_TotalKW"},
-  {HR_FLOAT,  11948,   0,   "CB8_TotalKW"},
-
-  {HR_FLOAT,  13456,   0,   "CB1_kW"},
-  {HR_FLOAT,  13460,   0,   "CB2_kW"},
-  {HR_FLOAT,  13464,   0,   "CB3_kW"},
-  {HR_FLOAT,  13468,   0,   "CB4_kW"},
-  {HR_FLOAT,  13472,   0,   "CB5_kW"},
-  {HR_FLOAT,  13476,   0,   "CB6_kW"},
-  {HR_FLOAT,  13480,   0,   "CB7_kW"},
-  {HR_FLOAT,  13484,   0,   "CB8_kW"},
-  {HR_FLOAT,  13488,   0,   "CB9_kW"},
-  {HR_FLOAT,  13492,   0,   "CB10_kW"},
-  {HR_FLOAT,  13496,   0,   "CB11_kW"},
-  {HR_FLOAT,  13500,   0,   "CB12_kW"},
-  {HR_FLOAT,  13504,   0,   "CB13_kW"},
-  {HR_FLOAT,  13508,   0,   "CB14_kW"},
-  {HR_FLOAT,  13512,   0,   "CB15_kW"},
-  {HR_FLOAT,  13516,   0,   "CB16_kW"},
-
-  {HR_FLOAT,  14608,   0,   "CB1_Current"},
-  {HR_FLOAT,  14612,   0,   "CB2_Current"},
-  {HR_FLOAT,  14616,   0,   "CB3_Current"},
-  {HR_FLOAT,  14620,   0,   "CB4_Current"},
-  {HR_FLOAT,  14624,   0,   "CB5_Current"},
-  {HR_FLOAT,  14628,   0,   "CB6_Current"},
-  {HR_FLOAT,  14632,   0,   "CB7_Current"},
-  {HR_FLOAT,  14636,   0,   "CB8_Current"},
-  {HR_FLOAT,  14640,   0,   "CB9_Current"},
-  {HR_FLOAT,  14644,   0,   "CB10_Current"},
-  {HR_FLOAT,  14648,   0,   "CB11_Current"},
-  {HR_FLOAT,  14652,   0,   "CB12_Current"},
-  {HR_FLOAT,  14656,   0,   "CB13_Current"},
-  {HR_FLOAT,  14660,   0,   "CB14_Current"},
-  {HR_FLOAT,  14664,   0,   "CB15_Current"},
-  {HR_FLOAT,  14668,   0,   "CB16_Current"},
-
-  {HR_FLOAT,  15376,   0,   "CB1_PF"},
-  {HR_FLOAT,  15380,   0,   "CB2_PF"},
-  {HR_FLOAT,  15384,   0,   "CB3_PF"},
-  {HR_FLOAT,  15388,   0,   "CB4_PF"},
-  {HR_FLOAT,  15392,   0,   "CB5_PF"},
-  {HR_FLOAT,  15396,   0,   "CB6_PF"},
-  {HR_FLOAT,  15400,   0,   "CB7_PF"},
-  {HR_FLOAT,  15404,   0,   "CB8_PF"},
-  
-  {HR_FLOAT,  16912,   0,   "CB1_max_kW"},
-  {HR_FLOAT,  16916,   0,   "CB2_max_kW"},
-  {HR_FLOAT,  16920,   0,   "CB3_max_kW"},
-  {HR_FLOAT,  16924,   0,   "CB4_max_kW"},
-  {HR_FLOAT,  16928,   0,   "CB5_max_kW"},
-  {HR_FLOAT,  16932,   0,   "CB6_max_kW"},
-  {HR_FLOAT,  16936,   0,   "CB7_max_kW"},
-  {HR_FLOAT,  16940,   0,   "CB8_max_kW"},
-  {HR_FLOAT,  16944,   0,   "CB9_max_kW"},
-  {HR_FLOAT,  16948,   0,   "CB10_max_kW"},
-  {HR_FLOAT,  16952,   0,   "CB11_max_kW"},
-  {HR_FLOAT,  16956,   0,   "CB12_max_kW"},
-  {HR_FLOAT,  16960,   0,   "CB13_max_kW"},
-  {HR_FLOAT,  16964,   0,   "CB14_max_kW"},
-  {HR_FLOAT,  16968,   0,   "CB15_max_kW"},
-  {HR_FLOAT,  16972,   0,   "CB16_max_kW"},
-
-  {HR_FLOAT,  17296,   0,   "CB1_maxCurrent"},
-  {HR_FLOAT,  17300,   0,   "CB2_maxCurrent"},
-  {HR_FLOAT,  17304,   0,   "CB3_maxCurrent"},
-  {HR_FLOAT,  17308,   0,   "CB4_maxCurrent"},
-  {HR_FLOAT,  17312,   0,   "CB5_maxCurrent"},
-  {HR_FLOAT,  17316,   0,   "CB6_maxCurrent"},
-  {HR_FLOAT,  17320,   0,   "CB7_maxCurrent"},
-  {HR_FLOAT,  17324,   0,   "CB8_maxCurrent"},
-  {HR_FLOAT,  17328,   0,   "CB9_maxCurrent"},
-  {HR_FLOAT,  17332,   0,   "CB10_maxCurrent"},
-  {HR_FLOAT,  17336,   0,   "CB11_maxCurrent"},
-  {HR_FLOAT,  17340,   0,   "CB12_maxCurrent"},
-  {HR_FLOAT,  17344,   0,   "CB13_maxCurrent"},
-  {HR_FLOAT,  17348,   0,   "CB14_maxCurrent"},
-  {HR_FLOAT,  17352,   0,   "CB15_maxCurrent"},
-  {HR_FLOAT,  17356,   0,   "CB16_maxCurrent"},
-
-  {HR_FLOAT,  63058,   0,   "MainCB_Total_kW"},
-  {HR_FLOAT,  63178,   0,   "MainCB_maxCurrent"},
-  {HR_FLOAT,  63068,   0,   "MainCB_neutralCurrent"},
-  {HR_FLOAT,  63070,   0,   "MainCB_PF"},
-  {HR_FLOAT,  63074,   0,   "MainCB_maxTotalkW"},
-  {HR_FLOAT,  63706,   0,   "MainCB_maxTotalCurrent"},
-  {HR_FLOAT,  63062,   0,   "MainCB_Total_kVA"},
-
-
-  {HR_FLOAT,  63108,   0,   "MainCB_L1_kW"},
-  {HR_FLOAT,  63112,   0,   "MainCB_L1_kVA"},
-  {HR_FLOAT,  63114,   0,   "MainCB_L1_Current"},
-  {HR_FLOAT,  63116,   0,   "MainCB_L1_PF"},
-  {HR_FLOAT,  63126,   0,   "MainCB_L1_max_kW"},
-  {HR_FLOAT,  63128,   0,   "MainCB_L1_max_current"},
-
-  {HR_FLOAT,  63158,   0,   "MainCB_L2_kW"},
-  {HR_FLOAT,  63162,   0,   "MainCB_L2_kVA"},
-  {HR_FLOAT,  63164,   0,   "MainCB_L2_Current"},
-  {HR_FLOAT,  63166,   0,   "MainCB_L2_PF"},
-  {HR_FLOAT,  63176,   0,   "MainCB_L2_max_kW"},
-  {HR_FLOAT,  63228,   0,   "MainCB_L2_max_current"},
-
-  {HR_FLOAT,  63208,   0,   "MainCB_L3_kW"},
-  {HR_FLOAT,  63212,   0,   "MainCB_L3_kVA"},
-  {HR_FLOAT,  63214,   0,   "MainCB_L3_Current"},
-  {HR_FLOAT,  63216,   0,   "MainCB_L3_PF"},
-  {HR_FLOAT,  63226,   0,   "MainCB_L3_max_kW"},
-  {HR_FLOAT,  63328,   0,   "MainCB_L3_max_current"},
-
-}; 
-//Size of modbus map used in FOR cycles, automatically calculated.
-
-/**
- * @brief The total number of entries in the `mb_map` array.
- * This is calculated at compile time and used for iterating over the map.
- */
-const int map_size = sizeof(mb_map) / sizeof(mb_map[0]);
-
-/** @brief The main loop update interval in milliseconds. */
-int interval = 250; 
-/** @} */ // End of ModbusMapConfig group
-
-#endif // CONFIG_H
diff --git a/src/EPMS/RPP/RPP_Cortex_TCP/main.cpp b/src/EPMS/RPP/RPP_Cortex_TCP/main.cpp
deleted file mode 100644
index 286a98c..0000000
--- a/src/EPMS/RPP/RPP_Cortex_TCP/main.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-/**
- * @file main.cpp
- * @brief Main execution program for the CRAH Unit (TCP) Emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * @details This file contains the main execution program for an Arduino-based emulator of a CRAH unit. 
- * The program uses a Wi-Fi connection to communicate via the Modbus IP protocol.
- *
- * The setup() function initializes the following:
- * - Serial communication for debugging.
- * - Wi-Fi connection using credentials from config.h.
- * - A Modbus TCP server.
- * - Modbus points (Coils, Holding Registers, etc.) based on a predefined map in config.h.
- *
- * The loop() function continuously:
- * - Services the Modbus TCP server to handle incoming requests.
- * - Periodically calls the main update loop for the emulated equipment, which
- *   manages state transitions and behavior strategies.
- *
- * @see config.h for Wi-Fi and Modbus configuration.
- * @see Equipment.h for the main equipment logic.
- * @see State.h for different equipment states.
- * @see Strategies/Strategy_Behavior.h for value generation strategies.
- * @see Modbus_Point.h for the base class for all Modbus points.
- */
-//=================================================================================================================================
-//Libraries and declaration of variables.
-#include <WiFi.h>
-#include "config.h"
-#include "ModbusPoints/Modbus_PointFactory.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-//=================================================================================================================================
-/** 
- * @brief Initializes the application.
- * @details This function runs once at startup. It configures the serial communication, 
- * Wi-Fi, and the Modbus server. It also creates and initializes all the Modbus points 
- * based on the `mb_map` array in `config.h`.
- */
-void setup() {
-  Serial.begin(115200);                       //Serial comm start
-  WiFi.config(local_IP, gateway, subnet);     // Wifi service start
-  WiFi.begin(ssid, password);
-  while (WiFi.status() != WL_CONNECTED) {
-    delay(1000);
-    Serial.print(".");
-  }
-  Serial.println("Connected!!");
-  mb.server();                                //Modbus server start
-  Serial.println("Server Created");
-  Serial.println(map_size);
-  for(int i = 0; i < map_size; i++){
-    Modbus_Point<ModbusIP>* point = createModbus_Point(&mb, mb_map[i].category, mb_map[i].address, mb_map[i].value, mb_map[i].description);
-    if (point) {
-      point->addToModbusServer();
-      EquipmentInstance.addModbus_Point(mb_map[i].description, point);
-    }
-  }
-  Serial.println("All modbus Points created");
-  Serial.println("Setup function ended");
-}
-//=================================================================================================================================
-/** 
- * @brief The main application loop.
- * @details This function runs repeatedly after setup() has completed. It performs two main actions:
- * 1. It continuously services the Modbus server by calling `mb.task()` to handle
- *    incoming requests from a Modbus master.
- * 2. At a fixed interval (defined in `config.h`), it calls `EquipmentInstance.update()`
- *    to run the emulator's internal state machine and behavior logic.
- */
-void loop() {
-  mb.task();
-  unsigned long currentMillis = millis();
-  if (currentMillis - previousMillis >= interval) {
-    previousMillis = currentMillis;
-    unsigned long startTime = millis();
-    EquipmentInstance.update();
-    unsigned long endTime = millis();
-    unsigned long elapsedTime = endTime - startTime;
-    Serial.printf("Control Execution time: %d ms\n", elapsedTime);
-  } 
-}
diff --git a/src/EPMS/SCP/SCP_Manufacturer_Model_TCP/README.md b/src/EPMS/SCP/SCP_Manufacturer_Model_TCP/README.md
deleted file mode 100644
index 355156f..0000000
--- a/src/EPMS/SCP/SCP_Manufacturer_Model_TCP/README.md
+++ /dev/null
@@ -1,33 +0,0 @@
-# EQUIPMENT_TYPE MANUFACTURER MODEL TCP
-
-## Brief Introduction
-Equipment specifc details that make it different from other devices
-
-## List of Equipmentt
-This cofiguration has been used for these models:
-* **Model**: 09-15-22 
-* **Model**: 09-15-23 
-* **Model**: 09-15-25 
-
-## Hardware Prerequisites
-
-The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities.
-* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html) 
-
----
-
-## States and Strategies
-Provide a brief description of what variables and strategies were used in this configuraiton
-
-### Standby State
-* **Equipment running**: set to 0
-* **Common Alarm**: set to 0
-* **SAT temperature**: set to 85
-
-### Running State
-* **Equipment running**: set to 1
-* **SAT temperature**: **Ramp Strategy** set to 65 deg setpoint
-
-### Fail State
-* **Commong Alarm**: set to 1
-* **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset
diff --git a/src/EPMS/SCP/SCP_Manufacturer_Model_TCP/State_Fail.cpp b/src/EPMS/SCP/SCP_Manufacturer_Model_TCP/State_Fail.cpp
deleted file mode 100644
index 8bc0385..0000000
--- a/src/EPMS/SCP/SCP_Manufacturer_Model_TCP/State_Fail.cpp
+++ /dev/null
@@ -1,81 +0,0 @@
-/**
- * @file State_Fail.cpp
- * @brief Implementation of the FailState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the FailState, which defines
- * the behavior of the equipment when it has entered a fault condition.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new FailState object with a list of active alarms.
- *
- * This constructor receives a list of alarm descriptions and creates strategies
- * to set the corresponding Modbus points to a value of 1, indicating an
- * active alarm. It also initializes a PID strategy for the 'CW Valve Position'
- * to maintain its state during the fault.
- * @param activeAlarms A vector of strings, where each string is the
- *                     description of a Modbus point to be set as an active alarm.
- */
-template<>
-FailState<ModbusIP>::FailState(const std::vector<std::string>& activeAlarms) {
-    // Simulate a failure: set common alarm and a specific fan alarm.
-
-    
-}
-
-/**
- * @brief Executes the fail state's logic for one update cycle.
- *
- * This method checks the "Alarm Reset" Modbus point for a command to
- * transition back to Standby, which would typically happen after a fault
- * is cleared by a user. If no transition is requested, it continues to apply
- * the failure strategies (e.g., keeping alarm bits active).
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* FailState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Fail update function");
-    
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the fail state.
- * Sets the "Alarm Common" point to 1 to indicate a general fault condition.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Fail State...");
-}
-
-/**
- * @brief Logic to execute once when exiting the fail state.
- * Clears the "Alarm Common" point to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Fail State...");
-}
\ No newline at end of file
diff --git a/src/EPMS/SCP/SCP_Manufacturer_Model_TCP/State_Running.cpp b/src/EPMS/SCP/SCP_Manufacturer_Model_TCP/State_Running.cpp
deleted file mode 100644
index b9e4a99..0000000
--- a/src/EPMS/SCP/SCP_Manufacturer_Model_TCP/State_Running.cpp
+++ /dev/null
@@ -1,89 +0,0 @@
-/**
- * @file State_Running.cpp
- * @brief Implementation of the RunningState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the RunningState, which defines
- * the behavior of the equipment when it is actively running.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "Strategies/Strategy_Totalizer.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new RunningState object.
- *
- * This constructor initializes behavior strategies active during the running
- * state, such as a PID controller for the 'CW Valve Position' and totalizers
- * for the run-hours of each EC fan.
- */
-template<>
-RunningState<ModbusIP>::RunningState() {
-}
-
-/**
- * @brief Executes the running state's logic for one update cycle.
- *
- * This method first checks for state transition commands:
- * 1. It reads the "ON/OFF Command By BMS" point. If it's 0, it transitions to StandbyState.
- * 2. It reads the "Fault Code" point. If it's non-zero, it transitions to FailState,
- *    passing the corresponding alarm description.
- *
- * If no transition occurs, it applies the strategies defined for the running state.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* RunningState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Running update function");
-    
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the running state.
- * Sets the "Run Status" for all EC fans to 1 to indicate they are active.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Running State...");
-    // You could also update a Modbus register to show the "standby" state
-
-}
-
-/**
- * @brief Logic to execute once when exiting the running state.
- * Sets the "Run Status" for all EC fans to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Running State...");
-   
-}
\ No newline at end of file
diff --git a/src/EPMS/SCP/SCP_Manufacturer_Model_TCP/State_Standby.cpp b/src/EPMS/SCP/SCP_Manufacturer_Model_TCP/State_Standby.cpp
deleted file mode 100644
index 20029d1..0000000
--- a/src/EPMS/SCP/SCP_Manufacturer_Model_TCP/State_Standby.cpp
+++ /dev/null
@@ -1,85 +0,0 @@
-/**
- * @file State_Standby.cpp
- * @brief Implementation of the StandbyState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the StandbyState, which defines
- * the behavior of the equipment when it is in an idle or standby mode.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-/**
- * @brief Constructs a new StandbyState object.
- *
- * In this state, the equipment is idle. This constructor initializes strategies
- * to bring the system to a safe, idle condition. It sets a stable value for
- * the SAT reading and creates ramp strategies to bring the CW valve and all
- * EC fan speeds down to zero.
- */
-template<>
-StandbyState<ModbusIP>::StandbyState() {
-    // You can add initialization code here if needed
-    
-
-}
-
-/**
- * @brief Executes the standby state's logic for one update cycle.
- *
- * This method applies the strategies defined for the standby state (e.g.,
- * ramping values to zero).
- *
- * @warning This method currently does not check for a command to transition to the
- *          Running state. This logic needs to be added to allow the unit to start.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* StandbyState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Standby update function");
-    
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the standby state.
- * This method performs cleanup by setting all alarm points and all EC fan
- * run status points to 0.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Standby State...");
-}
-
-/**
- * @brief Logic to execute once when exiting the standby state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Standby State...");
-}
\ No newline at end of file
diff --git a/src/EPMS/SCP/SCP_Manufacturer_Model_TCP/config.h b/src/EPMS/SCP/SCP_Manufacturer_Model_TCP/config.h
deleted file mode 100644
index bd4ad09..0000000
--- a/src/EPMS/SCP/SCP_Manufacturer_Model_TCP/config.h
+++ /dev/null
@@ -1,152 +0,0 @@
-/**
- * @file config.h
- * @brief Main configuration file for the CRAH Unit (TCP) emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * This file contains two important configurations: WiFi network parameters
- * and the Modbus register map for the device.
- */
-
-#ifndef CONFIG_H
-#define CONFIG_H
-
-#include "core.h"
-#include "Equipment/Equipment.h"
-
-#if defined(USE_MODBUS_IP)
-/**
-   * @defgroup ModbusTCPConfig Modbus IP Configuration
-   * @brief Parameters for Modbus TCP communication.
-   * @{
-   */
-  #include <ModbusIP_ESP8266.h>
-  const char *ssid = "wifi_name";       /**< @brief The SSID of the WiFi network. */
-  const char *password = "wifi_password";   /**< @brief The password for the WiFi network. */
-  IPAddress local_IP(192, 168, 1, 234);       /**< @brief The static IP address for the device. */
-  IPAddress gateway(192, 168, 1, 1);          /**< @brief The gateway IP address. */
-  IPAddress subnet(255, 255, 255, 0);         /**< @brief The subnet mask. */
-  
-  ModbusIP mb;
-#else
-  /**
-   * @defgroup ModbusRTUConfig Modbus RTU Configuration
-   * @brief Parameters for serial Modbus RTU communication.
-   * @{
-   */
-  #include <ModbusRTU.h>
-  const int BAUDRATE = 19200;   /**< @brief The serial communication speed in bits per second. */
-  const int RX_PIN = 17;        /**< @brief The GPIO pin used for receiving data (RX). */
-  const int TX_PIN = 16;        /**< @brief The GPIO pin used for transmitting data (TX). */
-  const int RST_PIN = 4;        /**< @brief The GPIO pin connected to the RS485 driver's DE/RE pins for direction control. */
-  const int MODBUS_ID = 1;      /**< @brief The unique slave ID for this device on the Modbus bus. */
-  /** @} */
-
-  /** @brief Global instance of the Modbus RTU server. */
-  ModbusRTU mb;
-#endif
-
-
-
-/**
- * @defgroup ModbusMapConfig Modbus Map Configuration
- * @brief Defines the Modbus register map and related parameters for the emulator.
- * @{
- */
-/**
- * @brief The Modbus map for the Equipment device.
- * This array defines all the Modbus points available on the emulated device.
- * The `description` field is crucial as it's used to look up points within the application logic.
- */
-modbusMap mb_map[] =
-{   
-  {HR,        15,     0,  "State Control"},  //Internal to control from Modscan
-  {HR,        16,     0,  "Fault Code"},
-  {HR_FLOAT,  18,     0,  "RAT"},     //Internal Fault code from Modscan  
-  {HR_FLOAT,  1,      0,  "SAT Setpoint"},                     
-  {HR_FLOAT,  681,    0,  "RAT Setpoint"},                   
-  {HR_FLOAT,  111,    0,  "High RAT Limit"},                 
-  {HR_FLOAT,  114,    0,  "Low RAT Limit"},                  
-  {HR_FLOAT,  118,    0,  "High SAT Limit"},                 
-  {HR_FLOAT,  122,    0,  "Low SAT Limit"},                  
-  {HR_FLOAT,  685,    0,  "High RAH Limit"},                 
-  {HR_FLOAT,  689,    0,  "Low RAH Limit"},                  
-  {HR,        5,      0,  "Setting the EC Fan Max Speed"},   
-  {HR,        695,    0,  "Setting the EC Fan Min Speed"},   
-  {HR_FLOAT,  693,    0,  "Setting Room Temp"},              
-  {HR,        691,    0,  "Setting EC Fan Speed "},          
-  {DI,        146,    0,  "Alarm SAT Sensor Fault"},         
-  {DI,        1246,   0,  "Alarm RAH Sensor Fault"},        
-  {DI,        1245,   0,  "Alarm RAT Sensor Fault"},        
-  {DI,        1250,   0,  "Alarm Filter DP Sensor Fault"},  
-  {DI,        51,     0,  "Alarm Flooding"},                  
-  {DI,        1096,   0,  "Alarm Dirty Filter"},            
-  {DI,        1367,   0,  "Alarm High RAT"},                
-  {DI,        1099,   0,  "Alarm Low RAT"},                 
-  {DI,        118,    0,  "Alarm High SAT"},                 
-  {DI,        122,    0,  "Alarm Low SAT"},                  
-  {DI,        1307,   0,  "Alarm High RAH"},                
-  {DI,        1308,   0,  "Alarm Low RAH"},                 
-  {DI,        1342,   0,  "Alarm Common"},                  
-  {DI,        148,    0,  "Alarm Phase Failure"},            
-  {DI,        1370,   0,  "Alarm Condensate Pump"},         
-  {DI,        1368,   0,  "Alarm Smoke"},                   
-  {DI,        1369,   0,  "Alarm Fire"},                    
-  {DI,        131,    0,  "Alarm EC Fan #1"},                
-  {DI,        132,    0,  "Alarm EC Fan #2"},                
-  {DI,        133,    0,  "Alarm EC Fan #3"},                
-  {DI,        134,    0,  "Alarm EC Fan #4"},                
-  {DI,        135,    0,  "Alarm EC Fan #5"},                
-  {DI,        136,    0,  "Alarm EC Fan #6"},                
-  {DI,        1360,   0,  "Alarm EC Fan #7"},               
-  {DI,        1361,   0,  "Alarm EC Fan #8"},               
-  {DI,        1362,   0,  "Alarm EC Fan #9"},               
-  {DI,        138,    0,  "Run Status EC Fan #1"},           
-  {DI,        139,    0,  "Run Status EC Fan #2"},           
-  {DI,        140,    0,  "Run Status EC Fan #3"},           
-  {DI,        141,    0,  "Run Status EC Fan #4"},           
-  {DI,        142,    0,  "Run Status EC Fan #5"},           
-  {DI,        143,    0,  "Run Status EC Fan #6"},           
-  {DI,        1363,   0,  "Run Status EC Fan #7"},          
-  {DI,        1364,   0,  "Run Status EC Fan #8"},          
-  {DI,        1365,   0,  "Run Status EC Fan #9"},          
-  {IR_FLOAT,  99,     0,  "SAT Reading"},                     
-  {IR_FLOAT,  70,     0,  "RAH Reading"},                     
-  {IR_FLOAT,  101,    0,  "RAT Reading"},                    
-  {IR_FLOAT,  106,    0,  "Filter DP Reading"},              
-  {IR_FLOAT,  496,    0,  "CW Valve Position"},              
-  {IR,        53,     0,  "Speed EC Fan #1"},                 
-  {IR,        228,    0,  "Speed EC Fan #2"},                
-  {IR,        229,    0,  "Speed EC Fan #3"},                
-  {IR,        230,    0,  "Speed EC Fan #4"},                
-  {IR,        231,    0,  "Speed EC Fan #5"},                
-  {IR,        232,    0,  "Speed EC Fan #6"},                
-  {IR,        678,    0,  "Speed EC Fan #7"},                
-  {IR,        679,    0,  "Speed EC Fan #8"},                
-  {IR,        680,    0,  "Speed EC Fan #9"},                
-  {IR,        274,    0,  "Operating Hours EC Fan #1"},      
-  {IR,        233,    0,  "Operating Hours EC Fan #2"},      
-  {IR,        244,    0,  "Operating Hours EC Fan #3"},      
-  {IR,        235,    0,  "Operating Hours EC Fan #4"},      
-  {IR,        236,    0,  "Operating Hours EC Fan #5"},      
-  {IR,        245,    0,  "Operating Hours EC Fan #6"},      
-  {IR,        486,    0,  "Operating Hours EC Fan #7"},      
-  {IR,        487,    0,  "Operating Hours EC Fan #8"},      
-  {IR,        488,    0,  "Operating Hours EC Fan #9"},      
-  {COIL,      301,    0,  "ON/OFF Command By BMS"},        
-  {COIL,      302,    0,  "Enable Off By Supervisory"},    
-  {COIL,      264,    0,  "Alarm Reset"}                                  
-};
-//Size of modbus map used in FOR cycles, automatically calculated.
-
-/**
- * @brief The total number of entries in the `mb_map` array.
- * This is calculated at compile time and used for iterating over the map.
- */
-const int map_size = sizeof(mb_map) / sizeof(mb_map[0]);
-
-/** @brief The main loop update interval in milliseconds. */
-int interval = 250; 
-/** @} */ // End of ModbusMapConfig group
-
-#endif // CONFIG_H
diff --git a/src/EPMS/SCP/SCP_Manufacturer_Model_TCP/main.cpp b/src/EPMS/SCP/SCP_Manufacturer_Model_TCP/main.cpp
deleted file mode 100644
index 286a98c..0000000
--- a/src/EPMS/SCP/SCP_Manufacturer_Model_TCP/main.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-/**
- * @file main.cpp
- * @brief Main execution program for the CRAH Unit (TCP) Emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * @details This file contains the main execution program for an Arduino-based emulator of a CRAH unit. 
- * The program uses a Wi-Fi connection to communicate via the Modbus IP protocol.
- *
- * The setup() function initializes the following:
- * - Serial communication for debugging.
- * - Wi-Fi connection using credentials from config.h.
- * - A Modbus TCP server.
- * - Modbus points (Coils, Holding Registers, etc.) based on a predefined map in config.h.
- *
- * The loop() function continuously:
- * - Services the Modbus TCP server to handle incoming requests.
- * - Periodically calls the main update loop for the emulated equipment, which
- *   manages state transitions and behavior strategies.
- *
- * @see config.h for Wi-Fi and Modbus configuration.
- * @see Equipment.h for the main equipment logic.
- * @see State.h for different equipment states.
- * @see Strategies/Strategy_Behavior.h for value generation strategies.
- * @see Modbus_Point.h for the base class for all Modbus points.
- */
-//=================================================================================================================================
-//Libraries and declaration of variables.
-#include <WiFi.h>
-#include "config.h"
-#include "ModbusPoints/Modbus_PointFactory.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-//=================================================================================================================================
-/** 
- * @brief Initializes the application.
- * @details This function runs once at startup. It configures the serial communication, 
- * Wi-Fi, and the Modbus server. It also creates and initializes all the Modbus points 
- * based on the `mb_map` array in `config.h`.
- */
-void setup() {
-  Serial.begin(115200);                       //Serial comm start
-  WiFi.config(local_IP, gateway, subnet);     // Wifi service start
-  WiFi.begin(ssid, password);
-  while (WiFi.status() != WL_CONNECTED) {
-    delay(1000);
-    Serial.print(".");
-  }
-  Serial.println("Connected!!");
-  mb.server();                                //Modbus server start
-  Serial.println("Server Created");
-  Serial.println(map_size);
-  for(int i = 0; i < map_size; i++){
-    Modbus_Point<ModbusIP>* point = createModbus_Point(&mb, mb_map[i].category, mb_map[i].address, mb_map[i].value, mb_map[i].description);
-    if (point) {
-      point->addToModbusServer();
-      EquipmentInstance.addModbus_Point(mb_map[i].description, point);
-    }
-  }
-  Serial.println("All modbus Points created");
-  Serial.println("Setup function ended");
-}
-//=================================================================================================================================
-/** 
- * @brief The main application loop.
- * @details This function runs repeatedly after setup() has completed. It performs two main actions:
- * 1. It continuously services the Modbus server by calling `mb.task()` to handle
- *    incoming requests from a Modbus master.
- * 2. At a fixed interval (defined in `config.h`), it calls `EquipmentInstance.update()`
- *    to run the emulator's internal state machine and behavior logic.
- */
-void loop() {
-  mb.task();
-  unsigned long currentMillis = millis();
-  if (currentMillis - previousMillis >= interval) {
-    previousMillis = currentMillis;
-    unsigned long startTime = millis();
-    EquipmentInstance.update();
-    unsigned long endTime = millis();
-    unsigned long elapsedTime = endTime - startTime;
-    Serial.printf("Control Execution time: %d ms\n", elapsedTime);
-  } 
-}
diff --git a/src/EPMS/STS/STS_PowerSmiths_STATYS_UL_600A_TCP/README.md b/src/EPMS/STS/STS_PowerSmiths_STATYS_UL_600A_TCP/README.md
deleted file mode 100644
index 355156f..0000000
--- a/src/EPMS/STS/STS_PowerSmiths_STATYS_UL_600A_TCP/README.md
+++ /dev/null
@@ -1,33 +0,0 @@
-# EQUIPMENT_TYPE MANUFACTURER MODEL TCP
-
-## Brief Introduction
-Equipment specifc details that make it different from other devices
-
-## List of Equipmentt
-This cofiguration has been used for these models:
-* **Model**: 09-15-22 
-* **Model**: 09-15-23 
-* **Model**: 09-15-25 
-
-## Hardware Prerequisites
-
-The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities.
-* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html) 
-
----
-
-## States and Strategies
-Provide a brief description of what variables and strategies were used in this configuraiton
-
-### Standby State
-* **Equipment running**: set to 0
-* **Common Alarm**: set to 0
-* **SAT temperature**: set to 85
-
-### Running State
-* **Equipment running**: set to 1
-* **SAT temperature**: **Ramp Strategy** set to 65 deg setpoint
-
-### Fail State
-* **Commong Alarm**: set to 1
-* **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset
diff --git a/src/EPMS/STS/STS_PowerSmiths_STATYS_UL_600A_TCP/State_Fail.cpp b/src/EPMS/STS/STS_PowerSmiths_STATYS_UL_600A_TCP/State_Fail.cpp
deleted file mode 100644
index 8bc0385..0000000
--- a/src/EPMS/STS/STS_PowerSmiths_STATYS_UL_600A_TCP/State_Fail.cpp
+++ /dev/null
@@ -1,81 +0,0 @@
-/**
- * @file State_Fail.cpp
- * @brief Implementation of the FailState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the FailState, which defines
- * the behavior of the equipment when it has entered a fault condition.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new FailState object with a list of active alarms.
- *
- * This constructor receives a list of alarm descriptions and creates strategies
- * to set the corresponding Modbus points to a value of 1, indicating an
- * active alarm. It also initializes a PID strategy for the 'CW Valve Position'
- * to maintain its state during the fault.
- * @param activeAlarms A vector of strings, where each string is the
- *                     description of a Modbus point to be set as an active alarm.
- */
-template<>
-FailState<ModbusIP>::FailState(const std::vector<std::string>& activeAlarms) {
-    // Simulate a failure: set common alarm and a specific fan alarm.
-
-    
-}
-
-/**
- * @brief Executes the fail state's logic for one update cycle.
- *
- * This method checks the "Alarm Reset" Modbus point for a command to
- * transition back to Standby, which would typically happen after a fault
- * is cleared by a user. If no transition is requested, it continues to apply
- * the failure strategies (e.g., keeping alarm bits active).
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* FailState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Fail update function");
-    
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the fail state.
- * Sets the "Alarm Common" point to 1 to indicate a general fault condition.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Fail State...");
-}
-
-/**
- * @brief Logic to execute once when exiting the fail state.
- * Clears the "Alarm Common" point to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Fail State...");
-}
\ No newline at end of file
diff --git a/src/EPMS/STS/STS_PowerSmiths_STATYS_UL_600A_TCP/State_Running.cpp b/src/EPMS/STS/STS_PowerSmiths_STATYS_UL_600A_TCP/State_Running.cpp
deleted file mode 100644
index b9e4a99..0000000
--- a/src/EPMS/STS/STS_PowerSmiths_STATYS_UL_600A_TCP/State_Running.cpp
+++ /dev/null
@@ -1,89 +0,0 @@
-/**
- * @file State_Running.cpp
- * @brief Implementation of the RunningState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the RunningState, which defines
- * the behavior of the equipment when it is actively running.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "Strategies/Strategy_Totalizer.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new RunningState object.
- *
- * This constructor initializes behavior strategies active during the running
- * state, such as a PID controller for the 'CW Valve Position' and totalizers
- * for the run-hours of each EC fan.
- */
-template<>
-RunningState<ModbusIP>::RunningState() {
-}
-
-/**
- * @brief Executes the running state's logic for one update cycle.
- *
- * This method first checks for state transition commands:
- * 1. It reads the "ON/OFF Command By BMS" point. If it's 0, it transitions to StandbyState.
- * 2. It reads the "Fault Code" point. If it's non-zero, it transitions to FailState,
- *    passing the corresponding alarm description.
- *
- * If no transition occurs, it applies the strategies defined for the running state.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* RunningState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Running update function");
-    
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the running state.
- * Sets the "Run Status" for all EC fans to 1 to indicate they are active.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Running State...");
-    // You could also update a Modbus register to show the "standby" state
-
-}
-
-/**
- * @brief Logic to execute once when exiting the running state.
- * Sets the "Run Status" for all EC fans to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Running State...");
-   
-}
\ No newline at end of file
diff --git a/src/EPMS/STS/STS_PowerSmiths_STATYS_UL_600A_TCP/State_Standby.cpp b/src/EPMS/STS/STS_PowerSmiths_STATYS_UL_600A_TCP/State_Standby.cpp
deleted file mode 100644
index 20029d1..0000000
--- a/src/EPMS/STS/STS_PowerSmiths_STATYS_UL_600A_TCP/State_Standby.cpp
+++ /dev/null
@@ -1,85 +0,0 @@
-/**
- * @file State_Standby.cpp
- * @brief Implementation of the StandbyState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the StandbyState, which defines
- * the behavior of the equipment when it is in an idle or standby mode.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-/**
- * @brief Constructs a new StandbyState object.
- *
- * In this state, the equipment is idle. This constructor initializes strategies
- * to bring the system to a safe, idle condition. It sets a stable value for
- * the SAT reading and creates ramp strategies to bring the CW valve and all
- * EC fan speeds down to zero.
- */
-template<>
-StandbyState<ModbusIP>::StandbyState() {
-    // You can add initialization code here if needed
-    
-
-}
-
-/**
- * @brief Executes the standby state's logic for one update cycle.
- *
- * This method applies the strategies defined for the standby state (e.g.,
- * ramping values to zero).
- *
- * @warning This method currently does not check for a command to transition to the
- *          Running state. This logic needs to be added to allow the unit to start.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* StandbyState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Standby update function");
-    
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the standby state.
- * This method performs cleanup by setting all alarm points and all EC fan
- * run status points to 0.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Standby State...");
-}
-
-/**
- * @brief Logic to execute once when exiting the standby state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Standby State...");
-}
\ No newline at end of file
diff --git a/src/EPMS/STS/STS_PowerSmiths_STATYS_UL_600A_TCP/config.h b/src/EPMS/STS/STS_PowerSmiths_STATYS_UL_600A_TCP/config.h
deleted file mode 100644
index 6a061ba..0000000
--- a/src/EPMS/STS/STS_PowerSmiths_STATYS_UL_600A_TCP/config.h
+++ /dev/null
@@ -1,162 +0,0 @@
-/**
- * @file config.h
- * @brief Main configuration file for the STS Powersmiths STATYS UL 600A
- * @author Zach Gutierrez
- * @date 2025-09-02
- *
- * This file contains two important configurations: WiFi network parameters
- * and the Modbus register map for the device.
- */
-
-#ifndef CONFIG_H
-#define CONFIG_H
-
-#include "core.h"
-#include "Equipment/Equipment.h"
-
-#if defined(USE_MODBUS_IP)
-/**
-   * @defgroup ModbusTCPConfig Modbus IP Configuration
-   * @brief Parameters for Modbus TCP communication.
-   * @{
-   */
-  #include <ModbusIP_ESP8266.h>
-  const char *ssid = "wifi_name";       /**< @brief The SSID of the WiFi network. */
-  const char *password = "wifi_password";   /**< @brief The password for the WiFi network. */
-  IPAddress local_IP(192, 168, 1, 234);       /**< @brief The static IP address for the device. */
-  IPAddress gateway(192, 168, 1, 1);          /**< @brief The gateway IP address. */
-  IPAddress subnet(255, 255, 255, 0);         /**< @brief The subnet mask. */
-  
-  ModbusIP mb;
-#else
-  /**
-   * @defgroup ModbusRTUConfig Modbus RTU Configuration
-   * @brief Parameters for serial Modbus RTU communication.
-   * @{
-   */
-  #include <ModbusRTU.h>
-  const int BAUDRATE = 19200;   /**< @brief The serial communication speed in bits per second. */
-  const int RX_PIN = 17;        /**< @brief The GPIO pin used for receiving data (RX). */
-  const int TX_PIN = 16;        /**< @brief The GPIO pin used for transmitting data (TX). */
-  const int RST_PIN = 4;        /**< @brief The GPIO pin connected to the RS485 driver's DE/RE pins for direction control. */
-  const int MODBUS_ID = 1;      /**< @brief The unique slave ID for this device on the Modbus bus. */
-  /** @} */
-
-  /** @brief Global instance of the Modbus RTU server. */
-  ModbusRTU mb;
-#endif
-
-
-
-/**
- * @defgroup ModbusMapConfig Modbus Map Configuration
- * @brief Defines the Modbus register map and related parameters for the emulator.
- * @{
- */
-/**
- * @brief The Modbus map for the Equipment device.
- * This array defines all the Modbus points available on the emulated device.
- * The `description` field is crucial as it's used to look up points within the application logic.
- */
-modbusMap mb_map[] = {
-  {HR, 56, 0, "Amb_Temp_Alm" },
-  {HR, 70, 0, "Amps_A" },
-  {HR, 71, 0, "Amps_B" },
-  {HR, 72, 0, "Amps_C" },
-  {HR, 73, 0, "Amps_N" },
-  {HR, 49, 0, "CB1_Status" },
-  {HR, 49, 0, "CB2_Status" },
-  {HR, 49, 0, "CB3_Status" },
-  {HR, 49, 0, "CB3A_Status" },
-  {HR, 49, 0, "CB4_Status" },
-  {HR, 49, 0, "CB5_Status" },
-  {HR, 59, 0, "Comm_Fail" },
-  {HR, 56, 0, "Cons_Volt" },
-  {HR, 77, 0, "FREQ" },
-  {HR, 56, 0, "Gen_Alm" },
-  {HR, 56, 0, "Imm_Stop" },
-  {HR, 48, 0, "In_Ser_Mode" },
-  {HR, 68, 0, "kVA" },
-  {HR, 112, 0, "kVA_A" },
-  {HR, 113, 0, "kVA_B" },
-  {HR, 114, 0, "kVA_C" },
-  {HR, 69, 0,  "kW" },
-  {HR, 115, 0, "kW_A" },
-  {HR, 116, 0, "kW_B" },
-  {HR, 117, 0, "kW_C" },
-  {HR, 56, 12, "Maint_Alm" },
-  {HR, 48, 15, "Maint_Alt" },
-  {HR, 56, 8,  "Out_Of_Tol" },
-  {HR, 56, 7,  "Out_Sht_Ckt_Det" },
-  {HR, 56, 1,  "Ovrld" },
-  {HR, 1007, 0, "Ovrd" },
-  {HR, 41, 0, "Perc_Load" },
-  {HR, 65, 0, "Perc_Load_A" },
-  {HR, 66, 0, "Perc_Load_B" },
-  {HR, 67, 0, "Perc_Load_C" },
-  {HR, 121, 0, "PF_A" },
-  {HR, 122, 0, "PF_B" },
-  {HR, 123, 0, "PF_C" },
-  {HR, 51, 0,  "S1_Active" },
-  {HR, 128, 0, "S1_Amps_A" },
-  {HR, 129, 0, "S1_Amps_B" },
-  {HR, 130, 0, "S1_Amps_C" },
-  {HR, 99, 0,  "S1_FREQ" },
-  {HR, 92, 0,  "S1_kVA" },
-  {HR, 80, 0,  "S1_kVA_A" },
-  {HR, 81, 0,  "S1_kVA_B" },
-  {HR, 82, 0,  "S1_kVA_C" },
-  {HR, 93, 0,  "S1_kW" },
-  {HR, 131, 0, "S1_kW_A" },
-  {HR, 132, 0, "S1_kW_B" },
-  {HR, 133, 0, "S1_kW_C" },
-  {HR, 2050, 0, "S1_Not_Avail" },
-  {HR, 51, 0, "S1_OK" },
-  {HR, 48, 0, "S1_Pref" },
-  {HR, 100, 0, "S1_Volts_AB" },
-  {HR, 101, 0, "S1_Volts_BC" },
-  {HR, 102, 0, "S1_Volts_CA" },
-  {HR, 51, 0, "S2_Active" },
-  {HR, 134, 0, "S2_Amps_A" },
-  {HR, 135, 0, "S2_Amps_B" },
-  {HR, 136, 0, "S2_Amps_C" },
-  {HR, 106, 0, "S2_FREQ" },
-  {HR, 94, 0, "S2_kVA" },
-  {HR, 83, 0, "S2_kVA_A" },
-  {HR, 84, 0, "S2_kVA_B" },
-  {HR, 85, 0, "S2_kVA_C" },
-  {HR, 95, 0, "S2_kW" },
-  {HR, 137, 0, "S2_kW_A" },
-  {HR, 138, 0, "S2_kW_B" },
-  {HR, 139, 0, "S2_kW_C" },
-  {HR, 2052, 0,"S2_Not_Avail" },
-  {HR, 51, 56, "S2_OK" },
-  {HR, 48, 7,  "S2_Pref" },
-  {HR, 107, 0, "S2_Volts_AB" },
-  {HR, 108, 0, "S2_Volts_BC" },
-  {HR, 109, 0, "S2_Volts_CA" },
-  {HR, 51, 0,  "SS1_Closed" },
-  {HR, 51, 0,  "SS2_Closed" },
-  {HR, 59, 0,  "STS_Power_Off" },
-  {HR, 56, 0,  "SWBK_Imposs" },
-  {HR, 79, 0, "Temp" },
-  {HR, 42, 0, "Ttl_Trsfer_Cnt" },
-  {HR, 56, 0, "Trsfer_Impo" },
-  {HR, 48, 0, "Trsfer_Lock" },
-  {HR, 118, 0, "Volts_AB" },
-  {HR, 119, 0, "Volts_BC" },
-  {HR, 120, 0, "Volts_CA" }
-};
-//Size of modbus map used in FOR cycles, automatically calculated.
-
-/**
- * @brief The total number of entries in the `mb_map` array.
- * This is calculated at compile time and used for iterating over the map.
- */
-const int map_size = sizeof(mb_map) / sizeof(mb_map[0]);
-
-/** @brief The main loop update interval in milliseconds. */
-int interval = 250; 
-/** @} */ // End of ModbusMapConfig group
-
-#endif // CONFIG_H
diff --git a/src/EPMS/STS/STS_PowerSmiths_STATYS_UL_600A_TCP/main.cpp b/src/EPMS/STS/STS_PowerSmiths_STATYS_UL_600A_TCP/main.cpp
deleted file mode 100644
index 286a98c..0000000
--- a/src/EPMS/STS/STS_PowerSmiths_STATYS_UL_600A_TCP/main.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-/**
- * @file main.cpp
- * @brief Main execution program for the CRAH Unit (TCP) Emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * @details This file contains the main execution program for an Arduino-based emulator of a CRAH unit. 
- * The program uses a Wi-Fi connection to communicate via the Modbus IP protocol.
- *
- * The setup() function initializes the following:
- * - Serial communication for debugging.
- * - Wi-Fi connection using credentials from config.h.
- * - A Modbus TCP server.
- * - Modbus points (Coils, Holding Registers, etc.) based on a predefined map in config.h.
- *
- * The loop() function continuously:
- * - Services the Modbus TCP server to handle incoming requests.
- * - Periodically calls the main update loop for the emulated equipment, which
- *   manages state transitions and behavior strategies.
- *
- * @see config.h for Wi-Fi and Modbus configuration.
- * @see Equipment.h for the main equipment logic.
- * @see State.h for different equipment states.
- * @see Strategies/Strategy_Behavior.h for value generation strategies.
- * @see Modbus_Point.h for the base class for all Modbus points.
- */
-//=================================================================================================================================
-//Libraries and declaration of variables.
-#include <WiFi.h>
-#include "config.h"
-#include "ModbusPoints/Modbus_PointFactory.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-//=================================================================================================================================
-/** 
- * @brief Initializes the application.
- * @details This function runs once at startup. It configures the serial communication, 
- * Wi-Fi, and the Modbus server. It also creates and initializes all the Modbus points 
- * based on the `mb_map` array in `config.h`.
- */
-void setup() {
-  Serial.begin(115200);                       //Serial comm start
-  WiFi.config(local_IP, gateway, subnet);     // Wifi service start
-  WiFi.begin(ssid, password);
-  while (WiFi.status() != WL_CONNECTED) {
-    delay(1000);
-    Serial.print(".");
-  }
-  Serial.println("Connected!!");
-  mb.server();                                //Modbus server start
-  Serial.println("Server Created");
-  Serial.println(map_size);
-  for(int i = 0; i < map_size; i++){
-    Modbus_Point<ModbusIP>* point = createModbus_Point(&mb, mb_map[i].category, mb_map[i].address, mb_map[i].value, mb_map[i].description);
-    if (point) {
-      point->addToModbusServer();
-      EquipmentInstance.addModbus_Point(mb_map[i].description, point);
-    }
-  }
-  Serial.println("All modbus Points created");
-  Serial.println("Setup function ended");
-}
-//=================================================================================================================================
-/** 
- * @brief The main application loop.
- * @details This function runs repeatedly after setup() has completed. It performs two main actions:
- * 1. It continuously services the Modbus server by calling `mb.task()` to handle
- *    incoming requests from a Modbus master.
- * 2. At a fixed interval (defined in `config.h`), it calls `EquipmentInstance.update()`
- *    to run the emulator's internal state machine and behavior logic.
- */
-void loop() {
-  mb.task();
-  unsigned long currentMillis = millis();
-  if (currentMillis - previousMillis >= interval) {
-    previousMillis = currentMillis;
-    unsigned long startTime = millis();
-    EquipmentInstance.update();
-    unsigned long endTime = millis();
-    unsigned long elapsedTime = endTime - startTime;
-    Serial.printf("Control Execution time: %d ms\n", elapsedTime);
-  } 
-}
diff --git a/src/EPMS/STS/Vertiv STA0600A32A572/README.md b/src/EPMS/STS/Vertiv STA0600A32A572/README.md
deleted file mode 100644
index 4f156e3..0000000
--- a/src/EPMS/STS/Vertiv STA0600A32A572/README.md	
+++ /dev/null
@@ -1,48 +0,0 @@
-# Daikin Chiller (RTU) Emulator
-
-This project is an Arduino-based emulator for a Daikin Chiller unit, communicating over Modbus RTU. It is designed to be a flexible template that can be adapted to simulate different types of chillers by modifying the configuration and state logic.
-
-The emulator operates on a state machine with three core states:
-* **Standby**: The chiller is idle but ready.
-* **Running**: The chiller is active and operational.
-* **Fail**: The chiller has encountered a fault condition.
-
-## Features
-
-* **Modbus RTU Communication**: Emulates a Modbus slave device.
-* **State Machine Logic**: Simulates different operational states (Standby, Running, Fail).
-* **Dynamic Value Simulation**: Uses "Strategies" (e.g., PID, Ramp) to generate realistic, changing values for Modbus points.
-* **Configurable Modbus Map**: The entire Modbus register map is defined in a single, easy-to-modify file (`config.h`).
-* **Extensible Design**: The structure allows for the addition of new states and behaviors.
-
-## Hardware Prerequisites
-
-The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities and at least one hardware serial port for RS485 communication.
-
-* **Microcontroller**: ESP8266, ESP32, or similar.
-* **RS485 Transceiver**: A module like the MAX485 to interface with the Modbus RTU bus.
-
-## Software Dependencies
-
-This project relies on a Modbus library. Ensure you have the correct library installed in your Arduino IDE.
-
-* **Modbus Library**: The code uses a library that provides `ModbusRTU.h` and optionally `ModbusIP_ESP8266.h`.
-
----
-
-## How to Customize for a New Chiller
-
-To adapt this template for a new chiller, follow these steps.
-
-### 1. Configure Device-Specific Parameters (`config.h`)
-
-Open `CH_Daikin_AWV026B_RTU/config.h`. This is the main file for device-specific settings.
-
-#### Modbus RTU Settings
-Update the following constants for your device's serial communication setup.
-```c++
-const int BAUDRATE = 19200;   // The serial communication speed
-const int RX_PIN = 17;        // The GPIO pin for receiving data (RX)
-const int TX_PIN = 16;        // The GPIO pin for transmitting data (TX)
-const int RST_PIN = 4;        // The GPIO pin for RS485 direction control
-const int MODBUS_ID = 1;      // The unique slave ID for this device
\ No newline at end of file
diff --git a/src/EPMS/STS/Vertiv STA0600A32A572/State_Fail.cpp b/src/EPMS/STS/Vertiv STA0600A32A572/State_Fail.cpp
deleted file mode 100644
index 8bc0385..0000000
--- a/src/EPMS/STS/Vertiv STA0600A32A572/State_Fail.cpp	
+++ /dev/null
@@ -1,81 +0,0 @@
-/**
- * @file State_Fail.cpp
- * @brief Implementation of the FailState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the FailState, which defines
- * the behavior of the equipment when it has entered a fault condition.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new FailState object with a list of active alarms.
- *
- * This constructor receives a list of alarm descriptions and creates strategies
- * to set the corresponding Modbus points to a value of 1, indicating an
- * active alarm. It also initializes a PID strategy for the 'CW Valve Position'
- * to maintain its state during the fault.
- * @param activeAlarms A vector of strings, where each string is the
- *                     description of a Modbus point to be set as an active alarm.
- */
-template<>
-FailState<ModbusIP>::FailState(const std::vector<std::string>& activeAlarms) {
-    // Simulate a failure: set common alarm and a specific fan alarm.
-
-    
-}
-
-/**
- * @brief Executes the fail state's logic for one update cycle.
- *
- * This method checks the "Alarm Reset" Modbus point for a command to
- * transition back to Standby, which would typically happen after a fault
- * is cleared by a user. If no transition is requested, it continues to apply
- * the failure strategies (e.g., keeping alarm bits active).
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* FailState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Fail update function");
-    
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the fail state.
- * Sets the "Alarm Common" point to 1 to indicate a general fault condition.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Fail State...");
-}
-
-/**
- * @brief Logic to execute once when exiting the fail state.
- * Clears the "Alarm Common" point to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Fail State...");
-}
\ No newline at end of file
diff --git a/src/EPMS/STS/Vertiv STA0600A32A572/State_Running.cpp b/src/EPMS/STS/Vertiv STA0600A32A572/State_Running.cpp
deleted file mode 100644
index b9e4a99..0000000
--- a/src/EPMS/STS/Vertiv STA0600A32A572/State_Running.cpp	
+++ /dev/null
@@ -1,89 +0,0 @@
-/**
- * @file State_Running.cpp
- * @brief Implementation of the RunningState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the RunningState, which defines
- * the behavior of the equipment when it is actively running.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "Strategies/Strategy_Totalizer.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new RunningState object.
- *
- * This constructor initializes behavior strategies active during the running
- * state, such as a PID controller for the 'CW Valve Position' and totalizers
- * for the run-hours of each EC fan.
- */
-template<>
-RunningState<ModbusIP>::RunningState() {
-}
-
-/**
- * @brief Executes the running state's logic for one update cycle.
- *
- * This method first checks for state transition commands:
- * 1. It reads the "ON/OFF Command By BMS" point. If it's 0, it transitions to StandbyState.
- * 2. It reads the "Fault Code" point. If it's non-zero, it transitions to FailState,
- *    passing the corresponding alarm description.
- *
- * If no transition occurs, it applies the strategies defined for the running state.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* RunningState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Running update function");
-    
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the running state.
- * Sets the "Run Status" for all EC fans to 1 to indicate they are active.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Running State...");
-    // You could also update a Modbus register to show the "standby" state
-
-}
-
-/**
- * @brief Logic to execute once when exiting the running state.
- * Sets the "Run Status" for all EC fans to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Running State...");
-   
-}
\ No newline at end of file
diff --git a/src/EPMS/STS/Vertiv STA0600A32A572/State_Standby.cpp b/src/EPMS/STS/Vertiv STA0600A32A572/State_Standby.cpp
deleted file mode 100644
index 20029d1..0000000
--- a/src/EPMS/STS/Vertiv STA0600A32A572/State_Standby.cpp	
+++ /dev/null
@@ -1,85 +0,0 @@
-/**
- * @file State_Standby.cpp
- * @brief Implementation of the StandbyState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the StandbyState, which defines
- * the behavior of the equipment when it is in an idle or standby mode.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-/**
- * @brief Constructs a new StandbyState object.
- *
- * In this state, the equipment is idle. This constructor initializes strategies
- * to bring the system to a safe, idle condition. It sets a stable value for
- * the SAT reading and creates ramp strategies to bring the CW valve and all
- * EC fan speeds down to zero.
- */
-template<>
-StandbyState<ModbusIP>::StandbyState() {
-    // You can add initialization code here if needed
-    
-
-}
-
-/**
- * @brief Executes the standby state's logic for one update cycle.
- *
- * This method applies the strategies defined for the standby state (e.g.,
- * ramping values to zero).
- *
- * @warning This method currently does not check for a command to transition to the
- *          Running state. This logic needs to be added to allow the unit to start.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* StandbyState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Standby update function");
-    
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the standby state.
- * This method performs cleanup by setting all alarm points and all EC fan
- * run status points to 0.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Standby State...");
-}
-
-/**
- * @brief Logic to execute once when exiting the standby state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Standby State...");
-}
\ No newline at end of file
diff --git a/src/EPMS/STS/Vertiv STA0600A32A572/config.h b/src/EPMS/STS/Vertiv STA0600A32A572/config.h
deleted file mode 100644
index a7ce4c2..0000000
--- a/src/EPMS/STS/Vertiv STA0600A32A572/config.h	
+++ /dev/null
@@ -1,102 +0,0 @@
-/**
- * @file config.h
- * @brief Main configuration file for the CRAH Unit (TCP) emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * This file contains two important configurations: WiFi network parameters
- * and the Modbus register map for the device.
- */
-
-#ifndef CONFIG_H
-#define CONFIG_H
-
-#include "core.h"
-#include "Equipment/Equipment.h"
-
-#if defined(USE_MODBUS_IP)
-/**
-   * @defgroup ModbusTCPConfig Modbus IP Configuration
-   * @brief Parameters for Modbus TCP communication.
-   * @{
-   */
-  #include <ModbusIP_ESP8266.h>
-  const char *ssid = "wifi_name";       /**< @brief The SSID of the WiFi network. */
-  const char *password = "wifi_password";   /**< @brief The password for the WiFi network. */
-  IPAddress local_IP(192, 168, 1, 234);       /**< @brief The static IP address for the device. */
-  IPAddress gateway(192, 168, 1, 1);          /**< @brief The gateway IP address. */
-  IPAddress subnet(255, 255, 255, 0);         /**< @brief The subnet mask. */
-  
-  ModbusIP mb;
-#else
-  /**
-   * @defgroup ModbusRTUConfig Modbus RTU Configuration
-   * @brief Parameters for serial Modbus RTU communication.
-   * @{
-   */
-  #include <ModbusRTU.h>
-  const int BAUDRATE = 19200;   /**< @brief The serial communication speed in bits per second. */
-  const int RX_PIN = 17;        /**< @brief The GPIO pin used for receiving data (RX). */
-  const int TX_PIN = 16;        /**< @brief The GPIO pin used for transmitting data (TX). */
-  const int RST_PIN = 4;        /**< @brief The GPIO pin connected to the RS485 driver's DE/RE pins for direction control. */
-  const int MODBUS_ID = 1;      /**< @brief The unique slave ID for this device on the Modbus bus. */
-  /** @} */
-
-  /** @brief Global instance of the Modbus RTU server. */
-  ModbusRTU mb;
-#endif
-
-
-
-/**
- * @defgroup ModbusMapConfig Modbus Map Configuration
- * @brief Defines the Modbus register map and related parameters for the emulator.
- * @{
- */
-/**
- * @brief The Modbus map for the Equipment device.
- * This array defines all the Modbus points available on the emulated device.
- * The `description` field is crucial as it's used to look up points within the application logic.
- */
-modbusMap mb_map[] =
-{   
-  {HR,        15,     0,  "State Control"},  //Internal to control from Modscan
-  {HR,        16,     0,  "Fault Code"}, //Internal Fault code from Modscan 
-  {HR,        289,    0,  "Alarm Status Word 1"},     
-  {HR,        290,    0,  "Alarm Status Word 2"},                     
-  {HR,        291,    0,  "Alarm Status Word 3"},                   
-  {HR,        292,    0,  "Alarm Status Word 4"},                 
-  {HR,        24,     0,  "Status Word"},                  
-  {HR,        3,      0,  "Active Source"},                 
-  {HR,        2,      0,  "Preferred Source"},                  
-  {HR,        1,      0,  "Total Transfer Count"},                 
-  {HR,        19,     0,  "Output kVA"},                  
-  {HR,        18,     0,  "Output kW"},   
-  {HR,        7,      0,  "Source 1 Amps A"},   
-  {HR,        8,      0,  "Source 1 Amps B"},              
-  {HR,        9,      0,  "Source 1 Amps C"},          
-  {HR,        10,     0,  "Source 1 Frequency"},         
-  {HR,        4,      0,  "Source 1 Volts A-B"},        
-  {HR,        5,      0,  "Source 1 Volts B-C"},        
-  {HR,        6,      0,  "Source 1 Volts C-A"},  
-  {HR,        14,     0,  "Source 2 Amps A"},                  
-  {HR,        15,     0,  "Source 2 Amps B"},            
-  {HR,        16,     0,  "Source 2 Amps C"},                
-  {HR,        17,     0,  "Source 2 Frequency"},                 
-  {HR,        11,     0,  "Source 2 Volts A-B"},                 
-  {HR,        12,     0,  "Source 2 Volts B-C"},                  
-  {HR,        13,     0,  "Source 2 Volts C-A"},                                       
-};
-//Size of modbus map used in FOR cycles, automatically calculated.
-
-/**
- * @brief The total number of entries in the `mb_map` array.
- * This is calculated at compile time and used for iterating over the map.
- */
-const int map_size = sizeof(mb_map) / sizeof(mb_map[0]);
-
-/** @brief The main loop update interval in milliseconds. */
-int interval = 250; 
-/** @} */ // End of ModbusMapConfig group
-
-#endif // CONFIG_H
diff --git a/src/EPMS/STS/Vertiv STA0600A32A572/main.cpp b/src/EPMS/STS/Vertiv STA0600A32A572/main.cpp
deleted file mode 100644
index 286a98c..0000000
--- a/src/EPMS/STS/Vertiv STA0600A32A572/main.cpp	
+++ /dev/null
@@ -1,86 +0,0 @@
-/**
- * @file main.cpp
- * @brief Main execution program for the CRAH Unit (TCP) Emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * @details This file contains the main execution program for an Arduino-based emulator of a CRAH unit. 
- * The program uses a Wi-Fi connection to communicate via the Modbus IP protocol.
- *
- * The setup() function initializes the following:
- * - Serial communication for debugging.
- * - Wi-Fi connection using credentials from config.h.
- * - A Modbus TCP server.
- * - Modbus points (Coils, Holding Registers, etc.) based on a predefined map in config.h.
- *
- * The loop() function continuously:
- * - Services the Modbus TCP server to handle incoming requests.
- * - Periodically calls the main update loop for the emulated equipment, which
- *   manages state transitions and behavior strategies.
- *
- * @see config.h for Wi-Fi and Modbus configuration.
- * @see Equipment.h for the main equipment logic.
- * @see State.h for different equipment states.
- * @see Strategies/Strategy_Behavior.h for value generation strategies.
- * @see Modbus_Point.h for the base class for all Modbus points.
- */
-//=================================================================================================================================
-//Libraries and declaration of variables.
-#include <WiFi.h>
-#include "config.h"
-#include "ModbusPoints/Modbus_PointFactory.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-//=================================================================================================================================
-/** 
- * @brief Initializes the application.
- * @details This function runs once at startup. It configures the serial communication, 
- * Wi-Fi, and the Modbus server. It also creates and initializes all the Modbus points 
- * based on the `mb_map` array in `config.h`.
- */
-void setup() {
-  Serial.begin(115200);                       //Serial comm start
-  WiFi.config(local_IP, gateway, subnet);     // Wifi service start
-  WiFi.begin(ssid, password);
-  while (WiFi.status() != WL_CONNECTED) {
-    delay(1000);
-    Serial.print(".");
-  }
-  Serial.println("Connected!!");
-  mb.server();                                //Modbus server start
-  Serial.println("Server Created");
-  Serial.println(map_size);
-  for(int i = 0; i < map_size; i++){
-    Modbus_Point<ModbusIP>* point = createModbus_Point(&mb, mb_map[i].category, mb_map[i].address, mb_map[i].value, mb_map[i].description);
-    if (point) {
-      point->addToModbusServer();
-      EquipmentInstance.addModbus_Point(mb_map[i].description, point);
-    }
-  }
-  Serial.println("All modbus Points created");
-  Serial.println("Setup function ended");
-}
-//=================================================================================================================================
-/** 
- * @brief The main application loop.
- * @details This function runs repeatedly after setup() has completed. It performs two main actions:
- * 1. It continuously services the Modbus server by calling `mb.task()` to handle
- *    incoming requests from a Modbus master.
- * 2. At a fixed interval (defined in `config.h`), it calls `EquipmentInstance.update()`
- *    to run the emulator's internal state machine and behavior logic.
- */
-void loop() {
-  mb.task();
-  unsigned long currentMillis = millis();
-  if (currentMillis - previousMillis >= interval) {
-    previousMillis = currentMillis;
-    unsigned long startTime = millis();
-    EquipmentInstance.update();
-    unsigned long endTime = millis();
-    unsigned long elapsedTime = endTime - startTime;
-    Serial.printf("Control Execution time: %d ms\n", elapsedTime);
-  } 
-}
diff --git a/src/EPMS/UPS/UPS_Vertiv_APM2_TCP/README.md b/src/EPMS/UPS/UPS_Vertiv_APM2_TCP/README.md
deleted file mode 100644
index 4f156e3..0000000
--- a/src/EPMS/UPS/UPS_Vertiv_APM2_TCP/README.md
+++ /dev/null
@@ -1,48 +0,0 @@
-# Daikin Chiller (RTU) Emulator
-
-This project is an Arduino-based emulator for a Daikin Chiller unit, communicating over Modbus RTU. It is designed to be a flexible template that can be adapted to simulate different types of chillers by modifying the configuration and state logic.
-
-The emulator operates on a state machine with three core states:
-* **Standby**: The chiller is idle but ready.
-* **Running**: The chiller is active and operational.
-* **Fail**: The chiller has encountered a fault condition.
-
-## Features
-
-* **Modbus RTU Communication**: Emulates a Modbus slave device.
-* **State Machine Logic**: Simulates different operational states (Standby, Running, Fail).
-* **Dynamic Value Simulation**: Uses "Strategies" (e.g., PID, Ramp) to generate realistic, changing values for Modbus points.
-* **Configurable Modbus Map**: The entire Modbus register map is defined in a single, easy-to-modify file (`config.h`).
-* **Extensible Design**: The structure allows for the addition of new states and behaviors.
-
-## Hardware Prerequisites
-
-The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities and at least one hardware serial port for RS485 communication.
-
-* **Microcontroller**: ESP8266, ESP32, or similar.
-* **RS485 Transceiver**: A module like the MAX485 to interface with the Modbus RTU bus.
-
-## Software Dependencies
-
-This project relies on a Modbus library. Ensure you have the correct library installed in your Arduino IDE.
-
-* **Modbus Library**: The code uses a library that provides `ModbusRTU.h` and optionally `ModbusIP_ESP8266.h`.
-
----
-
-## How to Customize for a New Chiller
-
-To adapt this template for a new chiller, follow these steps.
-
-### 1. Configure Device-Specific Parameters (`config.h`)
-
-Open `CH_Daikin_AWV026B_RTU/config.h`. This is the main file for device-specific settings.
-
-#### Modbus RTU Settings
-Update the following constants for your device's serial communication setup.
-```c++
-const int BAUDRATE = 19200;   // The serial communication speed
-const int RX_PIN = 17;        // The GPIO pin for receiving data (RX)
-const int TX_PIN = 16;        // The GPIO pin for transmitting data (TX)
-const int RST_PIN = 4;        // The GPIO pin for RS485 direction control
-const int MODBUS_ID = 1;      // The unique slave ID for this device
\ No newline at end of file
diff --git a/src/EPMS/UPS/UPS_Vertiv_APM2_TCP/State_Battery.cpp b/src/EPMS/UPS/UPS_Vertiv_APM2_TCP/State_Battery.cpp
deleted file mode 100644
index b3c7894..0000000
--- a/src/EPMS/UPS/UPS_Vertiv_APM2_TCP/State_Battery.cpp
+++ /dev/null
@@ -1,229 +0,0 @@
-/**
- * @file State_Battery.cpp
- * @brief Implementation of the BatteryState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the BatteryState, which defines
- * the behavior of the equipment when it is actively Battery.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "Strategies/Strategy_Totalizer.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State_Battery.h"
-#include "States/State_Bypass.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new BatteryState object.
- *
- * This constructor initializes behavior strategies active during the Battery
- * state, such as a PID controller for the 'CW Valve Position' and totalizers
- * for the run-hours of each EC fan.
- */
-template<>
-BatteryState<ModbusIP>::BatteryState() {
-  addStrategy("System Output RMS A-B", new SingleValueStrategy(480.0f, 5.0f, 1000));
-  addStrategy("System Output RMS B-C", new SingleValueStrategy(480.0f, 5.0f, 1000));
-  addStrategy("System Output RMS C-A", new SingleValueStrategy(480.0f, 5.0f, 1000));
-  addStrategy("System Output RMS A-N", new SingleValueStrategy(270.0f, 5.0f, 1000));
-  addStrategy("System Output RMS B-N", new SingleValueStrategy(270.0f, 5.0f, 1000));
-  addStrategy("System Output RMS C-N", new SingleValueStrategy(270.0f, 5.0f, 1000));
-
-  addStrategy("System Output RMS Current Phase A", new RampStrategy(10.0f, 50.0f, 1000));
-  addStrategy("System Output RMS Current Phase B", new RampStrategy(10.0f, 50.0f, 1000));
-  addStrategy("System Output RMS Current Phase C", new RampStrategy(10.0f, 50.0f, 1000));
-  
-  addStrategy("System Output Frequency", new SingleValueStrategy(60.0F, 2.0f, 1000));
-
-  addStrategy("System Output Power Factor Phs A", new SingleValueStrategy(93.0f, 5.0f, 1000));
-  addStrategy("System Output Power Factor Phs B", new SingleValueStrategy(93.0f, 5.0f, 1000));
-  addStrategy("System Output Power Factor Phs C", new SingleValueStrategy(93.0f, 5.0f, 1000));
-
-  addStrategy("System Output Power Phase A", new RampStrategy(10.0f, 50.0f, 1000));
-  addStrategy("System Output Power Phase B", new RampStrategy(10.0f, 50.0f, 1000));
-  addStrategy("System Output Power Phase C", new RampStrategy(10.0f, 50.0f, 1000));
-  addStrategy("System Output Apparent Power Phs A", new RampStrategy(10.0f, 50.0f, 1000));
-  addStrategy("System Output Apparent Power Phs B", new RampStrategy(10.0f, 50.0f, 1000));
-  addStrategy("System Output Apparent Power Phs C", new RampStrategy(10.0f, 50.0f, 1000));
-
-  addStrategy("Battery Time Remaining", new RampStrategy(0.0f, 3.0f, 1000));
-  addStrategy("Percentage Load", new RampStrategy(0.0f, 5.0f, 1000));
-}
-
-/**
- * @brief Executes the Battery state's logic for one update cycle.
- *
- * This method first checks for state transition commands:
- * 1. It reads the "ON/OFF Command By BMS" point. If it's 0, it transitions to StandbyState.
- * 2. It reads the "Fault Code" point. If it's non-zero, it transitions to FailState,
- *    passing the corresponding alarm description.
- *
- * If no transition occurs, it applies the strategies defined for the Battery state.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* BatteryState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-  // STATE control, add conditions if change to a different state is needed
-  Serial.println("Battery update function");
-  float State_Ctrl = getPointValue(equipment, "Px State");
-  switch (static_cast<int>(State_Ctrl)) {
-    case 1:
-      return new StandbyState<ModbusIP>();
-      break;  
-    case 2:
-      return new RunningState<ModbusIP>();
-      break;
-    case 4:
-      return new BypassState<ModbusIP>();
-      break;
-      default:
-      break;
-    }
-    
-    float Battery_time = getPointValue(equipment, "Battery Time Remaining");
-    float Bat_Percent = Battery_time /4.80f;
-    float select = 1.0f;
-    if (Bat_Percent > 98.0f){
-      setPointValue(equipment, "UPS Battery Status2", 0.0f);
-      select = 1.0f;
-    }
-    if (Bat_Percent > 20.0f) {
-      setPointValue(equipment, "UPS Battery Status1", 2.0f);
-      setPointValue(equipment, "Battery Low", 0.0f);
-      select = 1.0f;
-    } 
-    if (Bat_Percent <= 20.0f && Bat_Percent >= 5.0f){
-      setPointValue(equipment, "UPS Battery Status1", 3.0f);
-      setPointValue(equipment, "Battery Low", 1.0f);
-      select = 0.8f;
-    }
-    if (Bat_Percent < 5.0f){
-      setPointValue(equipment, "UPS Battery Status1", 4.0f);
-      select = 0.05f;
-    }
-    float rating = getPointValue(equipment, "Px Rating");
-    float load = getPointValue(equipment, "Px Load");
-    float real_load = (rating) * (load/100.0f);
-    
-    Strategy_Behavior* ramp_strat = nullptr;
-    //Output strategies
-    float Out_Vab = getPointValue(equipment, "System Output RMS A-B");
-    ramp_strat = getStrategy("System Output RMS Current Phase A");
-    static_cast<RampStrategy*>(ramp_strat)->setTarget(real_load*select);
-    float Out_Vbc = getPointValue(equipment, "System Output RMS B-C");
-    ramp_strat = getStrategy("System Output RMS Current Phase B");
-    static_cast<RampStrategy*>(ramp_strat)->setTarget(real_load*select);
-    float Out_Vca = getPointValue(equipment, "System Output RMS C-A");
-    ramp_strat = getStrategy("System Output RMS Current Phase C");
-    static_cast<RampStrategy*>(ramp_strat)->setTarget(real_load*select);
-    
-    float Out_Van = getPointValue(equipment, "System Output RMS A-N");
-    float Out_Ia = getPointValue(equipment, "System Output RMS Current Phase A");
-    float Out_PFa = getPointValue(equipment, "System Output Power Factor Phs A");
-    ramp_strat = getStrategy("System Output Power Phase A");
-    static_cast<RampStrategy*>(ramp_strat)->setTarget(Out_Van * Out_Ia);
-    ramp_strat = getStrategy("System Output Apparent Power Phs A");
-    static_cast<RampStrategy*>(ramp_strat)->setTarget(Out_Van * Out_Ia * Out_PFa);
-    
-    float Out_Vbn = getPointValue(equipment, "System Output RMS B-N");
-    float Out_Ib = getPointValue(equipment, "System Output RMS Current Phase B");
-    float Out_PFb = getPointValue(equipment, "System Output Power Factor Phs B");
-    ramp_strat = getStrategy("System Output Power Phase B");
-    static_cast<RampStrategy*>(ramp_strat)->setTarget(Out_Vbn * Out_Ib);
-    ramp_strat = getStrategy("System Output Apparent Power Phs B");
-    static_cast<RampStrategy*>(ramp_strat)->setTarget(Out_Vbn * Out_Ib * Out_PFb);
-    
-    float Out_Vcn = getPointValue(equipment, "System Output RMS C-N");
-    float Out_Ic = getPointValue(equipment, "System Output RMS Current Phase C");
-    float Out_PFc = getPointValue(equipment, "System Output Power Factor Phs C");
-    ramp_strat = getStrategy("System Output Power Phase C");
-    static_cast<RampStrategy*>(ramp_strat)->setTarget(Out_Vcn * Out_Ic);
-    ramp_strat = getStrategy("System Output Apparent Power Phs C");
-    static_cast<RampStrategy*>(ramp_strat)->setTarget(Out_Vcn * Out_Ic * Out_PFc);
-
-    setPointValue(equipment, "System Output Power", (real_load * Out_Vab)/1000.0f);
-    setPointValue(equipment, "System Output Apparent Power", (real_load* Out_Vab * 0.9f)/1000.0f);
-    
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-  }
-  
-  /**
-   * @brief Logic to execute once when entering the Battery state.
-   * Sets the "Run Status" for all EC fans to 1 to indicate they are active.
-   * @param equipment Pointer to the Equipment instance.
-   */
-  template<>
-  void BatteryState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Battery State...");
-  setPointValue(equipment, "System Input RMS A-B", 0.0f);
-  setPointValue(equipment, "System Input RMS B-C", 0.0f);
-  setPointValue(equipment, "System Input RMS C-A", 0.0f);
-  setPointValue(equipment, "System Input RMS A-N", 0.0f);
-  setPointValue(equipment, "System Input RMS B-N", 0.0f);
-  setPointValue(equipment, "System Input RMS C-N", 0.0f);
-  setPointValue(equipment, "System Input RMS Current Phase A", 0.0f);
-  setPointValue(equipment, "System Input RMS Current Phase B", 0.0f);
-  setPointValue(equipment, "System Input RMS Current Phase C", 0.0f);
-  setPointValue(equipment, "System Input Frequency", 0.0f);
-  setPointValue(equipment, "System Input Power Factor Phs A", 0.0f);
-  setPointValue(equipment, "System Input Power Factor Phs B", 0.0f);
-  setPointValue(equipment, "System Input Power Factor Phs C", 0.0f);
-  setPointValue(equipment, "System Input Power Phase A", 0.0f);
-  setPointValue(equipment, "System Input Power Phase B", 0.0f);
-  setPointValue(equipment, "System Input Power Phase C", 0.0f);
-  setPointValue(equipment, "System Input Apparent Power Phs A", 0.0f);
-  setPointValue(equipment, "System Input Apparent Power Phs B", 0.0f);
-  setPointValue(equipment, "System Input Apparent Power Phs C", 0.0f);
-
-    
-  setPointValue(equipment, "Bypass Input Voltage RMS A-B", 0.0f);
-  setPointValue(equipment, "Bypass Input Voltage RMS B-C", 0.0f);
-  setPointValue(equipment, "Bypass Input Voltage RMS C-A", 0.0f);
-  setPointValue(equipment, "Bypass Input Voltage RMS A-N", 0.0f);
-  setPointValue(equipment, "Bypass Input Voltage RMS B-N", 0.0f);
-  setPointValue(equipment, "Bypass Input Voltage RMS C-N", 0.0f);
-  setPointValue(equipment, "Bypass Input Frequency", 0.0f);
-  setPointValue(equipment, "Bypass Power Phase A", 0.0f);
-  setPointValue(equipment, "Bypass Power Phase B", 0.0f);
-  setPointValue(equipment, "Bypass Power Phase C", 0.0f);
-  setPointValue(equipment, "UPS Loading Status", 6.0f);
-  setPointValue(equipment, "UPS Battery Status2", 2.0f);
-  
-  // You could also update a Modbus register to show the "standby" state
-
-}
-
-/**
- * @brief Logic to execute once when exiting the Battery state.
- * Sets the "Run Status" for all EC fans to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void BatteryState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Battery State...");
-   
-}
\ No newline at end of file
diff --git a/src/EPMS/UPS/UPS_Vertiv_APM2_TCP/State_Bypass.cpp b/src/EPMS/UPS/UPS_Vertiv_APM2_TCP/State_Bypass.cpp
deleted file mode 100644
index 0c92458..0000000
--- a/src/EPMS/UPS/UPS_Vertiv_APM2_TCP/State_Bypass.cpp
+++ /dev/null
@@ -1,273 +0,0 @@
-/**
- * @file State_Bypass.cpp
- * @brief Implementation of the BypassState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the BypassState, which defines
- * the behavior of the equipment when it is actively Bypass.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "Strategies/Strategy_Totalizer.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State_Bypass.h"
-#include "States/State_Battery.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new BypassState object.
- *
- * This constructor initializes behavior strategies active during the Bypass
- * state, such as a PID controller for the 'CW Valve Position' and totalizers
- * for the run-hours of each EC fan.
- */
-template<>
-BypassState<ModbusIP>::BypassState() {
-
-  //Input System
-  addStrategy("System Input RMS A-B", new SingleValueStrategy(480.0f, 5.0f, 1000));
-  addStrategy("System Input RMS B-C", new SingleValueStrategy(480.0f, 5.0f, 1000));
-  addStrategy("System Input RMS C-A", new SingleValueStrategy(480.0f, 5.0f, 1000));
-  addStrategy("System Input RMS A-N", new SingleValueStrategy(270.0f, 5.0f, 1000));
-  addStrategy("System Input RMS B-N", new SingleValueStrategy(270.0f, 5.0f, 1000));
-  addStrategy("System Input RMS C-N", new SingleValueStrategy(270.0f, 5.0f, 1000));
-
-  addStrategy("System Input RMS Current Phase A", new RampStrategy(0.0f, 25.0f, 1000));
-  addStrategy("System Input RMS Current Phase B", new RampStrategy(0.0f, 25.0f, 1000));
-  addStrategy("System Input RMS Current Phase C", new RampStrategy(0.0f, 25.0f, 1000));
-  
-  addStrategy("System Input Frequency", new SingleValueStrategy(60.0f, 2.0f, 1000));
-
-  addStrategy("System Input Power Factor Phs A", new SingleValueStrategy(93.0f, 5.0f, 1000));
-  addStrategy("System Input Power Factor Phs B", new SingleValueStrategy(93.0f, 5.0f, 1000));
-  addStrategy("System Input Power Factor Phs C", new SingleValueStrategy(93.0f, 5.0f, 1000));
-
-  addStrategy("System Input Power Phase A", new RampStrategy(0.0f, 50.0f, 1000));
-  addStrategy("System Input Power Phase B", new RampStrategy(0.0f, 50.0f, 1000));
-  addStrategy("System Input Power Phase C", new RampStrategy(0.0f, 50.0f, 1000));
-  addStrategy("System Input Apparent Power Phs A", new RampStrategy(0.0f, 50.0f, 1000));
-  addStrategy("System Input Apparent Power Phs B", new RampStrategy(0.0f, 50.0f, 1000));
-  addStrategy("System Input Apparent Power Phs C", new RampStrategy(0.0f, 50.0f, 1000));
-
-  //Bypass System
-
-  addStrategy("Bypass Input Voltage RMS A-B", new SingleValueStrategy(480.0f, 5.0f, 1000));
-  addStrategy("Bypass Input Voltage RMS B-C", new SingleValueStrategy(480.0f, 5.0f, 1000));
-  addStrategy("Bypass Input Voltage RMS C-A", new SingleValueStrategy(480.0f, 5.0f, 1000));
-  addStrategy("Bypass Input Voltage RMS A-N", new SingleValueStrategy(270.0f, 5.0f, 1000));
-  addStrategy("Bypass Input Voltage RMS B-N", new SingleValueStrategy(270.0f, 5.0f, 1000));
-  addStrategy("Bypass Input Voltage RMS C-N", new SingleValueStrategy(270.0f, 5.0f, 1000));
-
-  addStrategy("Bypass Input Frequency", new SingleValueStrategy(60.0f, 2.0f, 1000));
-
-  addStrategy("Bypass Input Power Phase A", new RampStrategy(0.0f, 25.0f, 1000));
-  addStrategy("Bypass Input Power Phase B", new RampStrategy(0.0f, 25.0f, 1000));
-  addStrategy("Bypass Input Power Phase C", new RampStrategy(0.0f, 25.0f, 1000));
-
-  //Output System
-  addStrategy("System Output RMS A-B", new SingleValueStrategy(480.0f, 5.0f, 1000));
-  addStrategy("System Output RMS B-C", new SingleValueStrategy(480.0f, 5.0f, 1000));
-  addStrategy("System Output RMS C-A", new SingleValueStrategy(480.0f, 5.0f, 1000));
-  addStrategy("System Output RMS A-N", new SingleValueStrategy(270.0f, 5.0f, 1000));
-  addStrategy("System Output RMS B-N", new SingleValueStrategy(270.0f, 5.0f, 1000));
-  addStrategy("System Output RMS C-N", new SingleValueStrategy(270.0f, 5.0f, 1000));
-
-  addStrategy("System Output RMS Current Phase A", new RampStrategy(0.0f, 25.0f, 1000));
-  addStrategy("System Output RMS Current Phase B", new RampStrategy(0.0f, 25.0f, 1000));
-  addStrategy("System Output RMS Current Phase C", new RampStrategy(0.0f, 25.0f, 1000));
-  
-  addStrategy("System Output Frequency", new SingleValueStrategy(60.0f, 2.0f, 1000));
-
-  addStrategy("System Output Power Factor Phs A", new SingleValueStrategy(93.0f, 5.0f, 1000));
-  addStrategy("System Output Power Factor Phs B", new SingleValueStrategy(93.0f, 5.0f, 1000));
-  addStrategy("System Output Power Factor Phs C", new SingleValueStrategy(93.0f, 5.0f, 1000));
-
-  addStrategy("System Output Power Phase A", new RampStrategy(0.0f, 50.0f, 1000));
-  addStrategy("System Output Power Phase B", new RampStrategy(0.0f, 50.0f, 1000));
-  addStrategy("System Output Power Phase C", new RampStrategy(0.0f, 50.0f, 1000));
-  addStrategy("System Output Apparent Power Phs A", new RampStrategy(0.0f, 50.0f, 1000));
-  addStrategy("System Output Apparent Power Phs B", new RampStrategy(0.0f, 50.0f, 1000));
-  addStrategy("System Output Apparent Power Phs C", new RampStrategy(0.0f, 50.0f, 1000));
-
-  addStrategy("Battery Time Remaining", new RampStrategy(480.0f, 0.3f, 1000));
-  addStrategy("DC Bus Voltage", new SingleValueStrategy(518.0f, 5.0f, 1000));
-}
-
-/**
- * @brief Executes the Bypass state's logic for one update cycle.
- *
- * This method first checks for state transition commands:
- * 1. It reads the "ON/OFF Command By BMS" point. If it's 0, it transitions to StandbyState.
- * 2. It reads the "Fault Code" point. If it's non-zero, it transitions to FailState,
- *    passing the corresponding alarm description.
- *
- * If no transition occurs, it applies the strategies defined for the Bypass state.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* BypassState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-  // STATE control, add conditions if change to a different state is needed
-  Serial.println("Bypass update function");
-  float State_Ctrl = getPointValue(equipment, "Px State");
-  switch (static_cast<int>(State_Ctrl)) {
-    case 1:
-      return new StandbyState<ModbusIP>();
-      break;
-    case 2:
-      return new RunningState<ModbusIP>();
-      break;  
-    case 3:
-      return new BatteryState<ModbusIP>();
-      break;
-    default:
-      break;
-  }
-  float rating = getPointValue(equipment, "Px Rating");
-  float load = getPointValue(equipment, "Px Load");
-  float real_load = (rating) * (load/100.0f);
-
-  Strategy_Behavior* ramp_strat = nullptr;
-
-  //Input strategies
-  float In_Vab = getPointValue(equipment, "System Input RMS A-B");
-  ramp_strat = getStrategy("System Input RMS Current Phase A");
-  static_cast<RampStrategy*>(ramp_strat)->setTarget(real_load);
-  float In_Vbc = getPointValue(equipment, "System Input RMS B-C");
-  ramp_strat = getStrategy("System Input RMS Current Phase B");
-  static_cast<RampStrategy*>(ramp_strat)->setTarget(real_load);
-  float In_Vca = getPointValue(equipment, "System Input RMS C-A");
-  ramp_strat = getStrategy("System Input RMS Current Phase C");
-  static_cast<RampStrategy*>(ramp_strat)->setTarget(real_load);
-
-  float In_Van = getPointValue(equipment, "System Input RMS A-N");
-  float In_Ia = getPointValue(equipment, "System Input RMS Current Phase A");
-  float In_PFa = getPointValue(equipment, "System Input Power Factor Phs A");
-  ramp_strat = getStrategy("System Input Power Phase A");
-  static_cast<RampStrategy*>(ramp_strat)->setTarget(In_Van * In_Ia);
-  ramp_strat = getStrategy("Bypass Input Power Phase A");
-  static_cast<RampStrategy*>(ramp_strat)->setTarget(In_Van * In_Ia);
-  ramp_strat = getStrategy("System Input Apparent Power Phs A");
-  static_cast<RampStrategy*>(ramp_strat)->setTarget(In_Van * In_Ia * 0.9f);
-  
-  float In_Vbn = getPointValue(equipment, "System Input RMS B-N");
-  float In_Ib = getPointValue(equipment, "System Input RMS Current Phase B");
-  float In_PFb = getPointValue(equipment, "System Input Power Factor Phs B");
-  ramp_strat = getStrategy("System Input Power Phase B");
-  static_cast<RampStrategy*>(ramp_strat)->setTarget(In_Vbn * In_Ib);
-  ramp_strat = getStrategy("Bypass Input Power Phase B");
-  static_cast<RampStrategy*>(ramp_strat)->setTarget(In_Vbn * In_Ib);
-  ramp_strat = getStrategy("System Input Apparent Power Phs B");
-  static_cast<RampStrategy*>(ramp_strat)->setTarget(In_Vbn * In_Ib * 0.9f);
-  
-  float In_Vcn = getPointValue(equipment, "System Input RMS C-N");
-  float In_Ic = getPointValue(equipment, "System Input RMS Current Phase C");
-  float In_PFc = getPointValue(equipment, "System Input Power Factor Phs C");
-  ramp_strat = getStrategy("System Input Power Phase C");
-  static_cast<RampStrategy*>(ramp_strat)->setTarget(In_Vcn * In_Ic);
-  ramp_strat = getStrategy("Bypass Input Power Phase C");
-  static_cast<RampStrategy*>(ramp_strat)->setTarget(In_Vcn * In_Ic);
-  ramp_strat = getStrategy("System Input Apparent Power Phs C");
-  static_cast<RampStrategy*>(ramp_strat)->setTarget(In_Vcn * In_Ic * 0.9f);
-
-  //Output strategies
-  float Out_Vab = getPointValue(equipment, "System Output RMS A-B");
-  ramp_strat = getStrategy("System Output RMS Current Phase A");
-  static_cast<RampStrategy*>(ramp_strat)->setTarget(real_load);
-  float Out_Vbc = getPointValue(equipment, "System Output RMS B-C");
-  ramp_strat = getStrategy("System Output RMS Current Phase B");
-  static_cast<RampStrategy*>(ramp_strat)->setTarget(real_load);
-  float Out_Vca = getPointValue(equipment, "System Output RMS C-A");
-  ramp_strat = getStrategy("System Output RMS Current Phase C");
-  static_cast<RampStrategy*>(ramp_strat)->setTarget(real_load);
-
-  float Out_Van = getPointValue(equipment, "System Output RMS A-N");
-  float Out_Ia = getPointValue(equipment, "System Output RMS Current Phase A");
-  float Out_PFa = getPointValue(equipment, "System Output Power Factor Phs A");
-  ramp_strat = getStrategy("System Output Power Phase A");
-  static_cast<RampStrategy*>(ramp_strat)->setTarget(Out_Van * Out_Ia);
-  ramp_strat = getStrategy("System Output Apparent Power Phs A");
-  static_cast<RampStrategy*>(ramp_strat)->setTarget(Out_Van * Out_Ia * 0.9f);
-
-  float Out_Vbn = getPointValue(equipment, "System Output RMS B-N");
-  float Out_Ib = getPointValue(equipment, "System Output RMS Current Phase B");
-  float Out_PFb = getPointValue(equipment, "System Output Power Factor Phs B");
-  ramp_strat = getStrategy("System Output Power Phase B");
-  static_cast<RampStrategy*>(ramp_strat)->setTarget(Out_Vbn * Out_Ib);
-  ramp_strat = getStrategy("System Output Apparent Power Phs B");
-  static_cast<RampStrategy*>(ramp_strat)->setTarget(Out_Vbn * Out_Ib * 0.9f);
-
-  float Out_Vcn = getPointValue(equipment, "System Output RMS C-N");
-  float Out_Ic = getPointValue(equipment, "System Output RMS Current Phase C");
-  float Out_PFc = getPointValue(equipment, "System Output Power Factor Phs C");
-  ramp_strat = getStrategy("System Output Power Phase C");
-  static_cast<RampStrategy*>(ramp_strat)->setTarget(Out_Vcn * Out_Ic);
-  ramp_strat = getStrategy("System Output Apparent Power Phs C");
-  static_cast<RampStrategy*>(ramp_strat)->setTarget(Out_Vcn * Out_Ic * 0.9f);
-
-  float Battery_time = getPointValue(equipment, "Battery Time Remaining");
-  float Bat_Percent = Battery_time /4.80f;
-  if (Bat_Percent > 98.0f){
-    setPointValue(equipment, "UPS Battery Status2", 0.0f);
-  }
-  if (Bat_Percent > 20.0f) {
-    setPointValue(equipment, "UPS Battery Status1", 2.0f);
-    setPointValue(equipment, "Battery Low", 0.0f);
-  } 
-  if (Bat_Percent <= 20.0f && Bat_Percent >= 5.0f){
-    setPointValue(equipment, "UPS Battery Status1", 3.0f);
-    setPointValue(equipment, "Battery Low", 1.0f);
-  }
-  if (Bat_Percent < 5.0f){
-    setPointValue(equipment, "UPS Battery Status1", 4.0f);
-  }
-  setPointValue(equipment, "System Output Power", (real_load * In_Vab)/1000.0f);
-  setPointValue(equipment, "System Output Apparent Power", (real_load* In_Vab * 0.9f)/1000.0f);
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-/**
- * @brief Logic to execute once when entering the Bypass state.
- * Sets the "Run Status" for all EC fans to 1 to indicate they are active.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void BypassState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Bypass State...");
-    setPointValue(equipment, "UPS Loading Status", 4.0f);
-    setPointValue(equipment, "UPS Battery Status2", 3.0f);
-    setPointValue(equipment, "Percentage Load", 0.0f);
-    // You could also update a Modbus register to show the "standby" state
-
-}
-
-/**
- * @brief Logic to execute once when exiting the Bypass state.
- * Sets the "Run Status" for all EC fans to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void BypassState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Bypass State...");
-}
\ No newline at end of file
diff --git a/src/EPMS/UPS/UPS_Vertiv_APM2_TCP/State_Fail.cpp b/src/EPMS/UPS/UPS_Vertiv_APM2_TCP/State_Fail.cpp
deleted file mode 100644
index 66cafd6..0000000
--- a/src/EPMS/UPS/UPS_Vertiv_APM2_TCP/State_Fail.cpp
+++ /dev/null
@@ -1,88 +0,0 @@
-/**
- * @file State_Fail.cpp
- * @brief Implementation of the FailState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the FailState, which defines
- * the behavior of the equipment when it has entered a fault condition.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Battery.h"
-#include "States/State_Fail.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new FailState object with a list of active alarms.
- *
- * This constructor receives a list of alarm descriptions and creates strategies
- * to set the corresponding Modbus points to a value of 1, indicating an
- * active alarm. It also initializes a PID strategy for the 'CW Valve Position'
- * to maintain its state during the fault.
- * @param activeAlarms A vector of strings, where each string is the
- *                     description of a Modbus point to be set as an active alarm.
- */
-template<>
-FailState<ModbusIP>::FailState(const std::vector<std::string>& activeAlarms) {
-    // Simulate a failure: set common alarm and a specific fan alarm.
-
-    
-}
-
-/**
- * @brief Executes the fail state's logic for one update cycle.
- *
- * This method checks the "Alarm Reset" Modbus point for a command to
- * transition back to Standby, which would typically happen after a fault
- * is cleared by a user. If no transition is requested, it continues to apply
- * the failure strategies (e.g., keeping alarm bits active).
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* FailState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Fail update function");
-    float State_Ctrl = getPointValue(equipment, "Px State");
-    if (State_Ctrl == 2){
-      return new RunningState<ModbusIP>();
-    }
-    if (State_Ctrl == 1){
-      return new StandbyState<ModbusIP>();
-    }
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the fail state.
- * Sets the "Alarm Common" point to 1 to indicate a general fault condition.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Fail State...");
-}
-
-/**
- * @brief Logic to execute once when exiting the fail state.
- * Clears the "Alarm Common" point to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Fail State...");
-}
\ No newline at end of file
diff --git a/src/EPMS/UPS/UPS_Vertiv_APM2_TCP/State_Running.cpp b/src/EPMS/UPS/UPS_Vertiv_APM2_TCP/State_Running.cpp
deleted file mode 100644
index 0bdbcb6..0000000
--- a/src/EPMS/UPS/UPS_Vertiv_APM2_TCP/State_Running.cpp
+++ /dev/null
@@ -1,267 +0,0 @@
-/**
- * @file State_Running.cpp
- * @brief Implementation of the RunningState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the RunningState, which defines
- * the behavior of the equipment when it is actively running.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "Strategies/Strategy_Totalizer.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State_Battery.h"
-#include "States/State_Bypass.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new RunningState object.
- *
- * This constructor initializes behavior strategies active during the running
- * state, such as a PID controller for the 'CW Valve Position' and totalizers
- * for the run-hours of each EC fan.
- */
-template<>
-RunningState<ModbusIP>::RunningState() {
-  addStrategy("System Input RMS A-B", new SingleValueStrategy(480.0f, 5.0f, 1000));
-  addStrategy("System Input RMS B-C", new SingleValueStrategy(480.0f, 5.0f, 1000));
-  addStrategy("System Input RMS C-A", new SingleValueStrategy(480.0f, 5.0f, 1000));
-  addStrategy("System Input RMS A-N", new SingleValueStrategy(270.0f, 5.0f, 1000));
-  addStrategy("System Input RMS B-N", new SingleValueStrategy(270.0f, 5.0f, 1000));
-  addStrategy("System Input RMS C-N", new SingleValueStrategy(270.0f, 5.0f, 1000));
-
-  addStrategy("System Input RMS Current Phase A", new RampStrategy(0.0f, 25.0f, 1000));
-  addStrategy("System Input RMS Current Phase B", new RampStrategy(0.0f, 25.0f, 1000));
-  addStrategy("System Input RMS Current Phase C", new RampStrategy(0.0f, 25.0f, 1000));
-  
-  addStrategy("System Input Frequency", new SingleValueStrategy(60.0f, 2.0f, 1000));
-
-  addStrategy("System Input Power Factor Phs A", new SingleValueStrategy(93.0f, 0.5f, 1000));
-  addStrategy("System Input Power Factor Phs B", new SingleValueStrategy(93.0f, 0.5f, 1000));
-  addStrategy("System Input Power Factor Phs C", new SingleValueStrategy(93.0f, 0.5f, 1000));
-
-  addStrategy("System Input Power Phase A", new RampStrategy(0.0f, 50.0f, 1000));
-  addStrategy("System Input Power Phase B", new RampStrategy(0.0f, 50.0f, 1000));
-  addStrategy("System Input Power Phase C", new RampStrategy(0.0f, 50.0f, 1000));
-  addStrategy("System Input Apparent Power Phs A", new RampStrategy(0.0f, 50.0f, 1000));
-  addStrategy("System Input Apparent Power Phs B", new RampStrategy(0.0f, 50.0f, 1000));
-  addStrategy("System Input Apparent Power Phs C", new RampStrategy(0.0f, 50.0f, 1000));
-
-  addStrategy("System Output RMS A-B", new SingleValueStrategy(480.0f, 5.0f, 1000));
-  addStrategy("System Output RMS B-C", new SingleValueStrategy(480.0f, 5.0f, 1000));
-  addStrategy("System Output RMS C-A", new SingleValueStrategy(480.0f, 5.0f, 1000));
-  addStrategy("System Output RMS A-N", new SingleValueStrategy(270.0f, 5.0f, 1000));
-  addStrategy("System Output RMS B-N", new SingleValueStrategy(270.0f, 5.0f, 1000));
-  addStrategy("System Output RMS C-N", new SingleValueStrategy(270.0f, 5.0f, 1000));
-  
-  addStrategy("System Output RMS Current Phase A", new RampStrategy(0.0f, 25.0f, 1000));
-  addStrategy("System Output RMS Current Phase B", new RampStrategy(0.0f, 25.0f, 1000));
-  addStrategy("System Output RMS Current Phase C", new RampStrategy(0.0f, 25.0f, 1000));
-  
-  addStrategy("System Output Frequency", new SingleValueStrategy(60.0f, 2.0f, 1000));
-  
-  addStrategy("System Output Power Factor Phs A", new SingleValueStrategy(93.0f, 5.0f, 1000));
-  addStrategy("System Output Power Factor Phs B", new SingleValueStrategy(93.0f, 5.0f, 1000));
-  addStrategy("System Output Power Factor Phs C", new SingleValueStrategy(93.0f, 5.0f, 1000));
-  
-  addStrategy("System Output Power Phase A", new RampStrategy(10.0f, 50.0f, 1000));
-  addStrategy("System Output Power Phase B", new RampStrategy(10.0f, 50.0f, 1000));
-  addStrategy("System Output Power Phase C", new RampStrategy(10.0f, 50.0f, 1000));
-  addStrategy("System Output Apparent Power Phs A", new RampStrategy(10.0f, 50.0f, 1000));
-  addStrategy("System Output Apparent Power Phs B", new RampStrategy(10.0f, 50.0f, 1000));
-  addStrategy("System Output Apparent Power Phs C", new RampStrategy(10.0f, 50.0f, 1000));
-  
-  addStrategy("DC Bus Voltage", new SingleValueStrategy(518.0f, 5.0f, 1000));
-  addStrategy("Battery Time Remaining", new RampStrategy(480.0f, 1.0f, 1000));
-  addStrategy("Percentage Load", new RampStrategy(100.0f, 5.0f, 1000));
-
-  addStrategy("System Output Power", new SingleValueStrategy(0.0f, 5.0f, 1000));
-  addStrategy("System Output Apparent Power", new SingleValueStrategy(0.0f, 5.0f, 1000));
-}
-
-/**
- * @brief Executes the running state's logic for one update cycle.
- *
- * This method first checks for state transition commands:
- * 1. It reads the "ON/OFF Command By BMS" point. If it's 0, it transitions to StandbyState.
- * 2. It reads the "Fault Code" point. If it's non-zero, it transitions to FailState,
- *    passing the corresponding alarm description.
- *
- * If no transition occurs, it applies the strategies defined for the running state.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* RunningState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-  // STATE control, add conditions if change to a different state is needed
-  Serial.println("Running update function");
-  float State_Ctrl = getPointValue(equipment, "Px State");
-  switch (static_cast<int>(State_Ctrl)) {
-    case 1:
-      return new StandbyState<ModbusIP>();
-      break;  
-    case 3:
-      return new BatteryState<ModbusIP>();
-      break;
-    case 4:
-      return new BypassState<ModbusIP>();
-      break;
-    default:
-      break;
-  }
-
-  float rating = getPointValue(equipment, "Px Rating");
-  float load = getPointValue(equipment, "Px Load");
-  float real_load = (rating) * (load/100.0f);
-
-  Strategy_Behavior* ramp_strat = nullptr;
-  //Input strategies
-  float In_Vab = getPointValue(equipment, "System Input RMS A-B");
-  ramp_strat = getStrategy("System Input RMS Current Phase A");
-  static_cast<RampStrategy*>(ramp_strat)->setTarget(real_load);
-  float In_Vbc = getPointValue(equipment, "System Input RMS B-C");
-  ramp_strat = getStrategy("System Input RMS Current Phase B");
-  static_cast<RampStrategy*>(ramp_strat)->setTarget(real_load);
-  float In_Vca = getPointValue(equipment, "System Input RMS C-A");
-  ramp_strat = getStrategy("System Input RMS Current Phase C");
-  static_cast<RampStrategy*>(ramp_strat)->setTarget(real_load);
-
-  setPointValue(equipment, "System Output Power", (real_load * In_Vab)/1000.0f);
-  setPointValue(equipment, "System Output Apparent Power", (real_load* In_Vab * 0.9f)/1000.0f);
-
-  float In_Van = getPointValue(equipment, "System Input RMS A-N");
-  float In_Ia = getPointValue(equipment, "System Input RMS Current Phase A");
-  float In_PFa = getPointValue(equipment, "System Input Power Factor Phs A");
-  ramp_strat = getStrategy("System Input Power Phase A");
-  static_cast<RampStrategy*>(ramp_strat)->setTarget(In_Van * In_Ia);
-  ramp_strat = getStrategy("System Input Apparent Power Phs A");
-  static_cast<RampStrategy*>(ramp_strat)->setTarget(In_Van * In_Ia * 0.9f);
-
-  float In_Vbn = getPointValue(equipment, "System Input RMS B-N");
-  float In_Ib = getPointValue(equipment, "System Input RMS Current Phase B");
-  float In_PFb = getPointValue(equipment, "System Input Power Factor Phs B");
-  ramp_strat = getStrategy("System Input Power Phase B");
-  static_cast<RampStrategy*>(ramp_strat)->setTarget(In_Vbn * In_Ib);
-  ramp_strat = getStrategy("System Input Apparent Power Phs B");
-  static_cast<RampStrategy*>(ramp_strat)->setTarget(In_Vbn * In_Ib * 0.9f);
-
-  float In_Vcn = getPointValue(equipment, "System Input RMS C-N");
-  float In_Ic = getPointValue(equipment, "System Input RMS Current Phase C");
-  float In_PFc = getPointValue(equipment, "System Input Power Factor Phs C");
-  ramp_strat = getStrategy("System Input Power Phase C");
-  static_cast<RampStrategy*>(ramp_strat)->setTarget(In_Vcn * In_Ic);
-  ramp_strat = getStrategy("System Input Apparent Power Phs C");
-  static_cast<RampStrategy*>(ramp_strat)->setTarget(In_Vcn * In_Ic * 0.9f);
-
-  //Output strategies
-  float Out_Vab = getPointValue(equipment, "System Output RMS A-B");
-  ramp_strat = getStrategy("System Output RMS Current Phase A");
-  static_cast<RampStrategy*>(ramp_strat)->setTarget(real_load);
-  float Out_Vbc = getPointValue(equipment, "System Output RMS B-C");
-  ramp_strat = getStrategy("System Output RMS Current Phase B");
-  static_cast<RampStrategy*>(ramp_strat)->setTarget(real_load);
-  float Out_Vca = getPointValue(equipment, "System Output RMS C-A");
-  ramp_strat = getStrategy("System Output RMS Current Phase C");
-  static_cast<RampStrategy*>(ramp_strat)->setTarget(real_load);
-
-  float Out_Van = getPointValue(equipment, "System Output RMS A-N");
-  float Out_Ia = getPointValue(equipment, "System Output RMS Current Phase A");
-  float Out_PFa = getPointValue(equipment, "System Output Power Factor Phs A");
-  ramp_strat = getStrategy("System Output Power Phase A");
-  static_cast<RampStrategy*>(ramp_strat)->setTarget(Out_Van * Out_Ia);
-  ramp_strat = getStrategy("System Output Apparent Power Phs A");
-  static_cast<RampStrategy*>(ramp_strat)->setTarget(Out_Van * Out_Ia * 0.9f);
-
-  float Out_Vbn = getPointValue(equipment, "System Output RMS B-N");
-  float Out_Ib = getPointValue(equipment, "System Output RMS Current Phase B");
-  float Out_PFb = getPointValue(equipment, "System Output Power Factor Phs B");
-  ramp_strat = getStrategy("System Output Power Phase B");
-  static_cast<RampStrategy*>(ramp_strat)->setTarget(Out_Vbn * Out_Ib);
-  ramp_strat = getStrategy("System Output Apparent Power Phs B");
-  static_cast<RampStrategy*>(ramp_strat)->setTarget(Out_Vbn * Out_Ib * 0.9f);
-
-  float Out_Vcn = getPointValue(equipment, "System Output RMS C-N");
-  float Out_Ic = getPointValue(equipment, "System Output RMS Current Phase C");
-  float Out_PFc = getPointValue(equipment, "System Output Power Factor Phs C");
-  ramp_strat = getStrategy("System Output Power Phase C");
-  static_cast<RampStrategy*>(ramp_strat)->setTarget(Out_Vcn * Out_Ic);
-  ramp_strat = getStrategy("System Output Apparent Power Phs C");
-  static_cast<RampStrategy*>(ramp_strat)->setTarget(Out_Vcn * Out_Ic * 0.9f);
-
-  float Battery_time = getPointValue(equipment, "Battery Time Remaining");
-  float Bat_Percent = Battery_time /4.80f;
-  if (Bat_Percent > 98.0f){
-    setPointValue(equipment, "UPS Battery Status2", 0.0f);
-  }
-  if (Bat_Percent > 20.0f) {
-    setPointValue(equipment, "UPS Battery Status1", 2.0f);
-    setPointValue(equipment, "Battery Low", 0.0f);
-  } 
-  if (Bat_Percent <= 20.0f && Bat_Percent >= 5.0f){
-    setPointValue(equipment, "UPS Battery Status1", 3.0f);
-    setPointValue(equipment, "Battery Low", 1.0f);
-  }
-  if (Bat_Percent < 5.0f){
-    setPointValue(equipment, "UPS Battery Status1", 4.0f);
-  }
-  // Apply any strategies defined for the standby state
-  _applyStrategies(equipment);
-  return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the running state.
- * Sets the "Run Status" for all EC fans to 1 to indicate they are active.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Running State...");
-    // You could also update a Modbus register to show the "standby" state
-
-    setPointValue(equipment, "Bypass Input Voltage RMS A-B", 0.0f);
-    setPointValue(equipment, "Bypass Input Voltage RMS B-C", 0.0f);
-    setPointValue(equipment, "Bypass Input Voltage RMS C-A", 0.0f);
-    setPointValue(equipment, "Bypass Input Voltage RMS A-N", 0.0f);
-    setPointValue(equipment, "Bypass Input Voltage RMS B-N", 0.0f);
-    setPointValue(equipment, "Bypass Input Voltage RMS C-N", 0.0f);
-    setPointValue(equipment, "Bypass Input Frequency", 0.0f);
-    setPointValue(equipment, "Bypass Power Phase A", 0.0f);
-    setPointValue(equipment, "Bypass Power Phase B", 0.0f);
-    setPointValue(equipment, "Bypass Power Phase C", 0.0f);
-
-    setPointValue(equipment, "UPS Loading Status", 3.0f);
-    setPointValue(equipment, "UPS Battery Status2", 1.0f);
-
-}
-
-/**
- * @brief Logic to execute once when exiting the running state.
- * Sets the "Run Status" for all EC fans to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Running State...");
-   
-}
\ No newline at end of file
diff --git a/src/EPMS/UPS/UPS_Vertiv_APM2_TCP/State_Standby.cpp b/src/EPMS/UPS/UPS_Vertiv_APM2_TCP/State_Standby.cpp
deleted file mode 100644
index 602846b..0000000
--- a/src/EPMS/UPS/UPS_Vertiv_APM2_TCP/State_Standby.cpp
+++ /dev/null
@@ -1,153 +0,0 @@
-/**
- * @file State_Standby.cpp
- * @brief Implementation of the StandbyState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the StandbyState, which defines
- * the behavior of the equipment when it is in an idle or standby mode.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State_Battery.h"
-#include "States/State_Bypass.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-/**
- * @brief Constructs a new StandbyState object.
- *
- * In this state, the equipment is idle. This constructor initializes strategies
- * to bring the system to a safe, idle condition. It sets a stable value for
- * the SAT reading and creates ramp strategies to bring the CW valve and all
- * EC fan speeds down to zero.
- */
-template<>
-StandbyState<ModbusIP>::StandbyState() {
-    // You can add initialization code here if needed
-    
-
-}
-
-/**
- * @brief Executes the standby state's logic for one update cycle.
- *
- * This method applies the strategies defined for the standby state (e.g.,
- * ramping values to zero).
- *
- * @warning This method currently does not check for a command to transition to the
- *          Running state. This logic needs to be added to allow the unit to start.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* StandbyState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Standby update function");
-    
-    float State_Ctrl = getPointValue(equipment, "Px State");
-    switch (static_cast<int>(State_Ctrl)) {
-      case 2:
-        return new RunningState<ModbusIP>();
-        break;  
-      case 3:
-        return new BatteryState<ModbusIP>();
-        break;
-      case 4:
-        return new BypassState<ModbusIP>();
-        break;
-      default:
-        break;
-    }
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the standby state.
- * This method performs cleanup by setting all alarm points and all EC fan
- * run status points to 0.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-  // Logic to run when the equipment enters this state
-  Serial.println("Enter Standby State...");
-  setPointValue(equipment, "UPS Loading Status", 2.0f);
-
-  setPointValue(equipment, "System Input RMS A-B", 0.0f);                
-  setPointValue(equipment, "System Input RMS B-C", 0.0f);               
-  setPointValue(equipment, "System Input RMS C-A", 0.0f);           
-  setPointValue(equipment, "System Input RMS A-N", 0.0f);               
-  setPointValue(equipment, "System Input RMS B-N", 0.0f);               
-  setPointValue(equipment, "System Input RMS C-N", 0.0f);           
-  setPointValue(equipment, "System Input RMS Current Phase A", 0.0f);                  
-  setPointValue(equipment, "System Input RMS Current Phase B", 0.0f);                
-  setPointValue(equipment, "System Input RMS Current Phase C", 0.0f);                 
-  setPointValue(equipment, "System Input Frequency", 0.0f);                  
-  setPointValue(equipment, "System Input Power Factor Phs A", 0.0f);                
-  setPointValue(equipment, "System Input Power Factor Phs B", 0.0f);                
-  setPointValue(equipment, "System Input Power Factor Phs C", 0.0f);                
-  setPointValue(equipment, "System Input Power Phase A", 0.0f);                    
-  setPointValue(equipment, "System Input Power Phase B", 0.0f);                
-  setPointValue(equipment, "System Input Power Phase C", 0.0f);                
-  setPointValue(equipment, "System Input Apparent Power Phs A", 0.0f);            
-  setPointValue(equipment, "System Input Apparent Power Phs B", 0.0f);         
-  setPointValue(equipment, "System Input Apparent Power Phs C", 0.0f);                   
-  setPointValue(equipment, "Bypass Input Voltage RMS A-B", 0.0f);        
-  setPointValue(equipment, "Bypass Input Voltage RMS B-C", 0.0f);                  
-  setPointValue(equipment, "Bypass Input Voltage RMS C-A", 0.0f);                
-  setPointValue(equipment, "Bypass Input Voltage RMS A-N", 0.0f);  
-  setPointValue(equipment, "Bypass Input Voltage RMS B-N", 0.0f);            
-  setPointValue(equipment, "Bypass Input Voltage RMS C-N", 0.0f);                 
-  setPointValue(equipment, "Bypass Input Frequency", 0.0f);              
-  setPointValue(equipment, "Bypass Power Phase A", 0.0f);          
-  setPointValue(equipment, "Bypass Power Phase B", 0.0f);         
-  setPointValue(equipment, "Bypass Power Phase C", 0.0f);        
-  setPointValue(equipment, "System Output RMS A-B", 0.0f);                
-  setPointValue(equipment, "System Output RMS B-C", 0.0f);                
-  setPointValue(equipment, "System Output RMS C-A", 0.0f);                
-  setPointValue(equipment, "System Output RMS A-N", 0.0f);                
-  setPointValue(equipment, "System Output RMS B-N", 0.0f);                
-  setPointValue(equipment, "System Output RMS C-N", 0.0f);                
-  setPointValue(equipment, "System Output RMS Current Phase A", 0.0f);           
-  setPointValue(equipment, "System Output RMS Current Phase B", 0.0f);           
-  setPointValue(equipment, "System Output RMS Current Phase C", 0.0f);           
-  setPointValue(equipment, "System Output Frequency", 0.0f);           
-  setPointValue(equipment, "System Output Power Factor Phs A", 0.0f);                 
-  setPointValue(equipment, "System Output Power Factor Phs B", 0.0f);                
-  setPointValue(equipment, "System Output Power Factor Phs C", 0.0f);                
-  setPointValue(equipment, "System Output Power Phase A", 0.0f);                    
-  setPointValue(equipment, "System Output Power Phase B", 0.0f);              
-  setPointValue(equipment, "System Output Power Phase C", 0.0f);              
-  setPointValue(equipment, "System Output Apparent Power Phs A", 0.0f);          
-  setPointValue(equipment, "System Output Apparent Power Phs B", 0.0f);          
-  setPointValue(equipment, "System Output Apparent Power Phs C", 0.0f);                     
-  setPointValue(equipment, "System Output Power", 0.0f);                     
-  setPointValue(equipment, "System Output Apparent Power", 0.0f);   
-}
-
-/**
- * @brief Logic to execute once when exiting the standby state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Standby State...");
-}
\ No newline at end of file
diff --git a/src/EPMS/UPS/UPS_Vertiv_APM2_TCP/config.h b/src/EPMS/UPS/UPS_Vertiv_APM2_TCP/config.h
deleted file mode 100644
index dc93df8..0000000
--- a/src/EPMS/UPS/UPS_Vertiv_APM2_TCP/config.h
+++ /dev/null
@@ -1,146 +0,0 @@
-/**
- * @file config.h
- * @brief Main configuration file for the CRAH Unit (TCP) emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * This file contains two important configurations: WiFi network parameters
- * and the Modbus register map for the device.
- */
-
-#ifndef CONFIG_H
-#define CONFIG_H
-
-#include "core.h"
-#include "Equipment/Equipment.h"
-
-#if defined(USE_MODBUS_IP)
-/**
-   * @defgroup ModbusTCPConfig Modbus IP Configuration
-   * @brief Parameters for Modbus TCP communication.
-   * @{
-   */
-  #include <ModbusIP_ESP8266.h>
-  const char *ssid = "QTS_CDR_Arduino";       /**< @brief The SSID of the WiFi network. */
-  const char *password = "123abc456";   /**< @brief The password for the WiFi network. */
-  IPAddress local_IP(172, 17, 33, 187);       /**< @brief The static IP address for the device. */
-  IPAddress gateway(172, 17, 33, 1);          /**< @brief The gateway IP address. */
-  IPAddress subnet(255, 255, 255, 0);         /**< @brief The subnet mask. */
-  
-  ModbusIP mb;
-#else
-  /**
-   * @defgroup ModbusRTUConfig Modbus RTU Configuration
-   * @brief Parameters for serial Modbus RTU communication.
-   * @{
-   */
-  #include <ModbusRTU.h>
-  const int BAUDRATE = 19200;   /**< @brief The serial communication speed in bits per second. */
-  const int RX_PIN = 17;        /**< @brief The GPIO pin used for receiving data (RX). */
-  const int TX_PIN = 16;        /**< @brief The GPIO pin used for transmitting data (TX). */
-  const int RST_PIN = 4;        /**< @brief The GPIO pin connected to the RS485 driver's DE/RE pins for direction control. */
-  const int MODBUS_ID = 1;      /**< @brief The unique slave ID for this device on the Modbus bus. */
-  /** @} */
-
-  /** @brief Global instance of the Modbus RTU server. */
-  ModbusRTU mb;
-#endif
-
-
-
-/**
- * @defgroup ModbusMapConfig Modbus Map Configuration
- * @brief Defines the Modbus register map and related parameters for the emulator.
- * @{
- */
-/**
- * @brief The Modbus map for the Equipment device.
- * This array defines all the Modbus points available on the emulated device.
- * The `description` field is crucial as it's used to look up points within the application logic.
- */
-modbusMap mb_map[] =
-{   
-  {HR,       9, 0,  "Px State"},    //1-standby, 2 Running (Normal - charging), 3 Battery, 4 Bypass
-  {HR,      10, 0,  "Px Load"},     //%     Internal Fault code from Modscan 
-  {HR,      11, 0,  "Px Rating"},   //kVA Internal Fault code from Modscan 
-
-  {DI,      11, 0,  "Output Overload"},                 
-  {DI,      20, 0,  "Bypass Not Ready"},     
-  {DI,     239, 0,  "Internal Comms Failure"},                  
-  {DI,     244, 0,  "System Shutdown-EPO"},                     
-  {DI,     245, 0,  "Fuse Failure"},                 
-  {DI,     247, 0,  "System Fan Failure"},                   
-  {DI,     249, 0,  "System Output Off"},                  
-  {DI,     254, 0,  "UPS Output on Bypass"},                 
-  {DI,     263, 0,  "Battery Low"},                  
-  
-  {IR,       1,  0,  "System Input RMS A-B"},                
-  {IR,       2,  0,  "System Input RMS B-C"},               
-  {IR,       3,  0,  "System Input RMS C-A"},           
-  {IR,       4,  0,  "System Input RMS A-N"},               
-  {IR,       5,  0,  "System Input RMS B-N"},               
-  {IR,       6,  0,  "System Input RMS C-N"},           
-  {IR,       7,  0,  "System Input RMS Current Phase A"},                  
-  {IR,       8,  0,  "System Input RMS Current Phase B"},                
-  {IR,       9,  0,  "System Input RMS Current Phase C"},                 
-  {IR_10x,  10,  0,  "System Input Frequency"},                  
-  {IR,      11,  0,  "System Input Power Factor Phs A"},       //0.01         
-  {IR,      12,  0,  "System Input Power Factor Phs B"},                
-  {IR,      13,  0,  "System Input Power Factor Phs C"},                
-  {IR_10x,  14,  0,  "System Input Power Phase A"},                    
-  {IR_10x,  15,  0,  "System Input Power Phase B"},                
-  {IR_10x,  16,  0,  "System Input Power Phase C"},                
-  {IR_10x,  17,  0,  "System Input Apparent Power Phs A"},            
-  {IR_10x,  18,  0,  "System Input Apparent Power Phs B"},         
-  {IR_10x,  19,  0,  "System Input Apparent Power Phs C"},                   
-  {IR,      23,  0,  "Bypass Input Voltage RMS A-B"},        
-  {IR,      24,  0,  "Bypass Input Voltage RMS B-C"},                  
-  {IR,      25,  0,  "Bypass Input Voltage RMS C-A"},                
-  {IR,      26,  0,  "Bypass Input Voltage RMS A-N"},  
-  {IR,      27,  0,  "Bypass Input Voltage RMS B-N"},            
-  {IR,      28,  0,  "Bypass Input Voltage RMS C-N"},                 
-  {IR_10x,  29,  0,  "Bypass Input Frequency"},              
-  {IR_10x,  30,  0,  "Bypass Power Phase A"},          
-  {IR_10x,  31,  0,  "Bypass Power Phase B"},         
-  {IR_10x,  32,  0,  "Bypass Power Phase C"},        
-  {IR,      38,  0,  "System Output RMS A-B"},                
-  {IR,      39,  0,  "System Output RMS B-C"},                
-  {IR,      40,  0,  "System Output RMS C-A"},                
-  {IR,      41,  0,  "System Output RMS A-N"},                
-  {IR,      42,  0,  "System Output RMS B-N"},                
-  {IR,      43,  0,  "System Output RMS C-N"},                
-  {IR,      44,  0,  "System Output RMS Current Phase A"},           
-  {IR,      45,  0,  "System Output RMS Current Phase B"},           
-  {IR,      46,  0,  "System Output RMS Current Phase C"},           
-  {IR_10x,  50,  0,  "System Output Frequency"},           
-  {IR,      51,  0,  "System Output Power Factor Phs A"},                 
-  {IR,      52,  0,  "System Output Power Factor Phs B"},                
-  {IR,      53,  0,  "System Output Power Factor Phs C"},                
-  {IR_10x,  54,  0,  "System Output Power Phase A"},                    
-  {IR_10x,  55,  0,  "System Output Power Phase B"},              
-  {IR_10x,  56,  0,  "System Output Power Phase C"},              
-  {IR_10x,  57,  0,  "System Output Apparent Power Phs A"},          
-  {IR_10x,  58,  0,  "System Output Apparent Power Phs B"},          
-  {IR_10x,  59,  0,  "System Output Apparent Power Phs C"},                     
-  {IR,      60,  0,  "System Output Power"},                     
-  {IR,      61,  0,  "System Output Apparent Power"},          
-  {IR,      164, 0,  "UPS Loading Status"},                                   
-  {IR,      175, 0,  "DC Bus Voltage"},                 
-  {IR,      179, 0,  "Percentage Load"},                 
-  {IR,      180, 0,  "Battery Time Remaining"},   
-  {IR,      183, 0,  "UPS Battery Status1"},
-  {IR,      184, 0,  "UPS Battery Status2"},   
-};
-//Size of modbus map used in FOR cycles, automatically calculated.
-
-/**
- * @brief The total number of entries in the `mb_map` array.
- * This is calculated at compile time and used for iterating over the map.
- */
-const int map_size = sizeof(mb_map) / sizeof(mb_map[0]);
-
-/** @brief The main loop update interval in milliseconds. */
-int interval = 250; 
-/** @} */ // End of ModbusMapConfig group
-
-#endif // CONFIG_H
\ No newline at end of file
diff --git a/src/EPMS/UPS/UPS_Vertiv_APM2_TCP/main.cpp b/src/EPMS/UPS/UPS_Vertiv_APM2_TCP/main.cpp
deleted file mode 100644
index 286a98c..0000000
--- a/src/EPMS/UPS/UPS_Vertiv_APM2_TCP/main.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-/**
- * @file main.cpp
- * @brief Main execution program for the CRAH Unit (TCP) Emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * @details This file contains the main execution program for an Arduino-based emulator of a CRAH unit. 
- * The program uses a Wi-Fi connection to communicate via the Modbus IP protocol.
- *
- * The setup() function initializes the following:
- * - Serial communication for debugging.
- * - Wi-Fi connection using credentials from config.h.
- * - A Modbus TCP server.
- * - Modbus points (Coils, Holding Registers, etc.) based on a predefined map in config.h.
- *
- * The loop() function continuously:
- * - Services the Modbus TCP server to handle incoming requests.
- * - Periodically calls the main update loop for the emulated equipment, which
- *   manages state transitions and behavior strategies.
- *
- * @see config.h for Wi-Fi and Modbus configuration.
- * @see Equipment.h for the main equipment logic.
- * @see State.h for different equipment states.
- * @see Strategies/Strategy_Behavior.h for value generation strategies.
- * @see Modbus_Point.h for the base class for all Modbus points.
- */
-//=================================================================================================================================
-//Libraries and declaration of variables.
-#include <WiFi.h>
-#include "config.h"
-#include "ModbusPoints/Modbus_PointFactory.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-//=================================================================================================================================
-/** 
- * @brief Initializes the application.
- * @details This function runs once at startup. It configures the serial communication, 
- * Wi-Fi, and the Modbus server. It also creates and initializes all the Modbus points 
- * based on the `mb_map` array in `config.h`.
- */
-void setup() {
-  Serial.begin(115200);                       //Serial comm start
-  WiFi.config(local_IP, gateway, subnet);     // Wifi service start
-  WiFi.begin(ssid, password);
-  while (WiFi.status() != WL_CONNECTED) {
-    delay(1000);
-    Serial.print(".");
-  }
-  Serial.println("Connected!!");
-  mb.server();                                //Modbus server start
-  Serial.println("Server Created");
-  Serial.println(map_size);
-  for(int i = 0; i < map_size; i++){
-    Modbus_Point<ModbusIP>* point = createModbus_Point(&mb, mb_map[i].category, mb_map[i].address, mb_map[i].value, mb_map[i].description);
-    if (point) {
-      point->addToModbusServer();
-      EquipmentInstance.addModbus_Point(mb_map[i].description, point);
-    }
-  }
-  Serial.println("All modbus Points created");
-  Serial.println("Setup function ended");
-}
-//=================================================================================================================================
-/** 
- * @brief The main application loop.
- * @details This function runs repeatedly after setup() has completed. It performs two main actions:
- * 1. It continuously services the Modbus server by calling `mb.task()` to handle
- *    incoming requests from a Modbus master.
- * 2. At a fixed interval (defined in `config.h`), it calls `EquipmentInstance.update()`
- *    to run the emulator's internal state machine and behavior logic.
- */
-void loop() {
-  mb.task();
-  unsigned long currentMillis = millis();
-  if (currentMillis - previousMillis >= interval) {
-    previousMillis = currentMillis;
-    unsigned long startTime = millis();
-    EquipmentInstance.update();
-    unsigned long endTime = millis();
-    unsigned long elapsedTime = endTime - startTime;
-    Serial.printf("Control Execution time: %d ms\n", elapsedTime);
-  } 
-}
diff --git a/src/EPMS/XFMR/XFMR_Manufacturer_Model_TCP/README.md b/src/EPMS/XFMR/XFMR_Manufacturer_Model_TCP/README.md
deleted file mode 100644
index 355156f..0000000
--- a/src/EPMS/XFMR/XFMR_Manufacturer_Model_TCP/README.md
+++ /dev/null
@@ -1,33 +0,0 @@
-# EQUIPMENT_TYPE MANUFACTURER MODEL TCP
-
-## Brief Introduction
-Equipment specifc details that make it different from other devices
-
-## List of Equipmentt
-This cofiguration has been used for these models:
-* **Model**: 09-15-22 
-* **Model**: 09-15-23 
-* **Model**: 09-15-25 
-
-## Hardware Prerequisites
-
-The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities.
-* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html) 
-
----
-
-## States and Strategies
-Provide a brief description of what variables and strategies were used in this configuraiton
-
-### Standby State
-* **Equipment running**: set to 0
-* **Common Alarm**: set to 0
-* **SAT temperature**: set to 85
-
-### Running State
-* **Equipment running**: set to 1
-* **SAT temperature**: **Ramp Strategy** set to 65 deg setpoint
-
-### Fail State
-* **Commong Alarm**: set to 1
-* **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset
diff --git a/src/EPMS/XFMR/XFMR_Manufacturer_Model_TCP/State_Fail.cpp b/src/EPMS/XFMR/XFMR_Manufacturer_Model_TCP/State_Fail.cpp
deleted file mode 100644
index 8bc0385..0000000
--- a/src/EPMS/XFMR/XFMR_Manufacturer_Model_TCP/State_Fail.cpp
+++ /dev/null
@@ -1,81 +0,0 @@
-/**
- * @file State_Fail.cpp
- * @brief Implementation of the FailState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the FailState, which defines
- * the behavior of the equipment when it has entered a fault condition.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new FailState object with a list of active alarms.
- *
- * This constructor receives a list of alarm descriptions and creates strategies
- * to set the corresponding Modbus points to a value of 1, indicating an
- * active alarm. It also initializes a PID strategy for the 'CW Valve Position'
- * to maintain its state during the fault.
- * @param activeAlarms A vector of strings, where each string is the
- *                     description of a Modbus point to be set as an active alarm.
- */
-template<>
-FailState<ModbusIP>::FailState(const std::vector<std::string>& activeAlarms) {
-    // Simulate a failure: set common alarm and a specific fan alarm.
-
-    
-}
-
-/**
- * @brief Executes the fail state's logic for one update cycle.
- *
- * This method checks the "Alarm Reset" Modbus point for a command to
- * transition back to Standby, which would typically happen after a fault
- * is cleared by a user. If no transition is requested, it continues to apply
- * the failure strategies (e.g., keeping alarm bits active).
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* FailState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Fail update function");
-    
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the fail state.
- * Sets the "Alarm Common" point to 1 to indicate a general fault condition.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Fail State...");
-}
-
-/**
- * @brief Logic to execute once when exiting the fail state.
- * Clears the "Alarm Common" point to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void FailState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Fail State...");
-}
\ No newline at end of file
diff --git a/src/EPMS/XFMR/XFMR_Manufacturer_Model_TCP/State_Running.cpp b/src/EPMS/XFMR/XFMR_Manufacturer_Model_TCP/State_Running.cpp
deleted file mode 100644
index b9e4a99..0000000
--- a/src/EPMS/XFMR/XFMR_Manufacturer_Model_TCP/State_Running.cpp
+++ /dev/null
@@ -1,89 +0,0 @@
-/**
- * @file State_Running.cpp
- * @brief Implementation of the RunningState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the RunningState, which defines
- * the behavior of the equipment when it is actively running.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "Strategies/Strategy_Totalizer.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-
-/**
- * @brief Constructs a new RunningState object.
- *
- * This constructor initializes behavior strategies active during the running
- * state, such as a PID controller for the 'CW Valve Position' and totalizers
- * for the run-hours of each EC fan.
- */
-template<>
-RunningState<ModbusIP>::RunningState() {
-}
-
-/**
- * @brief Executes the running state's logic for one update cycle.
- *
- * This method first checks for state transition commands:
- * 1. It reads the "ON/OFF Command By BMS" point. If it's 0, it transitions to StandbyState.
- * 2. It reads the "Fault Code" point. If it's non-zero, it transitions to FailState,
- *    passing the corresponding alarm description.
- *
- * If no transition occurs, it applies the strategies defined for the running state.
- *
- * @param equipment Pointer to the Equipment instance.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* RunningState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Running update function");
-    
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the running state.
- * Sets the "Run Status" for all EC fans to 1 to indicate they are active.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Running State...");
-    // You could also update a Modbus register to show the "standby" state
-
-}
-
-/**
- * @brief Logic to execute once when exiting the running state.
- * Sets the "Run Status" for all EC fans to 0 before transitioning to the next state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void RunningState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Running State...");
-   
-}
\ No newline at end of file
diff --git a/src/EPMS/XFMR/XFMR_Manufacturer_Model_TCP/State_Standby.cpp b/src/EPMS/XFMR/XFMR_Manufacturer_Model_TCP/State_Standby.cpp
deleted file mode 100644
index 20029d1..0000000
--- a/src/EPMS/XFMR/XFMR_Manufacturer_Model_TCP/State_Standby.cpp
+++ /dev/null
@@ -1,85 +0,0 @@
-/**
- * @file State_Standby.cpp
- * @brief Implementation of the StandbyState class.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-05
- *
- * This file contains the implementation for the StandbyState, which defines
- * the behavior of the equipment when it is in an idle or standby mode.
- */
-#include "ModbusPoints/Modbus_Point.h"
-#include "ModbusPoints/Modbus_FloatDecorator.h"
-#include "Equipment/Equipment.h"
-#include "Strategies/Strategy_Ramp.h"
-#include "Strategies/Strategy_Random.h"
-#include "Strategies/Strategy_Saw.h"
-#include "Strategies/Strategy_SingleValue.h"
-#include "Strategies/Strategy_Square.h"
-#include "Strategies/Strategy_PID.h"
-#include "States/State_Standby.h"
-#include "States/State_Running.h"
-#include "States/State_Fail.h"
-#include "States/State.h"
-#include <vector>
-#include <string>
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-/**
- * @brief Constructs a new StandbyState object.
- *
- * In this state, the equipment is idle. This constructor initializes strategies
- * to bring the system to a safe, idle condition. It sets a stable value for
- * the SAT reading and creates ramp strategies to bring the CW valve and all
- * EC fan speeds down to zero.
- */
-template<>
-StandbyState<ModbusIP>::StandbyState() {
-    // You can add initialization code here if needed
-    
-
-}
-
-/**
- * @brief Executes the standby state's logic for one update cycle.
- *
- * This method applies the strategies defined for the standby state (e.g.,
- * ramping values to zero).
- *
- * @warning This method currently does not check for a command to transition to the
- *          Running state. This logic needs to be added to allow the unit to start.
- * @return A pointer to a new State if a transition should occur, otherwise nullptr.
- */
-template<>
-State<ModbusIP>* StandbyState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
-    // STATE control, add conditions if change to a different state is needed
-    Serial.println("Standby update function");
-    
-    // Apply any strategies defined for the standby state
-    _applyStrategies(equipment);
-    return nullptr;
-}
-
-/**
- * @brief Logic to execute once when entering the standby state.
- * This method performs cleanup by setting all alarm points and all EC fan
- * run status points to 0.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
-    // Logic to run when the equipment enters this state
-    Serial.println("Enter Standby State...");
-}
-
-/**
- * @brief Logic to execute once when exiting the standby state.
- * @param equipment Pointer to the Equipment instance.
- */
-template<>
-void StandbyState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
-    // Cleanup logic to run when the equipment leaves this state
-    Serial.println("Exit Standby State...");
-}
\ No newline at end of file
diff --git a/src/EPMS/XFMR/XFMR_Manufacturer_Model_TCP/config.h b/src/EPMS/XFMR/XFMR_Manufacturer_Model_TCP/config.h
deleted file mode 100644
index bd4ad09..0000000
--- a/src/EPMS/XFMR/XFMR_Manufacturer_Model_TCP/config.h
+++ /dev/null
@@ -1,152 +0,0 @@
-/**
- * @file config.h
- * @brief Main configuration file for the CRAH Unit (TCP) emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * This file contains two important configurations: WiFi network parameters
- * and the Modbus register map for the device.
- */
-
-#ifndef CONFIG_H
-#define CONFIG_H
-
-#include "core.h"
-#include "Equipment/Equipment.h"
-
-#if defined(USE_MODBUS_IP)
-/**
-   * @defgroup ModbusTCPConfig Modbus IP Configuration
-   * @brief Parameters for Modbus TCP communication.
-   * @{
-   */
-  #include <ModbusIP_ESP8266.h>
-  const char *ssid = "wifi_name";       /**< @brief The SSID of the WiFi network. */
-  const char *password = "wifi_password";   /**< @brief The password for the WiFi network. */
-  IPAddress local_IP(192, 168, 1, 234);       /**< @brief The static IP address for the device. */
-  IPAddress gateway(192, 168, 1, 1);          /**< @brief The gateway IP address. */
-  IPAddress subnet(255, 255, 255, 0);         /**< @brief The subnet mask. */
-  
-  ModbusIP mb;
-#else
-  /**
-   * @defgroup ModbusRTUConfig Modbus RTU Configuration
-   * @brief Parameters for serial Modbus RTU communication.
-   * @{
-   */
-  #include <ModbusRTU.h>
-  const int BAUDRATE = 19200;   /**< @brief The serial communication speed in bits per second. */
-  const int RX_PIN = 17;        /**< @brief The GPIO pin used for receiving data (RX). */
-  const int TX_PIN = 16;        /**< @brief The GPIO pin used for transmitting data (TX). */
-  const int RST_PIN = 4;        /**< @brief The GPIO pin connected to the RS485 driver's DE/RE pins for direction control. */
-  const int MODBUS_ID = 1;      /**< @brief The unique slave ID for this device on the Modbus bus. */
-  /** @} */
-
-  /** @brief Global instance of the Modbus RTU server. */
-  ModbusRTU mb;
-#endif
-
-
-
-/**
- * @defgroup ModbusMapConfig Modbus Map Configuration
- * @brief Defines the Modbus register map and related parameters for the emulator.
- * @{
- */
-/**
- * @brief The Modbus map for the Equipment device.
- * This array defines all the Modbus points available on the emulated device.
- * The `description` field is crucial as it's used to look up points within the application logic.
- */
-modbusMap mb_map[] =
-{   
-  {HR,        15,     0,  "State Control"},  //Internal to control from Modscan
-  {HR,        16,     0,  "Fault Code"},
-  {HR_FLOAT,  18,     0,  "RAT"},     //Internal Fault code from Modscan  
-  {HR_FLOAT,  1,      0,  "SAT Setpoint"},                     
-  {HR_FLOAT,  681,    0,  "RAT Setpoint"},                   
-  {HR_FLOAT,  111,    0,  "High RAT Limit"},                 
-  {HR_FLOAT,  114,    0,  "Low RAT Limit"},                  
-  {HR_FLOAT,  118,    0,  "High SAT Limit"},                 
-  {HR_FLOAT,  122,    0,  "Low SAT Limit"},                  
-  {HR_FLOAT,  685,    0,  "High RAH Limit"},                 
-  {HR_FLOAT,  689,    0,  "Low RAH Limit"},                  
-  {HR,        5,      0,  "Setting the EC Fan Max Speed"},   
-  {HR,        695,    0,  "Setting the EC Fan Min Speed"},   
-  {HR_FLOAT,  693,    0,  "Setting Room Temp"},              
-  {HR,        691,    0,  "Setting EC Fan Speed "},          
-  {DI,        146,    0,  "Alarm SAT Sensor Fault"},         
-  {DI,        1246,   0,  "Alarm RAH Sensor Fault"},        
-  {DI,        1245,   0,  "Alarm RAT Sensor Fault"},        
-  {DI,        1250,   0,  "Alarm Filter DP Sensor Fault"},  
-  {DI,        51,     0,  "Alarm Flooding"},                  
-  {DI,        1096,   0,  "Alarm Dirty Filter"},            
-  {DI,        1367,   0,  "Alarm High RAT"},                
-  {DI,        1099,   0,  "Alarm Low RAT"},                 
-  {DI,        118,    0,  "Alarm High SAT"},                 
-  {DI,        122,    0,  "Alarm Low SAT"},                  
-  {DI,        1307,   0,  "Alarm High RAH"},                
-  {DI,        1308,   0,  "Alarm Low RAH"},                 
-  {DI,        1342,   0,  "Alarm Common"},                  
-  {DI,        148,    0,  "Alarm Phase Failure"},            
-  {DI,        1370,   0,  "Alarm Condensate Pump"},         
-  {DI,        1368,   0,  "Alarm Smoke"},                   
-  {DI,        1369,   0,  "Alarm Fire"},                    
-  {DI,        131,    0,  "Alarm EC Fan #1"},                
-  {DI,        132,    0,  "Alarm EC Fan #2"},                
-  {DI,        133,    0,  "Alarm EC Fan #3"},                
-  {DI,        134,    0,  "Alarm EC Fan #4"},                
-  {DI,        135,    0,  "Alarm EC Fan #5"},                
-  {DI,        136,    0,  "Alarm EC Fan #6"},                
-  {DI,        1360,   0,  "Alarm EC Fan #7"},               
-  {DI,        1361,   0,  "Alarm EC Fan #8"},               
-  {DI,        1362,   0,  "Alarm EC Fan #9"},               
-  {DI,        138,    0,  "Run Status EC Fan #1"},           
-  {DI,        139,    0,  "Run Status EC Fan #2"},           
-  {DI,        140,    0,  "Run Status EC Fan #3"},           
-  {DI,        141,    0,  "Run Status EC Fan #4"},           
-  {DI,        142,    0,  "Run Status EC Fan #5"},           
-  {DI,        143,    0,  "Run Status EC Fan #6"},           
-  {DI,        1363,   0,  "Run Status EC Fan #7"},          
-  {DI,        1364,   0,  "Run Status EC Fan #8"},          
-  {DI,        1365,   0,  "Run Status EC Fan #9"},          
-  {IR_FLOAT,  99,     0,  "SAT Reading"},                     
-  {IR_FLOAT,  70,     0,  "RAH Reading"},                     
-  {IR_FLOAT,  101,    0,  "RAT Reading"},                    
-  {IR_FLOAT,  106,    0,  "Filter DP Reading"},              
-  {IR_FLOAT,  496,    0,  "CW Valve Position"},              
-  {IR,        53,     0,  "Speed EC Fan #1"},                 
-  {IR,        228,    0,  "Speed EC Fan #2"},                
-  {IR,        229,    0,  "Speed EC Fan #3"},                
-  {IR,        230,    0,  "Speed EC Fan #4"},                
-  {IR,        231,    0,  "Speed EC Fan #5"},                
-  {IR,        232,    0,  "Speed EC Fan #6"},                
-  {IR,        678,    0,  "Speed EC Fan #7"},                
-  {IR,        679,    0,  "Speed EC Fan #8"},                
-  {IR,        680,    0,  "Speed EC Fan #9"},                
-  {IR,        274,    0,  "Operating Hours EC Fan #1"},      
-  {IR,        233,    0,  "Operating Hours EC Fan #2"},      
-  {IR,        244,    0,  "Operating Hours EC Fan #3"},      
-  {IR,        235,    0,  "Operating Hours EC Fan #4"},      
-  {IR,        236,    0,  "Operating Hours EC Fan #5"},      
-  {IR,        245,    0,  "Operating Hours EC Fan #6"},      
-  {IR,        486,    0,  "Operating Hours EC Fan #7"},      
-  {IR,        487,    0,  "Operating Hours EC Fan #8"},      
-  {IR,        488,    0,  "Operating Hours EC Fan #9"},      
-  {COIL,      301,    0,  "ON/OFF Command By BMS"},        
-  {COIL,      302,    0,  "Enable Off By Supervisory"},    
-  {COIL,      264,    0,  "Alarm Reset"}                                  
-};
-//Size of modbus map used in FOR cycles, automatically calculated.
-
-/**
- * @brief The total number of entries in the `mb_map` array.
- * This is calculated at compile time and used for iterating over the map.
- */
-const int map_size = sizeof(mb_map) / sizeof(mb_map[0]);
-
-/** @brief The main loop update interval in milliseconds. */
-int interval = 250; 
-/** @} */ // End of ModbusMapConfig group
-
-#endif // CONFIG_H
diff --git a/src/EPMS/XFMR/XFMR_Manufacturer_Model_TCP/main.cpp b/src/EPMS/XFMR/XFMR_Manufacturer_Model_TCP/main.cpp
deleted file mode 100644
index 286a98c..0000000
--- a/src/EPMS/XFMR/XFMR_Manufacturer_Model_TCP/main.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-/**
- * @file main.cpp
- * @brief Main execution program for the CRAH Unit (TCP) Emulator.
- * @author Emmanuel Hernandez Cruz
- * @date 2025-09-02
- *
- * @details This file contains the main execution program for an Arduino-based emulator of a CRAH unit. 
- * The program uses a Wi-Fi connection to communicate via the Modbus IP protocol.
- *
- * The setup() function initializes the following:
- * - Serial communication for debugging.
- * - Wi-Fi connection using credentials from config.h.
- * - A Modbus TCP server.
- * - Modbus points (Coils, Holding Registers, etc.) based on a predefined map in config.h.
- *
- * The loop() function continuously:
- * - Services the Modbus TCP server to handle incoming requests.
- * - Periodically calls the main update loop for the emulated equipment, which
- *   manages state transitions and behavior strategies.
- *
- * @see config.h for Wi-Fi and Modbus configuration.
- * @see Equipment.h for the main equipment logic.
- * @see State.h for different equipment states.
- * @see Strategies/Strategy_Behavior.h for value generation strategies.
- * @see Modbus_Point.h for the base class for all Modbus points.
- */
-//=================================================================================================================================
-//Libraries and declaration of variables.
-#include <WiFi.h>
-#include "config.h"
-#include "ModbusPoints/Modbus_PointFactory.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
-//=================================================================================================================================
-/** 
- * @brief Initializes the application.
- * @details This function runs once at startup. It configures the serial communication, 
- * Wi-Fi, and the Modbus server. It also creates and initializes all the Modbus points 
- * based on the `mb_map` array in `config.h`.
- */
-void setup() {
-  Serial.begin(115200);                       //Serial comm start
-  WiFi.config(local_IP, gateway, subnet);     // Wifi service start
-  WiFi.begin(ssid, password);
-  while (WiFi.status() != WL_CONNECTED) {
-    delay(1000);
-    Serial.print(".");
-  }
-  Serial.println("Connected!!");
-  mb.server();                                //Modbus server start
-  Serial.println("Server Created");
-  Serial.println(map_size);
-  for(int i = 0; i < map_size; i++){
-    Modbus_Point<ModbusIP>* point = createModbus_Point(&mb, mb_map[i].category, mb_map[i].address, mb_map[i].value, mb_map[i].description);
-    if (point) {
-      point->addToModbusServer();
-      EquipmentInstance.addModbus_Point(mb_map[i].description, point);
-    }
-  }
-  Serial.println("All modbus Points created");
-  Serial.println("Setup function ended");
-}
-//=================================================================================================================================
-/** 
- * @brief The main application loop.
- * @details This function runs repeatedly after setup() has completed. It performs two main actions:
- * 1. It continuously services the Modbus server by calling `mb.task()` to handle
- *    incoming requests from a Modbus master.
- * 2. At a fixed interval (defined in `config.h`), it calls `EquipmentInstance.update()`
- *    to run the emulator's internal state machine and behavior logic.
- */
-void loop() {
-  mb.task();
-  unsigned long currentMillis = millis();
-  if (currentMillis - previousMillis >= interval) {
-    previousMillis = currentMillis;
-    unsigned long startTime = millis();
-    EquipmentInstance.update();
-    unsigned long endTime = millis();
-    unsigned long elapsedTime = endTime - startTime;
-    Serial.printf("Control Execution time: %d ms\n", elapsedTime);
-  } 
-}
diff --git a/src/README.md b/src/README.md
index 16d02de..355156f 100644
--- a/src/README.md
+++ b/src/README.md
@@ -1,22 +1,33 @@
-# Core Concepts
+# EQUIPMENT_TYPE MANUFACTURER MODEL TCP
 
 ## Brief Introduction
-This file explains the concepts of States and strategies, needed to modify the different programs. 
+Equipment specifc details that make it different from other devices
 
-## State concepts
-The emulator operates on a state machine with three core states:
-* **Standby**: The equipment is idle but ready.
-* **Running**: The equipment is active and operational.
-* **Fail**: The equipment has encountered a fault condition.
-* **Other**: It's possible to add more states, but new states need to be generated in the core library as well; consider use the 3 basic states before adding more.
+## List of Equipmentt
+This cofiguration has been used for these models:
+* **Model**: 09-15-22 
+* **Model**: 09-15-23 
+* **Model**: 09-15-25 
 
-## Strategy concepts
-The emulator is able to run different predefined strategies to control the modbus registers, this is the list of available strategies:
-* **Single Value**: This strategy will set a value to a setpoint, it has the option to add noise to the value.
-* **Random**: Random value between 0 and 100, can be used to L1 testing.
-* **Ramp**: The selected value is going to be adjusted in a constant step rate, to a setpoint, setpoint can be updated in execution time.
-* **Saw Wave**: Moves the value between two sepoints with constart increments, once it reaches the limit it will reverse direction.
-* **Square Wave**: Constant change between two sepoints with instant change between them.
-* **PID**: Full PID controller, you need to give a output, input and setpoint modbus address, PID calculate the output based on the input and the PID constants.
-* **Totalizer**: Constant increment of a value, to emulate run hours. 
-For more details read the specific strategy implementation
\ No newline at end of file
+## Hardware Prerequisites
+
+The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities.
+* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html) 
+
+---
+
+## States and Strategies
+Provide a brief description of what variables and strategies were used in this configuraiton
+
+### Standby State
+* **Equipment running**: set to 0
+* **Common Alarm**: set to 0
+* **SAT temperature**: set to 85
+
+### Running State
+* **Equipment running**: set to 1
+* **SAT temperature**: **Ramp Strategy** set to 65 deg setpoint
+
+### Fail State
+* **Commong Alarm**: set to 1
+* **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset
diff --git a/src/BMS/CRAC/CRAC_Munters_SysCooll_TCP/main.cpp b/src/main.cpp
similarity index 65%
rename from src/BMS/CRAC/CRAC_Munters_SysCooll_TCP/main.cpp
rename to src/main.cpp
index 286a98c..39d0fe5 100644
--- a/src/BMS/CRAC/CRAC_Munters_SysCooll_TCP/main.cpp
+++ b/src/main.cpp
@@ -27,13 +27,11 @@
 //=================================================================================================================================
 //Libraries and declaration of variables.
 #include <WiFi.h>
-#include "config.h"
-#include "ModbusPoints/Modbus_PointFactory.h"
-#if defined(USE_MODBUS_IP)
-  #include <ModbusIP_ESP8266.h>
-#else
-  #include <ModbusRTU.h>
-#endif
+#include <ModbusIP_ESP8266.h>
+#include <ModbusRTU.h>
+#include "Equipment/Equipment.h"
+#include "Storage.h"
+#include "ConfigParser.h"
 //=================================================================================================================================
 /** 
  * @brief Initializes the application.
@@ -41,27 +39,23 @@
  * Wi-Fi, and the Modbus server. It also creates and initializes all the Modbus points 
  * based on the `mb_map` array in `config.h`.
  */
+ModbusIP mbIP;
+ModbusRTU mbRTU;
+
+bool modeIsTCP = true;
+
 void setup() {
   Serial.begin(115200);                       //Serial comm start
-  WiFi.config(local_IP, gateway, subnet);     // Wifi service start
-  WiFi.begin(ssid, password);
-  while (WiFi.status() != WL_CONNECTED) {
-    delay(1000);
-    Serial.print(".");
+  
+  String lastConfig = Storage::readConfigFile();
+
+  if (lastConfig != ""){
+    ConfigParser::apply(lastConfig, mbIP, mbRTU, &modeIsTCP);
   }
-  Serial.println("Connected!!");
-  mb.server();                                //Modbus server start
-  Serial.println("Server Created");
-  Serial.println(map_size);
-  for(int i = 0; i < map_size; i++){
-    Modbus_Point<ModbusIP>* point = createModbus_Point(&mb, mb_map[i].category, mb_map[i].address, mb_map[i].value, mb_map[i].description);
-    if (point) {
-      point->addToModbusServer();
-      EquipmentInstance.addModbus_Point(mb_map[i].description, point);
-    }
+  else {
+    WiFi.softAP("ESP32_Modbus_Simulator", "12345678");
+    ConfigParser::initPythonTCPServer();
   }
-  Serial.println("All modbus Points created");
-  Serial.println("Setup function ended");
 }
 //=================================================================================================================================
 /** 
@@ -73,14 +67,21 @@ void setup() {
  *    to run the emulator's internal state machine and behavior logic.
  */
 void loop() {
-  mb.task();
-  unsigned long currentMillis = millis();
-  if (currentMillis - previousMillis >= interval) {
-    previousMillis = currentMillis;
-    unsigned long startTime = millis();
-    EquipmentInstance.update();
-    unsigned long endTime = millis();
-    unsigned long elapsedTime = endTime - startTime;
-    Serial.printf("Control Execution time: %d ms\n", elapsedTime);
+  if (modeIsTCP) {
+    mbIP.task();
+  } else {
+    mbRTU.task();
+  }
+  if (Serial.available() >0){
+    String jsonSerial = Serial.readStringUntil('\n');
+    if (jsonSerial.startsWith("{")) {
+      ConfigParser::apply(jsonSerial, mbIP, mbRTU, &modeIsTCP);
+      Storage::saveConfigFile(jsonSerial);
+      Serial.println(F("Config applied."));
+    }
   } 
+  if (WiFi.status() == WL_CONNECTED || WiFi.softAPIP()) {
+    ConfigParser::checkPythonTCPClient(mbIP, mbRTU, &modeIsTCP);
+  }
+  ConfigParser::getEquipmentInstance()->updateAllPoints();
 }