Public release MSCL 63.1.0

CHANGELOG.txt

@@ -14,6 +14,31 @@ RENAMED - A function/class has been renamed.
 REMOVED - A function/class has been removed.
 ======================================================================================================
 
+63.1.0 - 2022-01-13
+- Added RTK (v2) 6285-0100 bitfield status support and set as default
+- Updated RTK (v1) 6285-0000 bitfield status to have _v1 suffix
+
+63.0.1 - 2022-01-06
+- Increase default readWriteRetries for BaseStation and WirelessNode objects from 0
+    - BaseStation default: 2
+    - WirelessNode default: 3
+
+63.0.0 - 2022-01-05
+- Add enum MipModels::Modifier to represent the second half of a MIP model number for select models
+- Add enum MipModels::ModelNumber as an integer representation of full MIP device model numbers
+- Add functions to properly compare model numbers with placeholder modifier values
+- Add MipModel class to represent a MIP model number that keeps track of full model number, node model (first part), and modifier (second part)
+    - Add MipModel object constants to represent known products
+- MipNode::model() now returns a MipModel object instead of MipModels::NodeModel enum value
+- Remove unsupported MipModels::NodeModel enum values: node_3dm, node_fasA, node_3dm_gx2
+
+62.2.1 - 2022-01-05
+- Update Torque-Link-200-3ch (s) gain values
+
+62.2.0 - 2021-11-22
+- Update wireless sensor warmup delay min/max values
+- Add wireless sensor warmup delay default values
+
 62.1.2 - 2021-10-18
 - Fixes Windows python build, and updates windows python build scripts to work easier out of the box
 

HowToUseMSCL.md

@@ -61,6 +61,16 @@ sudo yum install ./<PACKAGE_NAME>.rpm   #install MSCL and it's dependencies
 
 *Note:* to uninstall MSCL, run: `sudo yum remove <PACKAGE_NAME>.rpm`
 
+### Udev
+
+Download the [udev](https://github.com/LORD-MicroStrain/microstrain_inertial/blob/ros/microstrain_inertial_driver/debian/udev) file from our ROS driver, and copy it to `/usr/lib/udev/rules.d/100-microstrain.rules` on Ubuntu or `/etc/udev/rules.d/100-microstrain.rules` on debian, CentOS, or Redhat
+
+Once the udev rule is installed, the devices will appear as follows in the file system, where {serial} is the serial number of the device:
+
+* `/dev/microstrain_main_{serial}` - All GX5 devices, and the main port of GQ7 devices
+* `/dev/microstrain_aux_{serial}` - The aux port of GQ7 devices
+* `/dev/microstrain_rtk_{serial}` - 3DM-RTK devices
+
 ### Python
 After installing the package, a folder was created in `/usr/share/`. The name of the folder varies depending on which package you install (`/usr/share/python2-mscl` or `/usr/share/python3-mscl`)
 

MSCL/source/mscl/LibVersion.h

@@ -10,9 +10,9 @@ MIT Licensed. See the included LICENSE.txt for a copy of the full MIT License.
 
 #ifndef SWIG
 //update with each release
-#define MSCL_MAJOR 62
+#define MSCL_MAJOR 63
 #define MSCL_MINOR 1
-#define MSCL_PATCH 2
+#define MSCL_PATCH 0
 #endif
 
 namespace mscl

MSCL/source/mscl/MicroStrain/Inertial/Commands/DeviceStatus.h

@@ -22,7 +22,7 @@ namespace mscl
     {
     public:
         //Function: commandName
-		//
+        //
         //Returns:
         //    std::string - the string name for this class.
         virtual std::string commandName() const { return "DeviceStatus"; }
@@ -41,7 +41,7 @@ namespace mscl
         //
         //Parameters:
         //    model - model number of the current device
-		//
+        //
         //Returns:
         //    DeviceStatus - object set up for getting a basic status.
         static DeviceStatus MakeGetBasicCommand(MipModels::NodeModel model);
@@ -50,16 +50,16 @@ namespace mscl
         //
         //Parameters:
         //    model - model number of the current device
-		//
+        //
         //Returns:
         //    DeviceStatus - object set up for getting a diagnostic status.
         static DeviceStatus MakeGetDiagnosticCommand(MipModels::NodeModel model);
 
         //Function: getResponseData
-		//
+        //
         //Parameter:
         //    response - The <GenericMipCmdResponse> object from which to get formatted data.
-		//
+        //
         //Returns:
         //    DeviceStatusData - An object with the data returned from the device.
         static DeviceStatusData getResponseData(const GenericMipCmdResponse& response);
@@ -71,22 +71,22 @@ namespace mscl
     private:
         // Function: Constructor DeviceStatus
         //    Private constructor creates a DeviceStatus object.  Use Make___Command methods to create an object.
-		DeviceStatus(MipModels::NodeModel model, DeviceStatusData::StatusSelector status_selector);
+        DeviceStatus(MipModels::NodeModel model, DeviceStatusData::StatusSelector status_selector);
 
         //Function: commandType
-		//
+        //
         //Returns:
         //    MipTypes::Command - the command ID.
         virtual MipTypes::Command commandType() const { return MipTypes::CMD_DEVICE_STATUS; }
 
         //Function: fieldDataByte
-		//
+        //
         //Returns:
         //    uint8 - the byte ID for field data in the reply.
         virtual uint8 fieldDataByte() const { return 0x90; }
 
         //Function: responseExpected
-		//
+        //
         //Returns:
         //    bool - True indicates that a response should return from the device.
         virtual bool responseExpected() const;
@@ -100,7 +100,7 @@ namespace mscl
         DeviceStatusData::StatusSelector m_statusSelector;
 
     public:
-	// Destructor
+    // Destructor
         ~DeviceStatus() { }
     };
 

MSCL/source/mscl/MicroStrain/Inertial/ExposedInertialTypes.cpp

@@ -689,62 +689,186 @@ namespace mscl
         return statusMap;
     }
 
-    RTKDeviceStatusFlags::ControllerState RTKDeviceStatusFlags::controllerState() const
+    RTKDeviceStatusFlags::RTKDeviceStatusFlags(const RTKDeviceStatusFlags_v1 rtk_v1) :
+        Bitfield(rtk_v1.value())
+    {}
+
+    RTKDeviceStatusFlags::operator RTKDeviceStatusFlags_v1() const
+    {
+        return RTKDeviceStatusFlags_v1(static_cast<uint32>(value()));
+    }
+
+    uint8 RTKDeviceStatusFlags::version() const
+    {
+        return static_cast<uint8>(get(VERSION));
+    }
+
+    RTKDeviceStatusFlags::ModemState RTKDeviceStatusFlags::modemState() const
+    {
+        return static_cast<ModemState>(get(MODEM_STATE));
+    }
+
+    void RTKDeviceStatusFlags::modemState(const ModemState state)
+    {
+        set(MODEM_STATE, state);
+    }
+
+    RTKDeviceStatusFlags::ConnectionType RTKDeviceStatusFlags::connectionType() const
+    {
+        return static_cast<ConnectionType>(get(CONNECTION_TYPE));
+    }
+
+    void RTKDeviceStatusFlags::connectionType(const ConnectionType state)
+    {
+        set(CONNECTION_TYPE, state);
+    }
+
+    int8 RTKDeviceStatusFlags::rssi() const
+    {
+        return -1 * static_cast<int8>(get(RSSI));
+    }
+
+    void RTKDeviceStatusFlags::rssi(const uint8 value)
+    {
+        set(RSSI, value);
+    }
+
+    uint8 RTKDeviceStatusFlags::signalQuality() const
+    {
+        return static_cast<uint8>(get(SIGNAL_QUALITY));
+    }
+
+    void RTKDeviceStatusFlags::signalQuality(const uint8 quality)
+    {
+        set(SIGNAL_QUALITY, quality);
+    }
+
+    uint8 RTKDeviceStatusFlags::towerChangeIndicator() const
+    {
+        return static_cast<uint8>(get(TOWER_CHANGE_INDICATOR));
+    }
+
+    void RTKDeviceStatusFlags::towerChangeIndicator(const uint8 value)
+    {
+        set(TOWER_CHANGE_INDICATOR, value);
+    }
+
+    uint8 RTKDeviceStatusFlags::nmeaTimeout() const
+    {
+        return static_cast<uint8>(get(NMEA_TIMEOUT));
+    }
+
+    void RTKDeviceStatusFlags::nmeaTimeout(const uint8 timeout)
+    {
+        set(NMEA_TIMEOUT, timeout);
+    }
+
+    uint8 RTKDeviceStatusFlags::serverTimeout() const
+    {
+        return static_cast<uint8>(get(SERVER_TIMEOUT));
+    }
+
+    void RTKDeviceStatusFlags::serverTimeout(const uint8 timeout)
+    {
+        set(SERVER_TIMEOUT, timeout);
+    }
+
+    uint8 RTKDeviceStatusFlags::rtcmTimeout() const
+    {
+        return static_cast<uint8>(get(RTCM_TIMEOUT));
+    }
+
+    void RTKDeviceStatusFlags::rtcmTimeout(const uint8 timeout)
+    {
+        set(RTCM_TIMEOUT, timeout);
+    }
+
+    uint8 RTKDeviceStatusFlags::deviceOutOfRange() const
+    {
+        return static_cast<uint8>(get(DEVICE_OUT_OF_RANGE));
+    }
+
+    void RTKDeviceStatusFlags::deviceOutOfRange(const uint8 outOfRange)
+    {
+        set(DEVICE_OUT_OF_RANGE, outOfRange);
+    }
+
+    uint8 RTKDeviceStatusFlags::correctionsUnavailable() const
+    {
+        return static_cast<uint8>(get(CORRECTIONS_UNAVAILABLE));
+    }
+
+    void RTKDeviceStatusFlags::correctionsUnavailable(const uint8 unavailable)
+    {
+        set(CORRECTIONS_UNAVAILABLE, unavailable);
+    }
+
+    RTKDeviceStatusFlags_v1::operator RTKDeviceStatusFlags() const
+    {
+        return RTKDeviceStatusFlags(static_cast<uint32>(value()));
+    }
+
+    uint8 RTKDeviceStatusFlags_v1::version() const
+    {
+        return static_cast<uint8>(get(VERSION));
+    }
+
+    RTKDeviceStatusFlags_v1::ControllerState RTKDeviceStatusFlags_v1::controllerState() const
     {
         return static_cast<ControllerState>(get(CONTROLLER_STATE));
     }
-    
-    void RTKDeviceStatusFlags::controllerState(RTKDeviceStatusFlags::ControllerState state)
+
+    void RTKDeviceStatusFlags_v1::controllerState(RTKDeviceStatusFlags_v1::ControllerState state)
     {
         set(CONTROLLER_STATE, state);
     }
 
-    RTKDeviceStatusFlags::PlatformState RTKDeviceStatusFlags::platformState() const
+    RTKDeviceStatusFlags_v1::PlatformState RTKDeviceStatusFlags_v1::platformState() const
     {
         return static_cast<PlatformState>(get(PLATFORM_STATE));
     }
 
-    void RTKDeviceStatusFlags::platformState(RTKDeviceStatusFlags::PlatformState state)
+    void RTKDeviceStatusFlags_v1::platformState(RTKDeviceStatusFlags_v1::PlatformState state)
     {
         set(PLATFORM_STATE, state);
     }
 
-    RTKDeviceStatusFlags::ControllerStatusCode RTKDeviceStatusFlags::controllerStatusCode() const
+    RTKDeviceStatusFlags_v1::ControllerStatusCode RTKDeviceStatusFlags_v1::controllerStatusCode() const
     {
         return static_cast<ControllerStatusCode>(get(CONTROLLER_STATUS_CODE));
     }
 
-    void RTKDeviceStatusFlags::controllerStatusCode(RTKDeviceStatusFlags::ControllerStatusCode status)
+    void RTKDeviceStatusFlags_v1::controllerStatusCode(RTKDeviceStatusFlags_v1::ControllerStatusCode status)
     {
         set(CONTROLLER_STATUS_CODE, status);
     }
 
-    RTKDeviceStatusFlags::PlatformStatusCode RTKDeviceStatusFlags::platformStatusCode() const
+    RTKDeviceStatusFlags_v1::PlatformStatusCode RTKDeviceStatusFlags_v1::platformStatusCode() const
     {
         return static_cast<PlatformStatusCode>(get(PLATFORM_STATUS_CODE));
     }
 
-    void RTKDeviceStatusFlags::platformStatusCode(RTKDeviceStatusFlags::PlatformStatusCode status)
+    void RTKDeviceStatusFlags_v1::platformStatusCode(RTKDeviceStatusFlags_v1::PlatformStatusCode status)
     {
         set(PLATFORM_STATUS_CODE, status);
     }
 
-    RTKDeviceStatusFlags::ResetReason RTKDeviceStatusFlags::resetReason() const
+    RTKDeviceStatusFlags_v1::ResetReason RTKDeviceStatusFlags_v1::resetReason() const
     {
         return static_cast<ResetReason>(get(RESET_REASON));
     }
 
-    void RTKDeviceStatusFlags::resetReason(RTKDeviceStatusFlags::ResetReason reason)
+    void RTKDeviceStatusFlags_v1::resetReason(RTKDeviceStatusFlags_v1::ResetReason reason)
     {
         set(RESET_REASON, static_cast<uint32>(reason));
     }
 
-    uint8 RTKDeviceStatusFlags::signalQuality() const
+    uint8 RTKDeviceStatusFlags_v1::signalQuality() const
     {
         return static_cast<uint8>(get(SIGNAL_QUALITY));
     }
 
-    void RTKDeviceStatusFlags::signalQuality(uint8 quality)
+    void RTKDeviceStatusFlags_v1::signalQuality(uint8 quality)
     {
         set(SIGNAL_QUALITY, quality);
     }