Add Modbus RTU polling

Author: Eric Berseth

config-schema.json

@@ -57,6 +57,16 @@ enum class ThresholdState {
     BelowThreshold      /**< Input value is below threshold */
 };
 
+/**
+ * @brief Convenient states for publishing
+  */
+enum class ThresholdAlert {
+    None,
+    Above,
+    Below,
+    Both,
+};
+
 /**
  * @brief Inclusive limit options for thresholds.
  * The the equal is also considered if a threshold (plus hysteresis) is inclusive
@@ -85,7 +95,7 @@ enum class ThresholdInitial {
 
 /**
  * @brief Event handler for threshold crossings.
- * 
+ *
  * @tparam T Type of the input value.
  * @param value The input value that triggered the event.
  * @param state The current threshold state.
@@ -95,7 +105,7 @@ using ThresholdEvent = std::function<void(T value, ThresholdState state)>;
 
 /**
  * @brief Class for comparing an input value to a threshold.
- * 
+ *
  * @tparam T Type of the input value.
  */
 template<typename T>
@@ -126,7 +136,7 @@ class ThresholdComparator {
 
     /**
      * @brief Set the threshold value.
-		 * 
+     *
      * @param threshold The new threshold value.
      */
     void setThreshold(T threshold) {
@@ -137,7 +147,7 @@ class ThresholdComparator {
 
     /**
      * @brief Get the current threshold value.
-		 * 
+     *
      * @return The current threshold value.
      */
     T getThreshold() const {
@@ -147,7 +157,7 @@ class ThresholdComparator {
 
     /**
      * @brief Set the hysteresis value.  This value must be positive.
-		 * 
+     *
      * @param hysteresis The new hysteresis value.
      */
     void setHysteresis(T hysteresis) {
@@ -163,27 +173,27 @@ class ThresholdComparator {
 
     /**
      * @brief Get the current hysteresis value.
-		 * 
+     *
      * @return The current hysteresis value.
      */
     T getHysteresis() const {
         std::lock_guard<RecursiveMutex> lock(_mutex);
         return _hysteresis;
     }
 
-		/**
-		 * @brief Set the threshold crossing callback function.
-		 * 
-		 * @param callback The callback function for threshold crossings.
-		 */
-		void setCallback(ThresholdEvent<T> callback) {
-				std::lock_guard<RecursiveMutex> lock(_mutex);
-				_thresholdMetCallback = callback;
-		}
+    /**
+     * @brief Set the threshold crossing callback function.
+     *
+     * @param callback The callback function for threshold crossings.
+     */
+    void setCallback(ThresholdEvent<T> callback) {
+        std::lock_guard<RecursiveMutex> lock(_mutex);
+        _thresholdMetCallback = callback;
+    }
 
     /**
      * @brief Set the inclusive limit options.
-		 * 
+     *
      * @param inclusive The new inclusive limit options.
      */
     void setInclusive(ThresholdInclusive inclusive) {
@@ -194,7 +204,7 @@ class ThresholdComparator {
 
     /**
      * @brief Get the current inclusive limit options.
-		 * 
+     *
      * @return The current inclusive limit options.
      */
     ThresholdInclusive getInclusive() const {
@@ -204,7 +214,7 @@ class ThresholdComparator {
 
     /**
      * @brief Evaluate the input value against the threshold.
-		 * 
+     *
      * @param inputValue The input value to compare against the threshold and hysteresis.
      * @return The current threshold state.
      */

lib/edge/src/ThresholdComparator.h

@@ -63,6 +63,22 @@ enum class ModbusType
   HoldingRegister,                            ///< Holding register
 };
 
+/**
+ * @brief Enums to help with 4-byte endian conversion for floating point numbers.
+ * The Particle platforms operate with little endian byte order when storing numbers.
+ * Modbus is supposed to be a big endian word order protocol but each server implementation
+ * may have a different way to read out 32-bit floating point values which probably depends
+ * on the embedded controller employed in the remote peice of equipment.
+ * 
+ */
+enum class ModbusFloatEndianess
+{
+  ABCD,                                       ///< All bytes and words are in big endian order
+  BADC,                                       ///< Bytes are in little endian, words are in big endian order
+  CDAB,                                       ///< Bytes are in big endian, words are in little endian order
+  DCBA,                                       ///< All bytes and words are in little endian order
+};
+
 struct ModbusClientContext {
   uint16_t writeBuffer[ku8MaxBufferSize];     ///< buffer containing data to transmit to Modbus server; set via SetTransmitBuffer()
   uint16_t writeAddress;                      ///< server register to which to write
@@ -560,6 +576,21 @@ class ModbusClient
      */
     uint8_t  readWriteMultipleRegisters(uint8_t id, uint16_t u16ReadAddress, uint16_t u16ReadQty, uint16_t u16WriteAddress, uint16_t u16WriteQty, ModbusClientContext& context);
 
+    /**
+     * @brief Swap two bytes in a 16-bit word.
+     *
+     * @param hi Most significant byte
+     * @param lo Least significant byte
+     * @return uint16_t Combined 16-bit word.
+     */
+    static inline uint16_t swapBytes(uint16_t word)
+    {
+      uint8_t* bytes = (uint8_t*)&word;
+      uint8_t swap = bytes[1];
+      bytes[1] = bytes[0];
+      bytes[0] = swap;
+      return word;
+    }
 
     /**
      * @brief Pack two bytes into a 16-bit word.
@@ -626,22 +657,42 @@ class ModbusClient
      *
      * @param word0 First ordered word from register
      * @param word1 Second ordered word from register
-     * @param littleEndian Use little endian word order to form number; otherwise, use big endian word order
+     * @param endian Specify byte and word endian orders
      * @return float Combined 32-bit floating point number.
      */
-    static inline float wordsToFloat(uint16_t word0, uint16_t word1, bool littleEndian = false)
+    static inline float wordsToFloat(uint16_t word0, uint16_t word1, ModbusFloatEndianess endian = ModbusFloatEndianess::CDAB)
     {
       float val {};
       uint16_t* pval = (uint16_t*)&val;
-      if (littleEndian)
+      switch (endian)
       {
-        pval[0] = word0;
-        pval[1] = word1;
-      }
-      else
-      {
-        pval[0] = word1;
-        pval[1] = word0;
+        case ModbusFloatEndianess::ABCD:
+          // Word[0] has bytes A*256 + B, word[1] has bytes C*256 + D
+          // Big endian word order and normal byte order
+          pval[0] = word1;
+          pval[1] = word0;
+          break;
+
+        case ModbusFloatEndianess::BADC:
+          // Word[0] has bytes B*256 + A, word[1] has bytes D*256 + C
+          // Big endian word order and swapped byte order
+          pval[0] = swapBytes(word1);
+          pval[1] = swapBytes(word0);
+          break;
+
+        case ModbusFloatEndianess::CDAB:
+          // Word[0] has bytes C*256 + D, word[1] has bytes A*256 + B
+          // Little endian word order and normal byte order
+          pval[0] = word0;
+          pval[1] = word1;
+          break;
+
+        case ModbusFloatEndianess::DCBA:
+          // Word[0] has bytes D*256 + C, word[1] has bytes B*256 + A
+          // Little endian word order and swapped byte order
+          pval[0] = swapBytes(word0);
+          pval[1] = swapBytes(word1);
+          break;
       }
       return val;
     }
@@ -652,20 +703,40 @@ class ModbusClient
      * @param value Combined 32-bit floating point number
      * @param word0 First ordered word to register
      * @param word1 Second ordered word to register
-     * @param littleEndian Use little endian word order to form number; otherwise, use big endian word order
+     * @param endian Specify byte and word endian orders
      */
-    static inline void floatToWords(float value, uint16_t& word0, uint16_t& word1, bool littleEndian = false)
+    static inline void floatToWords(float value, uint16_t& word0, uint16_t& word1, ModbusFloatEndianess endian = ModbusFloatEndianess::CDAB)
     {
       uint16_t* pval = (uint16_t*)&value;
-      if (littleEndian)
-      {
-        word0 = pval[0];
-        word1 = pval[1];
-      }
-      else
+      switch (endian)
       {
-        word1 = pval[0];
-        word0 = pval[1];
+        case ModbusFloatEndianess::ABCD:
+          // Word[0] has bytes A*256 + B, word[1] has bytes C*256 + D
+          // Big endian word order and normal byte order
+          word1 = pval[0];
+          word0 = pval[1];
+          break;
+
+        case ModbusFloatEndianess::BADC:
+          // Word[0] has bytes B*256 + A, word[1] has bytes D*256 + C
+          // Big endian word order and swapped byte order
+          word1 = swapBytes(pval[0]);
+          word0 = swapBytes(pval[1]);
+          break;
+
+        case ModbusFloatEndianess::CDAB:
+          // Word[0] has bytes C*256 + D, word[1] has bytes A*256 + B
+          // Little endian word order and normal byte order
+          word0 = pval[0];
+          word1 = pval[1];
+          break;
+
+        case ModbusFloatEndianess::DCBA:
+          // Word[0] has bytes D*256 + C, word[1] has bytes B*256 + A
+          // Little endian word order and swapped byte order
+          word0 = swapBytes(pval[0]);
+          word1 = swapBytes(pval[1]);
+          break;
       }
     }
 

lib/modbus/src/ModbusClient.h

@@ -30,3 +30,5 @@
 #define MONITOREDGE_IOEX_RS485_RX_PIN           (RX)
 #define MONITOREDGE_IOEX_RS485_TX_PIN           (TX)
 #define MONITOREDGE_IOEX_RS485_DE_PIN           (D4)
+
+constexpr char MONITOREDGE_IOEX_SKU[]           {"EXP1_IO_BASIC_485CAN"};

lib/monitor-one/src/monitor_edge_ioexpansion.h

@@ -17,6 +17,7 @@
 #pragma once
 
 #include "tracker_config.h"
+#include "IEdgePlatformConfiguration.h"
 #include "monitor_one_user_led.h"
 #include "Adp8866GnssLed.h"
 

lib/monitor-one/src/monitor_one_config.h

@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2023 Particle Industries, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "tracker_config.h"             // For TSOM related configuration
+#include "monitor_one_config.h"         // For Monitor One related configuration
+
+#define MONITOR_ONE_SUPPORT_PROTO       (1)
+#define MONITOR_ONE_SUPPORT_IOEXP       (1)
+
+using MonitorOneCardFunction = std::function<int(void)>;
+
+#if defined(MONITOR_ONE_SUPPORT_PROTO) && MONITOR_ONE_SUPPORT_PROTO
+constexpr char MONITOREDGE_PROTO_SKU[]  {"EXP1_PROTO"};
+#endif // MONITOR_ONE_SUPPORT_PROTO
+
+
+#if defined(MONITOR_ONE_SUPPORT_IOEXP) && MONITOR_ONE_SUPPORT_IOEXP
+#include "monitor_edge_ioexpansion.h"
+int expanderIoInit();
+int expanderIoLoop();
+#endif // MONITOR_ONE_SUPPORT_IOEXP