diff --git a/src/sfTk/sfDevXM125Core.cpp b/src/sfTk/sfDevXM125Core.cpp
index ea411a4..d185d42 100644
--- a/src/sfTk/sfDevXM125Core.cpp
+++ b/src/sfTk/sfDevXM125Core.cpp
@@ -31,6 +31,9 @@ sfTkError_t sfDevXM125Core::begin(sfTkII2C *theBus)
     // Sets communication bus
     _theBus = theBus;
 
+    // set the byte order to BIG Endian - the sensor works with Big E
+    _theBus->setByteOrder(sfTkByteOrder::BigEndian);
+
     // return the value of ping
     return theBus->ping();
 }
diff --git a/src/sfTk/sfDevXM125Distance.cpp b/src/sfTk/sfDevXM125Distance.cpp
index 4cbba66..b804f1b 100644
--- a/src/sfTk/sfDevXM125Distance.cpp
+++ b/src/sfTk/sfDevXM125Distance.cpp
@@ -170,7 +170,7 @@ sfTkError_t sfDevXM125Distance::getDistanceDetectorVersion(uint32_t &major, uint
 
     // Read from 16-Bit Register
     size_t readBytes = 0;
-    retVal = _theBus->readRegister16Region(SFE_XM125_DISTANCE_VERSION, (uint8_t *)&regVal, sizeof(uint32_t), readBytes);
+    retVal = _theBus->readRegister(SFE_XM125_DISTANCE_VERSION, (uint8_t *)&regVal, sizeof(uint32_t), readBytes);
     regVal = sftk_byte_swap(regVal);
 
     // Mask unused bits from register
@@ -186,8 +186,8 @@ sfTkError_t sfDevXM125Distance::getDistanceDetectorError(uint32_t &error)
 {
     // Read from 16-Bit Register
     size_t readBytes = 0;
-    sfTkError_t retVal = _theBus->readRegister16Region(SFE_XM125_DISTANCE_PROTOCOL_STATUS, (uint8_t *)&error,
-                                                       sizeof(uint32_t), readBytes);
+    sfTkError_t retVal =
+        _theBus->readRegister(SFE_XM125_DISTANCE_PROTOCOL_STATUS, (uint8_t *)&error, sizeof(uint32_t), readBytes);
     error = sftk_byte_swap(error);
     return retVal;
 }
@@ -198,8 +198,7 @@ sfTkError_t sfDevXM125Distance::getDistanceDetectorErrorStatus(uint32_t &status)
     sfTkError_t retVal;
     uint32_t regVal = 0;
     size_t readBytes = 0;
-    retVal = _theBus->readRegister16Region(SFE_XM125_DISTANCE_DETECTOR_STATUS, (uint8_t *)&regVal, sizeof(uint32_t),
-                                           readBytes);
+    retVal = _theBus->readRegister(SFE_XM125_DISTANCE_DETECTOR_STATUS, (uint8_t *)&regVal, sizeof(uint32_t), readBytes);
     regVal = sftk_byte_swap(regVal);
 
     // No error
@@ -257,8 +256,8 @@ sfTkError_t sfDevXM125Distance::getDistanceMeasureCounter(uint32_t &counter)
 {
     // Read from 16-Bit Register
     size_t readBytes = 0;
-    sfTkError_t retVal = _theBus->readRegister16Region(SFE_XM125_DISTANCE_MEASURE_COUNTER, (uint8_t *)&counter,
-                                                       sizeof(uint32_t), readBytes);
+    sfTkError_t retVal =
+        _theBus->readRegister(SFE_XM125_DISTANCE_MEASURE_COUNTER, (uint8_t *)&counter, sizeof(uint32_t), readBytes);
     counter = sftk_byte_swap(counter);
     return retVal;
 }
@@ -267,8 +266,8 @@ sfTkError_t sfDevXM125Distance::getDistanceMeasureCounter(uint32_t &counter)
 sfTkError_t sfDevXM125Distance::getDistanceDetectorStatus(uint32_t &status)
 {
     size_t readBytes = 0;
-    sfTkError_t retVal = _theBus->readRegister16Region(SFE_XM125_DISTANCE_DETECTOR_STATUS, (uint8_t *)&status,
-                                                       sizeof(uint32_t), readBytes);
+    sfTkError_t retVal =
+        _theBus->readRegister(SFE_XM125_DISTANCE_DETECTOR_STATUS, (uint8_t *)&status, sizeof(uint32_t), readBytes);
     status = sftk_byte_swap(status);
     return retVal;
 }
@@ -281,7 +280,7 @@ sfTkError_t sfDevXM125Distance::getDistanceNumberDistances(uint32_t &distance)
 
     // Read from 16-Bit Register
     size_t readBytes = 0;
-    retVal = _theBus->readRegister16Region(SFE_XM125_DISTANCE_RESULT, (uint8_t *)&regVal, sizeof(uint32_t), readBytes);
+    retVal = _theBus->readRegister(SFE_XM125_DISTANCE_RESULT, (uint8_t *)&regVal, sizeof(uint32_t), readBytes);
     regVal = sftk_byte_swap(regVal);
 
     // Mask unused bits from register
@@ -298,7 +297,7 @@ sfTkError_t sfDevXM125Distance::getDistanceNearStartEdge(uint32_t &edge)
 
     // Read from 16-Bit Register
     size_t readBytes = 0;
-    retVal = _theBus->readRegister16Region(SFE_XM125_DISTANCE_RESULT, (uint8_t *)&regVal, sizeof(uint32_t), readBytes);
+    retVal = _theBus->readRegister(SFE_XM125_DISTANCE_RESULT, (uint8_t *)&regVal, sizeof(uint32_t), readBytes);
     regVal = sftk_byte_swap(regVal);
 
     // Mask unused bits from register
@@ -315,7 +314,7 @@ sfTkError_t sfDevXM125Distance::getDistanceCalibrationNeeded(uint32_t &calibrate
 
     // Read from 16-Bit Register
     size_t readBytes = 0;
-    retVal = _theBus->readRegister16Region(SFE_XM125_DISTANCE_RESULT, (uint8_t *)&regVal, sizeof(uint32_t), readBytes);
+    retVal = _theBus->readRegister(SFE_XM125_DISTANCE_RESULT, (uint8_t *)&regVal, sizeof(uint32_t), readBytes);
     regVal = sftk_byte_swap(regVal);
 
     // Mask unused bits from register
@@ -333,7 +332,7 @@ sfTkError_t sfDevXM125Distance::getDistanceMeasureDistanceError(uint32_t &error)
 
     // Read from 16-Bit Register
     size_t readBytes = 0;
-    retVal = _theBus->readRegister16Region(SFE_XM125_DISTANCE_RESULT, (uint8_t *)&regVal, sizeof(uint32_t), readBytes);
+    retVal = _theBus->readRegister(SFE_XM125_DISTANCE_RESULT, (uint8_t *)&regVal, sizeof(uint32_t), readBytes);
     regVal = sftk_byte_swap(regVal);
 
     // Mask unused bits from register
@@ -351,7 +350,7 @@ sfTkError_t sfDevXM125Distance::getDistanceTemperature(int16_t &temperature)
 
     // Read from 16-Bit Register
     size_t readBytes = 0;
-    retVal = _theBus->readRegister16Region(SFE_XM125_DISTANCE_RESULT, (uint8_t *)&regVal, sizeof(uint32_t), readBytes);
+    retVal = _theBus->readRegister(SFE_XM125_DISTANCE_RESULT, (uint8_t *)&regVal, sizeof(uint32_t), readBytes);
     if (retVal != ksfTkErrOk)
         return retVal;
 
@@ -369,7 +368,7 @@ sfTkError_t sfDevXM125Distance::getDistancePeak0Distance(uint32_t &peak)
 {
     size_t readBytes = 0;
     sfTkError_t retVal =
-        _theBus->readRegister16Region(SFE_XM125_DISTANCE_PEAK0_DISTANCE, (uint8_t *)&peak, sizeof(uint32_t), readBytes);
+        _theBus->readRegister(SFE_XM125_DISTANCE_PEAK0_DISTANCE, (uint8_t *)&peak, sizeof(uint32_t), readBytes);
     peak = sftk_byte_swap(peak);
     return retVal;
 }
@@ -379,7 +378,7 @@ sfTkError_t sfDevXM125Distance::getDistancePeak1Distance(uint32_t &peak)
 {
     size_t readBytes = 0;
     sfTkError_t retVal =
-        _theBus->readRegister16Region(SFE_XM125_DISTANCE_PEAK1_DISTANCE, (uint8_t *)&peak, sizeof(uint32_t), readBytes);
+        _theBus->readRegister(SFE_XM125_DISTANCE_PEAK1_DISTANCE, (uint8_t *)&peak, sizeof(uint32_t), readBytes);
     peak = sftk_byte_swap(peak);
     return retVal;
 }
@@ -389,7 +388,7 @@ sfTkError_t sfDevXM125Distance::getDistancePeak2Distance(uint32_t &peak)
 {
     size_t readBytes = 0;
     sfTkError_t retVal =
-        _theBus->readRegister16Region(SFE_XM125_DISTANCE_PEAK2_DISTANCE, (uint8_t *)&peak, sizeof(uint32_t), readBytes);
+        _theBus->readRegister(SFE_XM125_DISTANCE_PEAK2_DISTANCE, (uint8_t *)&peak, sizeof(uint32_t), readBytes);
     peak = sftk_byte_swap(peak);
     return retVal;
 }
@@ -399,7 +398,7 @@ sfTkError_t sfDevXM125Distance::getDistancePeak3Distance(uint32_t &peak)
 {
     size_t readBytes = 0;
     sfTkError_t retVal =
-        _theBus->readRegister16Region(SFE_XM125_DISTANCE_PEAK3_DISTANCE, (uint8_t *)&peak, sizeof(uint32_t), readBytes);
+        _theBus->readRegister(SFE_XM125_DISTANCE_PEAK3_DISTANCE, (uint8_t *)&peak, sizeof(uint32_t), readBytes);
     peak = sftk_byte_swap(peak);
     return retVal;
 }
@@ -409,7 +408,7 @@ sfTkError_t sfDevXM125Distance::getDistancePeak4Distance(uint32_t &peak)
 {
     size_t readBytes = 0;
     sfTkError_t retVal =
-        _theBus->readRegister16Region(SFE_XM125_DISTANCE_PEAK4_DISTANCE, (uint8_t *)&peak, sizeof(uint32_t), readBytes);
+        _theBus->readRegister(SFE_XM125_DISTANCE_PEAK4_DISTANCE, (uint8_t *)&peak, sizeof(uint32_t), readBytes);
     peak = sftk_byte_swap(peak);
     return retVal;
 }
@@ -419,7 +418,7 @@ sfTkError_t sfDevXM125Distance::getDistancePeak5Distance(uint32_t &peak)
 {
     size_t readBytes = 0;
     sfTkError_t retVal =
-        _theBus->readRegister16Region(SFE_XM125_DISTANCE_PEAK5_DISTANCE, (uint8_t *)&peak, sizeof(uint32_t), readBytes);
+        _theBus->readRegister(SFE_XM125_DISTANCE_PEAK5_DISTANCE, (uint8_t *)&peak, sizeof(uint32_t), readBytes);
     peak = sftk_byte_swap(peak);
     return retVal;
 }
@@ -429,7 +428,7 @@ sfTkError_t sfDevXM125Distance::getDistancePeak6Distance(uint32_t &peak)
 {
     size_t readBytes = 0;
     sfTkError_t retVal =
-        _theBus->readRegister16Region(SFE_XM125_DISTANCE_PEAK6_DISTANCE, (uint8_t *)&peak, sizeof(uint32_t), readBytes);
+        _theBus->readRegister(SFE_XM125_DISTANCE_PEAK6_DISTANCE, (uint8_t *)&peak, sizeof(uint32_t), readBytes);
     peak = sftk_byte_swap(peak);
     return retVal;
 }
@@ -439,7 +438,7 @@ sfTkError_t sfDevXM125Distance::getDistancePeak7Distance(uint32_t &peak)
 {
     size_t readBytes = 0;
     sfTkError_t retVal =
-        _theBus->readRegister16Region(SFE_XM125_DISTANCE_PEAK7_DISTANCE, (uint8_t *)&peak, sizeof(uint32_t), readBytes);
+        _theBus->readRegister(SFE_XM125_DISTANCE_PEAK7_DISTANCE, (uint8_t *)&peak, sizeof(uint32_t), readBytes);
     peak = sftk_byte_swap(peak);
     return retVal;
 }
@@ -449,7 +448,7 @@ sfTkError_t sfDevXM125Distance::getDistancePeak8Distance(uint32_t &peak)
 {
     size_t readBytes = 0;
     sfTkError_t retVal =
-        _theBus->readRegister16Region(SFE_XM125_DISTANCE_PEAK8_DISTANCE, (uint8_t *)&peak, sizeof(uint32_t), readBytes);
+        _theBus->readRegister(SFE_XM125_DISTANCE_PEAK8_DISTANCE, (uint8_t *)&peak, sizeof(uint32_t), readBytes);
     peak = sftk_byte_swap(peak);
     return retVal;
 }
@@ -459,7 +458,7 @@ sfTkError_t sfDevXM125Distance::getDistancePeak9Distance(uint32_t &peak)
 {
     size_t readBytes = 0;
     sfTkError_t retVal =
-        _theBus->readRegister16Region(SFE_XM125_DISTANCE_PEAK9_DISTANCE, (uint8_t *)&peak, sizeof(uint32_t), readBytes);
+        _theBus->readRegister(SFE_XM125_DISTANCE_PEAK9_DISTANCE, (uint8_t *)&peak, sizeof(uint32_t), readBytes);
     peak = sftk_byte_swap(peak);
     return retVal;
 }
@@ -469,7 +468,7 @@ sfTkError_t sfDevXM125Distance::getDistancePeak0Strength(int32_t &peak)
 {
     size_t readBytes = 0;
     sfTkError_t retVal =
-        _theBus->readRegister16Region(SFE_XM125_DISTANCE_PEAK0_STRENGTH, (uint8_t *)&peak, sizeof(int32_t), readBytes);
+        _theBus->readRegister(SFE_XM125_DISTANCE_PEAK0_STRENGTH, (uint8_t *)&peak, sizeof(int32_t), readBytes);
     peak = sftk_byte_swap(peak);
 
     return retVal;
@@ -480,7 +479,7 @@ sfTkError_t sfDevXM125Distance::getDistancePeak1Strength(int32_t &peak)
 {
     size_t readBytes = 0;
     sfTkError_t retVal =
-        _theBus->readRegister16Region(SFE_XM125_DISTANCE_PEAK1_STRENGTH, (uint8_t *)&peak, sizeof(int32_t), readBytes);
+        _theBus->readRegister(SFE_XM125_DISTANCE_PEAK1_STRENGTH, (uint8_t *)&peak, sizeof(int32_t), readBytes);
     peak = sftk_byte_swap(peak);
 
     return retVal;
@@ -491,7 +490,7 @@ sfTkError_t sfDevXM125Distance::getDistancePeak2Strength(int32_t &peak)
 {
     size_t readBytes = 0;
     sfTkError_t retVal =
-        _theBus->readRegister16Region(SFE_XM125_DISTANCE_PEAK2_STRENGTH, (uint8_t *)&peak, sizeof(int32_t), readBytes);
+        _theBus->readRegister(SFE_XM125_DISTANCE_PEAK2_STRENGTH, (uint8_t *)&peak, sizeof(int32_t), readBytes);
     peak = sftk_byte_swap(peak);
 
     return retVal;
@@ -502,7 +501,7 @@ sfTkError_t sfDevXM125Distance::getDistancePeak3Strength(int32_t &peak)
 {
     size_t readBytes = 0;
     sfTkError_t retVal =
-        _theBus->readRegister16Region(SFE_XM125_DISTANCE_PEAK3_STRENGTH, (uint8_t *)&peak, sizeof(int32_t), readBytes);
+        _theBus->readRegister(SFE_XM125_DISTANCE_PEAK3_STRENGTH, (uint8_t *)&peak, sizeof(int32_t), readBytes);
     peak = sftk_byte_swap(peak);
 
     return retVal;
@@ -513,7 +512,7 @@ sfTkError_t sfDevXM125Distance::getDistancePeak4Strength(int32_t &peak)
 {
     size_t readBytes = 0;
     sfTkError_t retVal =
-        _theBus->readRegister16Region(SFE_XM125_DISTANCE_PEAK4_STRENGTH, (uint8_t *)&peak, sizeof(int32_t), readBytes);
+        _theBus->readRegister(SFE_XM125_DISTANCE_PEAK4_STRENGTH, (uint8_t *)&peak, sizeof(int32_t), readBytes);
     peak = sftk_byte_swap(peak);
 
     return retVal;
@@ -524,7 +523,7 @@ sfTkError_t sfDevXM125Distance::getDistancePeak5Strength(int32_t &peak)
 {
     size_t readBytes = 0;
     sfTkError_t retVal =
-        _theBus->readRegister16Region(SFE_XM125_DISTANCE_PEAK5_STRENGTH, (uint8_t *)&peak, sizeof(int32_t), readBytes);
+        _theBus->readRegister(SFE_XM125_DISTANCE_PEAK5_STRENGTH, (uint8_t *)&peak, sizeof(int32_t), readBytes);
     peak = sftk_byte_swap(peak);
 
     return retVal;
@@ -535,7 +534,7 @@ sfTkError_t sfDevXM125Distance::getDistancePeak6Strength(int32_t &peak)
 {
     size_t readBytes = 0;
     sfTkError_t retVal =
-        _theBus->readRegister16Region(SFE_XM125_DISTANCE_PEAK6_STRENGTH, (uint8_t *)&peak, sizeof(int32_t), readBytes);
+        _theBus->readRegister(SFE_XM125_DISTANCE_PEAK6_STRENGTH, (uint8_t *)&peak, sizeof(int32_t), readBytes);
     peak = sftk_byte_swap(peak);
 
     return retVal;
@@ -546,7 +545,7 @@ sfTkError_t sfDevXM125Distance::getDistancePeak7Strength(int32_t &peak)
 {
     size_t readBytes = 0;
     sfTkError_t retVal =
-        _theBus->readRegister16Region(SFE_XM125_DISTANCE_PEAK7_STRENGTH, (uint8_t *)&peak, sizeof(int32_t), readBytes);
+        _theBus->readRegister(SFE_XM125_DISTANCE_PEAK7_STRENGTH, (uint8_t *)&peak, sizeof(int32_t), readBytes);
     peak = sftk_byte_swap(peak);
 
     return retVal;
@@ -557,7 +556,7 @@ sfTkError_t sfDevXM125Distance::getDistancePeak8Strength(int32_t &peak)
 {
     size_t readBytes = 0;
     sfTkError_t retVal =
-        _theBus->readRegister16Region(SFE_XM125_DISTANCE_PEAK8_STRENGTH, (uint8_t *)&peak, sizeof(int32_t), readBytes);
+        _theBus->readRegister(SFE_XM125_DISTANCE_PEAK8_STRENGTH, (uint8_t *)&peak, sizeof(int32_t), readBytes);
     peak = sftk_byte_swap(peak);
 
     return retVal;
@@ -568,7 +567,7 @@ sfTkError_t sfDevXM125Distance::getDistancePeak9Strength(int32_t &peak)
 {
     size_t readBytes = 0;
     sfTkError_t retVal =
-        _theBus->readRegister16Region(SFE_XM125_DISTANCE_PEAK9_STRENGTH, (uint8_t *)&peak, sizeof(int32_t), readBytes);
+        _theBus->readRegister(SFE_XM125_DISTANCE_PEAK9_STRENGTH, (uint8_t *)&peak, sizeof(int32_t), readBytes);
     peak = sftk_byte_swap(peak);
 
     return retVal;
@@ -579,7 +578,7 @@ sfTkError_t sfDevXM125Distance::getDistanceStart(uint32_t &startVal)
 {
     size_t readBytes = 0;
     sfTkError_t retVal =
-        _theBus->readRegister16Region(SFE_XM125_DISTANCE_START, (uint8_t *)&startVal, sizeof(uint32_t), readBytes);
+        _theBus->readRegister(SFE_XM125_DISTANCE_START, (uint8_t *)&startVal, sizeof(uint32_t), readBytes);
     startVal = sftk_byte_swap(startVal);
     return retVal;
 }
@@ -588,15 +587,14 @@ sfTkError_t sfDevXM125Distance::getDistanceStart(uint32_t &startVal)
 sfTkError_t sfDevXM125Distance::setDistanceStart(uint32_t start)
 {
     start = sftk_byte_swap(start);
-    return _theBus->writeRegister16Region(SFE_XM125_DISTANCE_START, (uint8_t *)&start, sizeof(uint32_t));
+    return _theBus->writeRegister(SFE_XM125_DISTANCE_START, (uint8_t *)&start, sizeof(uint32_t));
 }
 
 //--------------------------------------------------------------------------------
 sfTkError_t sfDevXM125Distance::getDistanceEnd(uint32_t &end)
 {
     size_t readBytes = 0;
-    sfTkError_t retVal =
-        _theBus->readRegister16Region(SFE_XM125_DISTANCE_END, (uint8_t *)&end, sizeof(uint32_t), readBytes);
+    sfTkError_t retVal = _theBus->readRegister(SFE_XM125_DISTANCE_END, (uint8_t *)&end, sizeof(uint32_t), readBytes);
     end = sftk_byte_swap(end);
     return retVal;
 }
@@ -605,15 +603,15 @@ sfTkError_t sfDevXM125Distance::getDistanceEnd(uint32_t &end)
 sfTkError_t sfDevXM125Distance::setDistanceEnd(uint32_t end)
 {
     end = sftk_byte_swap(end);
-    return _theBus->writeRegister16Region(SFE_XM125_DISTANCE_END, (uint8_t *)&end, sizeof(uint32_t));
+    return _theBus->writeRegister(SFE_XM125_DISTANCE_END, (uint8_t *)&end, sizeof(uint32_t));
 }
 
 //--------------------------------------------------------------------------------
 sfTkError_t sfDevXM125Distance::getDistanceMaxStepLength(uint32_t &length)
 {
     size_t readBytes = 0;
-    sfTkError_t retVal = _theBus->readRegister16Region(SFE_XM125_DISTANCE_MAX_STEP_LENGTH, (uint8_t *)&length,
-                                                       sizeof(uint32_t), readBytes);
+    sfTkError_t retVal =
+        _theBus->readRegister(SFE_XM125_DISTANCE_MAX_STEP_LENGTH, (uint8_t *)&length, sizeof(uint32_t), readBytes);
     length = sftk_byte_swap(length);
     return retVal;
 }
@@ -622,7 +620,7 @@ sfTkError_t sfDevXM125Distance::getDistanceMaxStepLength(uint32_t &length)
 sfTkError_t sfDevXM125Distance::setDistanceMaxStepLength(uint32_t length)
 {
     length = sftk_byte_swap(length);
-    return _theBus->writeRegister16Region(SFE_XM125_DISTANCE_MAX_STEP_LENGTH, (uint8_t *)&length, sizeof(uint32_t));
+    return _theBus->writeRegister(SFE_XM125_DISTANCE_MAX_STEP_LENGTH, (uint8_t *)&length, sizeof(uint32_t));
 }
 
 //--------------------------------------------------------------------------------
@@ -630,8 +628,8 @@ sfTkError_t sfDevXM125Distance::getDistanceCloseRangeLeakageCancellation(bool &r
 {
     size_t readBytes = 0;
     uint8_t readVal = 0;
-    sfTkError_t retVal = _theBus->readRegister16Region(SFE_XM125_DISTANCE_CLOSE_RANGE_LEAKAGE, (uint8_t *)&readVal,
-                                                       sizeof(uint8_t), readBytes);
+    sfTkError_t retVal =
+        _theBus->readRegister(SFE_XM125_DISTANCE_CLOSE_RANGE_LEAKAGE, (uint8_t *)&readVal, sizeof(uint8_t), readBytes);
     if (retVal != ksfTkErrOk)
         return retVal;
 
@@ -643,15 +641,15 @@ sfTkError_t sfDevXM125Distance::getDistanceCloseRangeLeakageCancellation(bool &r
 sfTkError_t sfDevXM125Distance::setDistanceCloseRangeLeakageCancellation(bool range)
 {
     uint8_t value = range ? 1 : 0;
-    return _theBus->writeRegister16Region(SFE_XM125_DISTANCE_CLOSE_RANGE_LEAKAGE, &value, sizeof(value));
+    return _theBus->writeRegister(SFE_XM125_DISTANCE_CLOSE_RANGE_LEAKAGE, &value, sizeof(value));
 }
 
 //--------------------------------------------------------------------------------
 sfTkError_t sfDevXM125Distance::getDistanceSignalQuality(uint32_t &signal)
 {
     size_t readBytes = 0;
-    sfTkError_t retVal = _theBus->readRegister16Region(SFE_XM125_DISTANCE_SIGNAL_QUALITY, (uint8_t *)&signal,
-                                                       sizeof(uint32_t), readBytes);
+    sfTkError_t retVal =
+        _theBus->readRegister(SFE_XM125_DISTANCE_SIGNAL_QUALITY, (uint8_t *)&signal, sizeof(uint32_t), readBytes);
     signal = sftk_byte_swap(signal);
     return retVal;
 }
@@ -660,7 +658,7 @@ sfTkError_t sfDevXM125Distance::getDistanceSignalQuality(uint32_t &signal)
 sfTkError_t sfDevXM125Distance::setDistanceSignalQuality(uint32_t signal)
 {
     signal = sftk_byte_swap(signal);
-    return _theBus->writeRegister16Region(SFE_XM125_DISTANCE_SIGNAL_QUALITY, (uint8_t *)&signal, sizeof(uint32_t));
+    return _theBus->writeRegister(SFE_XM125_DISTANCE_SIGNAL_QUALITY, (uint8_t *)&signal, sizeof(uint32_t));
 }
 
 //--------------------------------------------------------------------------------
@@ -668,7 +666,7 @@ sfTkError_t sfDevXM125Distance::getDistanceMaxProfile(uint32_t &profile)
 {
     size_t readBytes = 0;
     sfTkError_t retVal =
-        _theBus->readRegister16Region(SFE_XM125_DISTANCE_MAX_PROFILE, (uint8_t *)&profile, sizeof(uint32_t), readBytes);
+        _theBus->readRegister(SFE_XM125_DISTANCE_MAX_PROFILE, (uint8_t *)&profile, sizeof(uint32_t), readBytes);
     profile = sftk_byte_swap(profile);
     return retVal;
 }
@@ -677,15 +675,15 @@ sfTkError_t sfDevXM125Distance::getDistanceMaxProfile(uint32_t &profile)
 sfTkError_t sfDevXM125Distance::setDistanceMaxProfile(uint32_t profile)
 {
     profile = sftk_byte_swap(profile);
-    return _theBus->writeRegister16Region(SFE_XM125_DISTANCE_MAX_PROFILE, (uint8_t *)&profile, sizeof(uint32_t));
+    return _theBus->writeRegister(SFE_XM125_DISTANCE_MAX_PROFILE, (uint8_t *)&profile, sizeof(uint32_t));
 }
 
 //--------------------------------------------------------------------------------
 sfTkError_t sfDevXM125Distance::getDistanceThresholdMethod(uint32_t &method)
 {
     size_t readBytes = 0;
-    sfTkError_t retVal = _theBus->readRegister16Region(SFE_XM125_DISTANCE_THRESHOLD_METHOD, (uint8_t *)&method,
-                                                       sizeof(uint32_t), readBytes);
+    sfTkError_t retVal =
+        _theBus->readRegister(SFE_XM125_DISTANCE_THRESHOLD_METHOD, (uint8_t *)&method, sizeof(uint32_t), readBytes);
     method = sftk_byte_swap(method);
     return retVal;
 }
@@ -694,7 +692,7 @@ sfTkError_t sfDevXM125Distance::getDistanceThresholdMethod(uint32_t &method)
 sfTkError_t sfDevXM125Distance::setDistanceThresholdMethod(uint32_t method)
 {
     method = sftk_byte_swap(method);
-    return _theBus->writeRegister16Region(SFE_XM125_DISTANCE_THRESHOLD_METHOD, (uint8_t *)&method, sizeof(uint32_t));
+    return _theBus->writeRegister(SFE_XM125_DISTANCE_THRESHOLD_METHOD, (uint8_t *)&method, sizeof(uint32_t));
 }
 
 //--------------------------------------------------------------------------------
@@ -702,7 +700,7 @@ sfTkError_t sfDevXM125Distance::getDistancePeakSorting(uint32_t &peak)
 {
     size_t readBytes = 0;
     sfTkError_t retVal =
-        _theBus->readRegister16Region(SFE_XM125_DISTANCE_PEAK_SORTING, (uint8_t *)&peak, sizeof(uint32_t), readBytes);
+        _theBus->readRegister(SFE_XM125_DISTANCE_PEAK_SORTING, (uint8_t *)&peak, sizeof(uint32_t), readBytes);
     peak = sftk_byte_swap(peak);
     return retVal;
 }
@@ -711,15 +709,15 @@ sfTkError_t sfDevXM125Distance::getDistancePeakSorting(uint32_t &peak)
 sfTkError_t sfDevXM125Distance::setDistancePeakSorting(uint32_t peak)
 {
     peak = sftk_byte_swap(peak);
-    return _theBus->writeRegister16Region(SFE_XM125_DISTANCE_PEAK_SORTING, (uint8_t *)&peak, sizeof(uint32_t));
+    return _theBus->writeRegister(SFE_XM125_DISTANCE_PEAK_SORTING, (uint8_t *)&peak, sizeof(uint32_t));
 }
 
 //--------------------------------------------------------------------------------
 sfTkError_t sfDevXM125Distance::getDistanceNumFramesRecordedThreshold(uint32_t &thresh)
 {
     size_t readBytes = 0;
-    sfTkError_t retVal = _theBus->readRegister16Region(SFE_XM125_DISTANCE_NUM_FRAMES_RECORDED_THRESH,
-                                                       (uint8_t *)&thresh, sizeof(uint32_t), readBytes);
+    sfTkError_t retVal = _theBus->readRegister(SFE_XM125_DISTANCE_NUM_FRAMES_RECORDED_THRESH, (uint8_t *)&thresh,
+                                               sizeof(uint32_t), readBytes);
     thresh = sftk_byte_swap(thresh);
     return retVal;
 }
@@ -728,16 +726,15 @@ sfTkError_t sfDevXM125Distance::getDistanceNumFramesRecordedThreshold(uint32_t &
 sfTkError_t sfDevXM125Distance::setDistanceNumFramesRecordedThreshold(uint32_t thresh)
 {
     thresh = sftk_byte_swap(thresh);
-    return _theBus->writeRegister16Region(SFE_XM125_DISTANCE_NUM_FRAMES_RECORDED_THRESH, (uint8_t *)&thresh,
-                                          sizeof(uint32_t));
+    return _theBus->writeRegister(SFE_XM125_DISTANCE_NUM_FRAMES_RECORDED_THRESH, (uint8_t *)&thresh, sizeof(uint32_t));
 }
 
 //--------------------------------------------------------------------------------
 sfTkError_t sfDevXM125Distance::getDistanceFixedAmpThreshold(uint32_t &thresh)
 {
     size_t readBytes = 0;
-    sfTkError_t retVal = _theBus->readRegister16Region(SFE_XM125_DISTANCE_FIXED_AMPLITUDE_THRESHOLD_VAL,
-                                                       (uint8_t *)&thresh, sizeof(uint32_t), readBytes);
+    sfTkError_t retVal = _theBus->readRegister(SFE_XM125_DISTANCE_FIXED_AMPLITUDE_THRESHOLD_VAL, (uint8_t *)&thresh,
+                                               sizeof(uint32_t), readBytes);
     thresh = sftk_byte_swap(thresh);
     return retVal;
 }
@@ -746,16 +743,16 @@ sfTkError_t sfDevXM125Distance::getDistanceFixedAmpThreshold(uint32_t &thresh)
 sfTkError_t sfDevXM125Distance::setDistanceFixedAmpThreshold(uint32_t thresh)
 {
     thresh = sftk_byte_swap(thresh);
-    return _theBus->writeRegister16Region(SFE_XM125_DISTANCE_FIXED_AMPLITUDE_THRESHOLD_VAL, (uint8_t *)&thresh,
-                                          sizeof(uint32_t));
+    return _theBus->writeRegister(SFE_XM125_DISTANCE_FIXED_AMPLITUDE_THRESHOLD_VAL, (uint8_t *)&thresh,
+                                  sizeof(uint32_t));
 }
 
 //--------------------------------------------------------------------------------
 sfTkError_t sfDevXM125Distance::getDistanceThresholdSensitivity(uint32_t &thresh)
 {
     size_t readBytes = 0;
-    sfTkError_t retVal = _theBus->readRegister16Region(SFE_XM125_DISTANCE_THREHSOLD_SENSITIVITY, (uint8_t *)&thresh,
-                                                       sizeof(uint32_t), readBytes);
+    sfTkError_t retVal = _theBus->readRegister(SFE_XM125_DISTANCE_THREHSOLD_SENSITIVITY, (uint8_t *)&thresh,
+                                               sizeof(uint32_t), readBytes);
     thresh = sftk_byte_swap(thresh);
     return retVal;
 }
@@ -764,16 +761,15 @@ sfTkError_t sfDevXM125Distance::getDistanceThresholdSensitivity(uint32_t &thresh
 sfTkError_t sfDevXM125Distance::setDistanceThresholdSensitivity(uint32_t thresh)
 {
     thresh = sftk_byte_swap(thresh);
-    return _theBus->writeRegister16Region(SFE_XM125_DISTANCE_THREHSOLD_SENSITIVITY, (uint8_t *)&thresh,
-                                          sizeof(uint32_t));
+    return _theBus->writeRegister(SFE_XM125_DISTANCE_THREHSOLD_SENSITIVITY, (uint8_t *)&thresh, sizeof(uint32_t));
 }
 
 //--------------------------------------------------------------------------------
 sfTkError_t sfDevXM125Distance::getDistanceReflectorShape(uint32_t &shape)
 {
     size_t readBytes = 0;
-    sfTkError_t retVal = _theBus->readRegister16Region(SFE_XM125_DISTANCE_REFLECTOR_SHAPE, (uint8_t *)&shape,
-                                                       sizeof(uint32_t), readBytes);
+    sfTkError_t retVal =
+        _theBus->readRegister(SFE_XM125_DISTANCE_REFLECTOR_SHAPE, (uint8_t *)&shape, sizeof(uint32_t), readBytes);
     shape = sftk_byte_swap(shape);
     return retVal;
 }
@@ -782,15 +778,15 @@ sfTkError_t sfDevXM125Distance::getDistanceReflectorShape(uint32_t &shape)
 sfTkError_t sfDevXM125Distance::setDistanceReflectorShape(uint32_t shape)
 {
     shape = sftk_byte_swap(shape);
-    return _theBus->writeRegister16Region(SFE_XM125_DISTANCE_REFLECTOR_SHAPE, (uint8_t *)&shape, sizeof(uint32_t));
+    return _theBus->writeRegister(SFE_XM125_DISTANCE_REFLECTOR_SHAPE, (uint8_t *)&shape, sizeof(uint32_t));
 }
 
 //--------------------------------------------------------------------------------
 sfTkError_t sfDevXM125Distance::getDistanceFixedStrengthThresholdValue(int32_t &thresh)
 {
     size_t readBytes = 0;
-    sfTkError_t retVal = _theBus->readRegister16Region(SFE_XM125_DISTANCE_FIXED_STRENGTH_THRESHOLD_VAL,
-                                                       (uint8_t *)&thresh, sizeof(uint32_t), readBytes);
+    sfTkError_t retVal = _theBus->readRegister(SFE_XM125_DISTANCE_FIXED_STRENGTH_THRESHOLD_VAL, (uint8_t *)&thresh,
+                                               sizeof(uint32_t), readBytes);
     thresh = sftk_byte_swap(thresh);
     return retVal;
 }
@@ -799,8 +795,7 @@ sfTkError_t sfDevXM125Distance::getDistanceFixedStrengthThresholdValue(int32_t &
 sfTkError_t sfDevXM125Distance::setDistanceFixedStrengthThresholdValue(int32_t thresh)
 {
     thresh = sftk_byte_swap(thresh);
-    return _theBus->writeRegister16Region(SFE_XM125_DISTANCE_FIXED_STRENGTH_THRESHOLD_VAL, (uint8_t *)&thresh,
-                                          sizeof(int32_t));
+    return _theBus->writeRegister(SFE_XM125_DISTANCE_FIXED_STRENGTH_THRESHOLD_VAL, (uint8_t *)&thresh, sizeof(int32_t));
 }
 
 //--------------------------------------------------------------------------------
@@ -808,8 +803,8 @@ sfTkError_t sfDevXM125Distance::getDistanceMeasureOneWakeup(bool &measure)
 {
     size_t readBytes = 0;
     uint8_t value;
-    sfTkError_t retVal = _theBus->readRegister16Region(SFE_XM125_DISTANCE_MEASURE_ON_WAKEUP, (uint8_t *)&value,
-                                                       sizeof(uint8_t), readBytes);
+    sfTkError_t retVal =
+        _theBus->readRegister(SFE_XM125_DISTANCE_MEASURE_ON_WAKEUP, (uint8_t *)&value, sizeof(uint8_t), readBytes);
     measure = static_cast<bool>(value);
     return retVal;
 }
@@ -818,14 +813,14 @@ sfTkError_t sfDevXM125Distance::getDistanceMeasureOneWakeup(bool &measure)
 sfTkError_t sfDevXM125Distance::setDistanceMeasureOneWakeup(bool measure)
 {
     uint8_t value = static_cast<uint8_t>(measure);
-    return _theBus->writeRegister16Region(SFE_XM125_DISTANCE_MEASURE_ON_WAKEUP, (uint8_t *)&value, sizeof(uint8_t));
+    return _theBus->writeRegister(SFE_XM125_DISTANCE_MEASURE_ON_WAKEUP, (uint8_t *)&value, sizeof(uint8_t));
 }
 
 //--------------------------------------------------------------------------------
 sfTkError_t sfDevXM125Distance::setDistanceCommand(uint32_t command)
 {
     command = sftk_byte_swap(command);
-    return _theBus->writeRegister16Region(SFE_XM125_DISTANCE_COMMAND, (uint8_t *)&command, sizeof(uint32_t));
+    return _theBus->writeRegister(SFE_XM125_DISTANCE_COMMAND, (uint8_t *)&command, sizeof(uint32_t));
 }
 
 //--------------------------------------------------------------------------------
@@ -889,15 +884,14 @@ sfTkError_t sfDevXM125Distance::distanceBusyWait()
     uint32_t regVal = 0;
 
     size_t readBytes = 0;
-    retVal = _theBus->readRegister16Region(SFE_XM125_DISTANCE_DETECTOR_STATUS, (uint8_t *)&regVal, sizeof(uint32_t),
-                                           readBytes);
+    retVal = _theBus->readRegister(SFE_XM125_DISTANCE_DETECTOR_STATUS, (uint8_t *)&regVal, sizeof(uint32_t), readBytes);
     regVal = sftk_byte_swap(regVal);
 
     // Poll Detector Status until Busy bit is cleared
     while (((regVal & SFE_XM125_DISTANCE_DETECTOR_STATUS_MASK) >> SFE_XM125_DISTANCE_DETECTOR_STATUS_MASK_SHIFT) != 0)
     {
-        retVal = _theBus->readRegister16Region(SFE_XM125_DISTANCE_DETECTOR_STATUS, (uint8_t *)&regVal, sizeof(uint32_t),
-                                               readBytes);
+        retVal =
+            _theBus->readRegister(SFE_XM125_DISTANCE_DETECTOR_STATUS, (uint8_t *)&regVal, sizeof(uint32_t), readBytes);
         regVal = sftk_byte_swap(regVal);
     }
 
diff --git a/src/sfTk/sfDevXM125Presence.cpp b/src/sfTk/sfDevXM125Presence.cpp
index 05ce8e1..56db165 100644
--- a/src/sfTk/sfDevXM125Presence.cpp
+++ b/src/sfTk/sfDevXM125Presence.cpp
@@ -10,7 +10,6 @@
  *
  * SPDX-License-Identifier: MIT
  */
-
 #include "sfDevXM125Presence.h"
 
 sfTkError_t sfDevXM125Presence::begin(sfTkII2C *theBus)
@@ -134,7 +133,7 @@ sfTkError_t sfDevXM125Presence::getPresenceDetectorVersion(uint32_t &major, uint
 
     // Read from 16-Bit Register
     size_t readBytes = 0;
-    retVal = _theBus->readRegister16Region(SFE_XM125_PRESENCE_VERSION, (uint8_t *)&regVal, sizeof(regVal), readBytes);
+    retVal = _theBus->readRegister(SFE_XM125_PRESENCE_VERSION, (uint8_t *)&regVal, sizeof(regVal), readBytes);
 
     // Mask unused bits from register
     major = (regVal & SFE_XM125_PRESENCE_MAJOR_VERSION_MASK) >> SFE_XM125_PRESENCE_MAJOR_VERSION_MASK_SHIFT;
@@ -146,33 +145,24 @@ sfTkError_t sfDevXM125Presence::getPresenceDetectorVersion(uint32_t &major, uint
 //--------------------------------------------------------------------------------
 sfTkError_t sfDevXM125Presence::getPresenceDetectorError(uint32_t &error)
 {
-    size_t readBytes = 0;
-    return _theBus->readRegister16Region(SFE_XM125_PRESENCE_PROTOCOL_STATUS, (uint8_t *)&error, sizeof(uint32_t),
-                                         readBytes);
+    return _theBus->readRegister(SFE_XM125_PRESENCE_PROTOCOL_STATUS, error);
 }
 //--------------------------------------------------------------------------------
 sfTkError_t sfDevXM125Presence::getPresenceMeasureCounter(uint32_t &counter)
 {
-    size_t readBytes = 0;
-    return _theBus->readRegister16Region(SFE_XM125_PRESENCE_MEASURE_COUNTER, (uint8_t *)&counter, sizeof(uint32_t),
-                                         readBytes);
+    return _theBus->readRegister(SFE_XM125_PRESENCE_MEASURE_COUNTER, counter);
 }
 //--------------------------------------------------------------------------------
 sfTkError_t sfDevXM125Presence::getPresenceDetectorStatus(uint32_t &status)
 {
-    size_t readBytes = 0;
-    return _theBus->readRegister16Region(SFE_XM125_PRESENCE_DETECTOR_STATUS, (uint8_t *)&status, sizeof(uint32_t),
-                                         readBytes);
+    return _theBus->readRegister(SFE_XM125_PRESENCE_DETECTOR_STATUS, status);
 }
 //--------------------------------------------------------------------------------
 sfTkError_t sfDevXM125Presence::getPresenceDetectorErrorStatus(uint32_t &status)
 {
     sfTkError_t retVal = 0;
     uint32_t regVal = 0;
-    size_t readBytes = 0;
-    retVal = _theBus->readRegister16Region(SFE_XM125_PRESENCE_DETECTOR_STATUS, (uint8_t *)&regVal, sizeof(uint32_t),
-                                           readBytes);
-    regVal = sftk_byte_swap(regVal);
+    retVal = _theBus->readRegister(SFE_XM125_PRESENCE_DETECTOR_STATUS, regVal);
 
     // clear out status
     status = 0;
@@ -224,127 +214,85 @@ sfTkError_t sfDevXM125Presence::getPresenceDetectorErrorStatus(uint32_t &status)
 //--------------------------------------------------------------------------------
 sfTkError_t sfDevXM125Presence::getPresenceDetectorPresenceDetected(uint32_t &detected)
 {
-    uint32_t regVal = 0;
-
     // Read from 16-Bit Register
-    size_t readBytes = 0;
-    sfTkError_t retVal =
-        _theBus->readRegister16Region(SFE_XM125_PRESENCE_RESULT, (uint8_t *)&regVal, sizeof(uint32_t), readBytes);
-
-    regVal = sftk_byte_swap(regVal);
+    sfTkError_t retVal = _theBus->readRegister(SFE_XM125_PRESENCE_RESULT, detected);
 
     // Mask unused bits from register
-    detected = (regVal & SFE_XM125_PRESENCE_DETECTED_MASK);
+    if (retVal == ksfTkErrOk)
+        detected = (detected & SFE_XM125_PRESENCE_DETECTED_MASK);
 
     return retVal;
 }
 //--------------------------------------------------------------------------------
 sfTkError_t sfDevXM125Presence::getPresenceDetectorPresenceStickyDetected(uint32_t &sticky)
 {
-    uint32_t regVal = 0;
 
     // Read from 16-Bit Register
-    size_t readBytes = 0;
-    sfTkError_t retVal =
-        _theBus->readRegister16Region(SFE_XM125_PRESENCE_RESULT, (uint8_t *)&regVal, sizeof(uint32_t), readBytes);
-
-    regVal = sftk_byte_swap(regVal);
+    sfTkError_t retVal = _theBus->readRegister(SFE_XM125_PRESENCE_RESULT, sticky);
 
     // Mask unused bits from register
-    sticky = (regVal & SFE_XM125_PRESENCE_DETECTED_STICKY_MASK) >> 1;
+    if (retVal == ksfTkErrOk)
+        sticky = (sticky & SFE_XM125_PRESENCE_DETECTED_STICKY_MASK) >> 1;
 
     return retVal;
 }
 //--------------------------------------------------------------------------------
 sfTkError_t sfDevXM125Presence::getPresenceDetectorRegError(uint32_t &error)
 {
-    uint32_t regVal = 0;
-
-    // Read from 16-Bit Register
-    size_t readBytes = 0;
-    sfTkError_t retVal =
-        _theBus->readRegister16Region(SFE_XM125_PRESENCE_RESULT, (uint8_t *)&regVal, sizeof(uint32_t), readBytes);
-
-    regVal = sftk_byte_swap(regVal);
+    sfTkError_t retVal = _theBus->readRegister(SFE_XM125_PRESENCE_RESULT, error);
 
     // Mask unused bits from register
-    error = (regVal & SFE_XM125_PRESENCE_DETECTOR_ERROR_MASK) >> SFE_XM125_PRESENCE_DETECTOR_ERROR_MASK_SHIFT;
+    if (retVal == ksfTkErrOk)
+        error = (error & SFE_XM125_PRESENCE_DETECTOR_ERROR_MASK) >> SFE_XM125_PRESENCE_DETECTOR_ERROR_MASK_SHIFT;
 
     return retVal;
 }
 //--------------------------------------------------------------------------------
 sfTkError_t sfDevXM125Presence::getPresenceTemperature(uint32_t &temp)
 {
-    uint32_t regVal = 0;
-
-    // Read from 16-Bit Register
-    size_t readBytes = 0;
-    sfTkError_t retVal =
-        _theBus->readRegister16Region(SFE_XM125_PRESENCE_DISTANCE, (uint8_t *)&regVal, sizeof(uint32_t), readBytes);
+    sfTkError_t retVal = _theBus->readRegister(SFE_XM125_PRESENCE_DISTANCE, temp);
 
     // Mask unused bits from register
-    temp = (regVal & SFE_XM125_PRESENCE_TEMPERATURE_MASK) >> SFE_XM125_PRESENCE_TEMPERATURE_MASK_SHIFT;
+    temp = (temp & SFE_XM125_PRESENCE_TEMPERATURE_MASK) >> SFE_XM125_PRESENCE_TEMPERATURE_MASK_SHIFT;
 
     return retVal;
 }
 //--------------------------------------------------------------------------------
 sfTkError_t sfDevXM125Presence::getPresenceDistance(uint32_t &distance)
 {
-    size_t readBytes = 0;
-    sfTkError_t retVal =
-        _theBus->readRegister16Region(SFE_XM125_PRESENCE_DISTANCE, (uint8_t *)&distance, sizeof(uint32_t), readBytes);
-    distance = sftk_byte_swap(distance);
-    return retVal;
+    return _theBus->readRegister(SFE_XM125_PRESENCE_DISTANCE, distance);
 }
 //--------------------------------------------------------------------------------
 sfTkError_t sfDevXM125Presence::getPresenceIntraPresenceScore(uint32_t &intra)
 {
-    size_t readBytes = 0;
-    sfTkError_t retVal =
-        _theBus->readRegister16Region(SFE_XM125_INTRA_PRESENCE_SCORE, (uint8_t *)&intra, sizeof(uint32_t), readBytes);
-    intra = sftk_byte_swap(intra);
-    return retVal;
+    return _theBus->readRegister(SFE_XM125_INTRA_PRESENCE_SCORE, intra);
 }
 //--------------------------------------------------------------------------------
 sfTkError_t sfDevXM125Presence::getPresenceInterPresenceScore(uint32_t &inter)
 {
-    size_t readBytes = 0;
-    sfTkError_t retVal =
-        _theBus->readRegister16Region(SFE_XM125_INTER_PRESENCE, (uint8_t *)&inter, sizeof(uint32_t), readBytes);
-    inter = sftk_byte_swap(inter);
-    return retVal;
+    return _theBus->readRegister(SFE_XM125_INTER_PRESENCE, inter);
 }
 //--------------------------------------------------------------------------------
 sfTkError_t sfDevXM125Presence::getPresenceSweepsPerFrame(uint32_t &sweeps)
 {
-    size_t readBytes = 0;
-    sfTkError_t retVal =
-        _theBus->readRegister16Region(SFE_XM125_INTRA_PRESENCE_SCORE, (uint8_t *)&sweeps, sizeof(uint32_t), readBytes);
-    sweeps = sftk_byte_swap(sweeps);
-    return retVal;
+    return _theBus->readRegister(SFE_XM125_PRESENCE_SWEEPS_PER_FRAME, sweeps);
 }
 //--------------------------------------------------------------------------------
 sfTkError_t sfDevXM125Presence::setPresenceSweepsPerFrame(uint32_t sweeps)
 {
-    sweeps = sftk_byte_swap(sweeps);
-    return _theBus->writeRegister16Region(SFE_XM125_PRESENCE_SWEEPS_PER_FRAME, (uint8_t *)&sweeps, sizeof(uint32_t));
+    return _theBus->writeRegister(SFE_XM125_PRESENCE_SWEEPS_PER_FRAME, sweeps);
 }
 
 //--------------------------------------------------------------------------------
 sfTkError_t sfDevXM125Presence::getPresenceInterFramePresenceTimeout(uint32_t &time)
 {
-    size_t readBytes = 0;
-    sfTkError_t retVal = _theBus->readRegister16Region(SFE_XM125_PRESENCE_INTER_FRAME_TIMEOUT, (uint8_t *)&time,
-                                                       sizeof(uint32_t), readBytes);
-    time = sftk_byte_swap(time);
-    return retVal;
+    return _theBus->readRegister(SFE_XM125_PRESENCE_INTER_FRAME_TIMEOUT, time);
 }
 
 //--------------------------------------------------------------------------------
 sfTkError_t sfDevXM125Presence::setPresenceInterFramePresenceTimeout(uint32_t time)
 {
-    time = sftk_byte_swap(time);
-    return _theBus->writeRegister16Region(SFE_XM125_PRESENCE_INTER_FRAME_TIMEOUT, (uint8_t *)&time, sizeof(uint32_t));
+    return _theBus->writeRegister(SFE_XM125_PRESENCE_INTER_FRAME_TIMEOUT, time);
 }
 
 //--------------------------------------------------------------------------------
@@ -352,8 +300,8 @@ sfTkError_t sfDevXM125Presence::getPresenceInterPhaseBoostEnabled(bool &en)
 {
     size_t readBytes = 0;
     uint8_t value;
-    sfTkError_t retVal = _theBus->readRegister16Region(SFE_XM125_PRESENCE_INTER_PHASE_BOOST_ENABLED, (uint8_t *)&value,
-                                                       sizeof(uint8_t), readBytes);
+    sfTkError_t retVal = _theBus->readRegister(SFE_XM125_PRESENCE_INTER_PHASE_BOOST_ENABLED, (uint8_t *)&value,
+                                               sizeof(uint8_t), readBytes);
     en = (value != 0);
     return retVal;
 }
@@ -362,8 +310,7 @@ sfTkError_t sfDevXM125Presence::getPresenceInterPhaseBoostEnabled(bool &en)
 sfTkError_t sfDevXM125Presence::setPresenceInterPhaseBoostEnabled(bool en)
 {
     uint8_t value = en ? 1 : 0;
-    return _theBus->writeRegister16Region(SFE_XM125_PRESENCE_INTER_PHASE_BOOST_ENABLED, (uint8_t *)&value,
-                                          sizeof(uint8_t));
+    return _theBus->writeRegisterUInt8(SFE_XM125_PRESENCE_INTER_PHASE_BOOST_ENABLED, value);
 }
 
 //--------------------------------------------------------------------------------
@@ -371,8 +318,8 @@ sfTkError_t sfDevXM125Presence::getPresenceIntraDetectionEnabled(bool &en)
 {
     size_t readBytes = 0;
     uint8_t value;
-    sfTkError_t retVal = _theBus->readRegister16Region(SFE_XM125_PRESENCE_INTRA_DETECTION_ENABLED, (uint8_t *)&value,
-                                                       sizeof(uint8_t), readBytes);
+    sfTkError_t retVal = _theBus->readRegisterUInt8(SFE_XM125_PRESENCE_INTRA_DETECTION_ENABLED, value);
+
     en = (value != 0);
     return retVal;
 }
@@ -381,168 +328,115 @@ sfTkError_t sfDevXM125Presence::getPresenceIntraDetectionEnabled(bool &en)
 sfTkError_t sfDevXM125Presence::setPresenceInterDetectionEnabled(bool en)
 {
     uint8_t value = en ? 1 : 0;
-    return _theBus->writeRegister16Region(SFE_XM125_PRESENCE_INTRA_DETECTION_ENABLED, (uint8_t *)&value,
-                                          sizeof(uint8_t));
+    return _theBus->writeRegister(SFE_XM125_PRESENCE_INTRA_DETECTION_ENABLED, (uint8_t *)&value, sizeof(uint8_t));
 }
 
 //--------------------------------------------------------------------------------
 sfTkError_t sfDevXM125Presence::getPresenceFrameRate(uint32_t &rate)
 {
-    size_t readBytes = 0;
-    sfTkError_t retVal =
-        _theBus->readRegister16Region(SFE_XM125_PRESENCE_FRAME_RATE, (uint8_t *)&rate, sizeof(uint32_t), readBytes);
-    rate = sftk_byte_swap(rate);
-    return retVal;
+    return _theBus->readRegister(SFE_XM125_PRESENCE_FRAME_RATE, rate);
 }
 
 //--------------------------------------------------------------------------------
 sfTkError_t sfDevXM125Presence::setPresenceFrameRate(uint32_t rate)
 {
-    rate = sftk_byte_swap(rate);
-    return _theBus->writeRegister16Region(SFE_XM125_PRESENCE_FRAME_RATE, (uint8_t *)&rate, sizeof(uint32_t));
+    return _theBus->writeRegister(SFE_XM125_PRESENCE_FRAME_RATE, rate);
 }
 
 //--------------------------------------------------------------------------------
 sfTkError_t sfDevXM125Presence::getPresenceIntraDetectionThreshold(uint32_t &thresh)
 {
-    size_t readBytes = 0;
-    sfTkError_t retVal = _theBus->readRegister16Region(SFE_XM125_PRESENCE_INTRA_DETECTION_THRESHOLD, (uint8_t *)&thresh,
-                                                       sizeof(uint32_t), readBytes);
-    thresh = sftk_byte_swap(thresh);
-    return retVal;
+    return _theBus->readRegister(SFE_XM125_PRESENCE_INTRA_DETECTION_THRESHOLD, thresh);
 }
 
 //--------------------------------------------------------------------------------
 sfTkError_t sfDevXM125Presence::setPresenceIntraDetectionThreshold(uint32_t thresh)
 {
-    thresh = sftk_byte_swap(thresh);
-    return _theBus->writeRegister16Region(SFE_XM125_PRESENCE_INTRA_DETECTION_THRESHOLD, (uint8_t *)&thresh,
-                                          sizeof(uint32_t));
+    return _theBus->writeRegister(SFE_XM125_PRESENCE_INTRA_DETECTION_THRESHOLD, thresh);
 }
 
 //--------------------------------------------------------------------------------
 sfTkError_t sfDevXM125Presence::getPresenceInterDetectionThreshold(uint32_t &thresh)
 {
-    size_t readBytes = 0;
-    sfTkError_t retVal = _theBus->readRegister16Region(SFE_XM125_PRESENCE_INTER_DETECTION_THRESHOLD, (uint8_t *)&thresh,
-                                                       sizeof(uint32_t), readBytes);
-    thresh = sftk_byte_swap(thresh);
-    return retVal;
+    return _theBus->readRegister(SFE_XM125_PRESENCE_INTER_DETECTION_THRESHOLD, thresh);
 }
 
 //--------------------------------------------------------------------------------
 sfTkError_t sfDevXM125Presence::setPresenceInterDetectionThreshold(uint32_t thresh)
 {
-    thresh = sftk_byte_swap(thresh);
-    return _theBus->writeRegister16Region(SFE_XM125_PRESENCE_INTER_DETECTION_THRESHOLD, (uint8_t *)&thresh,
-                                          sizeof(uint32_t));
+    return _theBus->writeRegister(SFE_XM125_PRESENCE_INTER_DETECTION_THRESHOLD, thresh);
 }
 
 //--------------------------------------------------------------------------------
 sfTkError_t sfDevXM125Presence::getPresenceInterFrameDeviationTime(uint32_t &time)
 {
-    size_t readBytes = 0;
-    sfTkError_t retVal = _theBus->readRegister16Region(SFE_XM125_PRESENCE_INTER_FRAME_DEVIATION, (uint8_t *)&time,
-                                                       sizeof(uint32_t), readBytes);
-    time = sftk_byte_swap(time);
-    return retVal;
+    return _theBus->readRegister(SFE_XM125_PRESENCE_INTER_FRAME_DEVIATION, time);
 }
 
 //--------------------------------------------------------------------------------
 sfTkError_t sfDevXM125Presence::setPresenceInterFrameDeviationTime(uint32_t time)
 {
-    time = sftk_byte_swap(time);
-    return _theBus->writeRegister16Region(SFE_XM125_PRESENCE_INTER_FRAME_DEVIATION, (uint8_t *)&time, sizeof(uint32_t));
+    return _theBus->writeRegister(SFE_XM125_PRESENCE_INTER_FRAME_DEVIATION, time);
 }
 
 //--------------------------------------------------------------------------------
 sfTkError_t sfDevXM125Presence::getPresenceInterFrameFastCutoff(uint32_t &cut)
 {
-    size_t readBytes = 0;
-    sfTkError_t retVal = _theBus->readRegister16Region(SFE_XM125_PRESENCE_INTER_FRAME_FAST_CUTOFF, (uint8_t *)&cut,
-                                                       sizeof(uint32_t), readBytes);
-    cut = sftk_byte_swap(cut);
-    return retVal;
+    return _theBus->readRegister(SFE_XM125_PRESENCE_INTER_FRAME_FAST_CUTOFF, cut);
 }
 
 //--------------------------------------------------------------------------------
 sfTkError_t sfDevXM125Presence::setPresenceInterFrameFastCutoff(uint32_t cut)
 {
-    cut = sftk_byte_swap(cut);
-    return _theBus->writeRegister16Region(SFE_XM125_PRESENCE_INTER_FRAME_FAST_CUTOFF, (uint8_t *)&cut,
-                                          sizeof(uint32_t));
+    return _theBus->writeRegister(SFE_XM125_PRESENCE_INTER_FRAME_FAST_CUTOFF, cut);
 }
 
 //--------------------------------------------------------------------------------
 sfTkError_t sfDevXM125Presence::getPresenceInterFrameSlowCutoff(uint32_t &cut)
 {
-    size_t readBytes = 0;
-    sfTkError_t retVal = _theBus->readRegister16Region(SFE_XM125_PRESENCE_INTER_FRAME_SLOW_CUTOFF, (uint8_t *)&cut,
-                                                       sizeof(uint32_t), readBytes);
-    cut = sftk_byte_swap(cut);
-    return retVal;
+    return _theBus->readRegister(SFE_XM125_PRESENCE_INTER_FRAME_SLOW_CUTOFF, cut);
 }
 
 //--------------------------------------------------------------------------------
 sfTkError_t sfDevXM125Presence::setPresenceInterFrameSlowCutoff(uint32_t cut)
 {
-    cut = sftk_byte_swap(cut);
-    return _theBus->writeRegister16Region(SFE_XM125_PRESENCE_INTER_FRAME_SLOW_CUTOFF, (uint8_t *)&cut,
-                                          sizeof(uint32_t));
+    return _theBus->writeRegister(SFE_XM125_PRESENCE_INTER_FRAME_SLOW_CUTOFF, cut);
 }
 
 //--------------------------------------------------------------------------------
 sfTkError_t sfDevXM125Presence::getPresenceIntraFrameTimeConst(uint32_t &time)
 {
-    size_t readBytes = 0;
-    sfTkError_t retVal = _theBus->readRegister16Region(SFE_XM125_PRESENCE_INTRA_FRAME_TIME_CONST, (uint8_t *)&time,
-                                                       sizeof(uint32_t), readBytes);
-    time = sftk_byte_swap(time);
-    return retVal;
+    return _theBus->readRegister(SFE_XM125_PRESENCE_INTRA_FRAME_TIME_CONST, time);
 }
 
 //--------------------------------------------------------------------------------
 sfTkError_t sfDevXM125Presence::setPresenceIntraFrameTimeConst(uint32_t time)
 {
-    time = sftk_byte_swap(time);
-    return _theBus->writeRegister16Region(SFE_XM125_PRESENCE_INTRA_FRAME_TIME_CONST, (uint8_t *)&time,
-                                          sizeof(uint32_t));
+    return _theBus->writeRegister(SFE_XM125_PRESENCE_INTRA_FRAME_TIME_CONST, time);
 }
 
 //--------------------------------------------------------------------------------
 sfTkError_t sfDevXM125Presence::getPresenceIntraOutputTimeConst(uint32_t &time)
 {
-    size_t readBytes = 0;
-    sfTkError_t retVal = _theBus->readRegister16Region(SFE_XM125_PRESENCE_INTRA_OUTPUT_TIME_CONST, (uint8_t *)&time,
-                                                       sizeof(uint32_t), readBytes);
-    time = sftk_byte_swap(time);
-    return retVal;
+    return _theBus->readRegister(SFE_XM125_PRESENCE_INTRA_OUTPUT_TIME_CONST, time);
 }
 
 //--------------------------------------------------------------------------------
 sfTkError_t sfDevXM125Presence::setPresenceIntraOutputTimeConst(uint32_t time)
 {
-    time = sftk_byte_swap(time);
-    return _theBus->writeRegister16Region(SFE_XM125_PRESENCE_INTRA_OUTPUT_TIME_CONST, (uint8_t *)&time,
-                                          sizeof(uint32_t));
+    return _theBus->writeRegister(SFE_XM125_PRESENCE_INTRA_OUTPUT_TIME_CONST, time);
 }
 
 //--------------------------------------------------------------------------------
 sfTkError_t sfDevXM125Presence::getPresenceInterOutputTimeConst(uint32_t &time)
 {
-    size_t readBytes = 0;
-    sfTkError_t retVal = _theBus->readRegister16Region(SFE_XM125_PRESENCE_INTER_OUTPUT_TIME_CONST, (uint8_t *)&time,
-                                                       sizeof(uint32_t), readBytes);
-    time = sftk_byte_swap(time);
-    return retVal;
+    return _theBus->readRegister(SFE_XM125_PRESENCE_INTER_OUTPUT_TIME_CONST, time);
 }
 
 //--------------------------------------------------------------------------------
 sfTkError_t sfDevXM125Presence::setPresenceInterOutputTimeConst(uint32_t time)
 {
-    time = sftk_byte_swap(time);
-    return _theBus->writeRegister16Region(SFE_XM125_PRESENCE_INTER_OUTPUT_TIME_CONST, (uint8_t *)&time,
-                                          sizeof(uint32_t));
+    return _theBus->writeRegister(SFE_XM125_PRESENCE_INTER_OUTPUT_TIME_CONST, time);
 }
 
 //--------------------------------------------------------------------------------
@@ -550,8 +444,8 @@ sfTkError_t sfDevXM125Presence::getPresenceAutoProfileEn(bool &en)
 {
     size_t readBytes = 0;
     uint8_t value;
-    sfTkError_t retVal = _theBus->readRegister16Region(SFE_XM125_PRESENCE_AUTO_PROFILE_ENABLED, (uint8_t *)&value,
-                                                       sizeof(uint8_t), readBytes);
+    sfTkError_t retVal =
+        _theBus->readRegister(SFE_XM125_PRESENCE_AUTO_PROFILE_ENABLED, (uint8_t *)&value, sizeof(uint8_t), readBytes);
     en = (value != 0);
     return retVal;
 }
@@ -560,7 +454,7 @@ sfTkError_t sfDevXM125Presence::getPresenceAutoProfileEn(bool &en)
 sfTkError_t sfDevXM125Presence::setPresenceAutoProfileEn(bool en)
 {
     uint8_t value = en ? 1 : 0;
-    return _theBus->writeRegister16Region(SFE_XM125_PRESENCE_AUTO_PROFILE_ENABLED, (uint8_t *)&value, sizeof(uint8_t));
+    return _theBus->writeRegister(SFE_XM125_PRESENCE_AUTO_PROFILE_ENABLED, (uint8_t *)&value, sizeof(uint8_t));
 }
 
 //--------------------------------------------------------------------------------
@@ -568,8 +462,8 @@ sfTkError_t sfDevXM125Presence::getPresenceAutoStepLengthEn(bool &en)
 {
     size_t readBytes = 0;
     uint8_t value;
-    sfTkError_t retVal = _theBus->readRegister16Region(SFE_XM125_PRESENCE_AUTO_STEP_LENGTH_ENABLED, (uint8_t *)&value,
-                                                       sizeof(uint8_t), readBytes);
+    sfTkError_t retVal = _theBus->readRegister(SFE_XM125_PRESENCE_AUTO_STEP_LENGTH_ENABLED, (uint8_t *)&value,
+                                               sizeof(uint8_t), readBytes);
     en = (value != 0);
     return retVal;
 }
@@ -578,85 +472,65 @@ sfTkError_t sfDevXM125Presence::getPresenceAutoStepLengthEn(bool &en)
 sfTkError_t sfDevXM125Presence::setPresenceAutoStepLengthEn(bool en)
 {
     uint8_t value = en ? 1 : 0;
-    return _theBus->writeRegister16Region(SFE_XM125_PRESENCE_AUTO_STEP_LENGTH_ENABLED, (uint8_t *)&value,
-                                          sizeof(uint8_t));
+    return _theBus->writeRegister(SFE_XM125_PRESENCE_AUTO_STEP_LENGTH_ENABLED, (uint8_t *)&value, sizeof(uint8_t));
 }
 
 //--------------------------------------------------------------------------------
 sfTkError_t sfDevXM125Presence::getPresenceManualProfile(uint32_t &prof)
 {
-    size_t readBytes = 0;
-    sfTkError_t retVal =
-        _theBus->readRegister16Region(SFE_XM125_PRESENCE_MANUAL_PROFILE, (uint8_t *)&prof, sizeof(uint32_t), readBytes);
-    prof = sftk_byte_swap(prof);
-    return retVal;
+    return _theBus->readRegister(SFE_XM125_PRESENCE_MANUAL_PROFILE, prof);
 }
 
 //--------------------------------------------------------------------------------
 sfTkError_t sfDevXM125Presence::setPresenceManualProfile(uint32_t prof)
 {
-    prof = sftk_byte_swap(prof);
-    return _theBus->writeRegister16Region(SFE_XM125_PRESENCE_MANUAL_PROFILE, (uint8_t *)&prof, sizeof(uint32_t));
+    return _theBus->writeRegister(SFE_XM125_PRESENCE_MANUAL_PROFILE, prof);
 }
 
 //--------------------------------------------------------------------------------
 sfTkError_t sfDevXM125Presence::getPresenceManualStepLength(uint32_t &length)
 {
-    size_t readBytes = 0;
-    sfTkError_t retVal = _theBus->readRegister16Region(SFE_XM125_PRESENCE_MANUAL_STEP_LENGTH, (uint8_t *)&length,
-                                                       sizeof(uint32_t), readBytes);
-    length = sftk_byte_swap(length);
-    return retVal;
+    return _theBus->readRegister(SFE_XM125_PRESENCE_MANUAL_STEP_LENGTH, length);
 }
 
 //--------------------------------------------------------------------------------
 sfTkError_t sfDevXM125Presence::setPresenceManualStepLength(uint32_t length)
 {
-    length = sftk_byte_swap(length);
-    return _theBus->writeRegister16Region(SFE_XM125_PRESENCE_MANUAL_STEP_LENGTH, (uint8_t *)&length, sizeof(uint32_t));
+    return _theBus->writeRegister(SFE_XM125_PRESENCE_MANUAL_STEP_LENGTH, length);
 }
 
 //--------------------------------------------------------------------------------
 sfTkError_t sfDevXM125Presence::getPresenceStart(uint32_t &start)
 {
-    size_t readBytes = 0;
-    sfTkError_t retVal =
-        _theBus->readRegister16Region(SFE_XM125_PRESENCE_START, (uint8_t *)&start, sizeof(uint32_t), readBytes);
-    start = sftk_byte_swap(start);
-    return retVal;
+    return _theBus->readRegister(SFE_XM125_PRESENCE_START, start);
 }
 
 //--------------------------------------------------------------------------------
 sfTkError_t sfDevXM125Presence::setPresenceStart(uint32_t start)
 {
-    start = sftk_byte_swap(start);
-    return _theBus->writeRegister16Region(SFE_XM125_PRESENCE_START, (uint8_t *)&start, sizeof(uint32_t));
+    return _theBus->writeRegister(SFE_XM125_PRESENCE_START, start);
 }
 
 //--------------------------------------------------------------------------------
 sfTkError_t sfDevXM125Presence::getPresenceEnd(uint32_t &end)
 {
-    size_t readBytes = 0;
-    sfTkError_t retVal =
-        _theBus->readRegister16Region(SFE_XM125_PRESENCE_END, (uint8_t *)&end, sizeof(uint32_t), readBytes);
-    end = sftk_byte_swap(end);
-    return retVal;
+    return _theBus->readRegister(SFE_XM125_PRESENCE_END, end);
 }
 
 //--------------------------------------------------------------------------------
 sfTkError_t sfDevXM125Presence::setPresenceEnd(uint32_t end)
 {
-    end = sftk_byte_swap(end);
-    return _theBus->writeRegister16Region(SFE_XM125_PRESENCE_END, (uint8_t *)&end, sizeof(uint32_t));
+    return _theBus->writeRegister(SFE_XM125_PRESENCE_END, end);
 }
 
 //--------------------------------------------------------------------------------
 sfTkError_t sfDevXM125Presence::getPresenceResetFilters(bool &reset)
 {
+
     size_t readBytes = 0;
     uint8_t value;
     sfTkError_t retVal =
-        _theBus->readRegister16Region(SFE_XM125_PRESENCE_RESET_FILTERS_ON_PREPARE, &value, sizeof(uint8_t), readBytes);
+        _theBus->readRegister(SFE_XM125_PRESENCE_RESET_FILTERS_ON_PREPARE, &value, sizeof(uint8_t), readBytes);
     reset = (value != 0);
     return retVal;
 }
@@ -665,43 +539,36 @@ sfTkError_t sfDevXM125Presence::getPresenceResetFilters(bool &reset)
 sfTkError_t sfDevXM125Presence::setPresenceResetFilters(bool reset)
 {
     uint8_t value = reset ? 1 : 0;
-    return _theBus->writeRegister16Region(SFE_XM125_PRESENCE_RESET_FILTERS_ON_PREPARE, &value, sizeof(uint8_t));
+    return _theBus->writeRegister(SFE_XM125_PRESENCE_RESET_FILTERS_ON_PREPARE, &value, sizeof(uint8_t));
 }
 
 //--------------------------------------------------------------------------------
 sfTkError_t sfDevXM125Presence::getPresenceHWAAS(uint32_t &avg)
 {
-    size_t readBytes = 0;
-    return _theBus->readRegister16Region(SFE_XM125_PRESENCE_HWAAS, (uint8_t *)&avg, sizeof(uint32_t), readBytes);
+    return _theBus->readRegister(SFE_XM125_PRESENCE_HWAAS, avg);
 }
 
 //--------------------------------------------------------------------------------
 sfTkError_t sfDevXM125Presence::setPresenceHWAAS(uint32_t avg)
 {
-    return _theBus->writeRegister16Region(SFE_XM125_PRESENCE_HWAAS, (uint8_t *)&avg, sizeof(uint32_t));
+    return _theBus->writeRegister(SFE_XM125_PRESENCE_HWAAS, avg);
 }
 
 //--------------------------------------------------------------------------------
 sfTkError_t sfDevXM125Presence::getPresenceDetectionOnGPIO(uint32_t &detected)
 {
-    size_t readBytes = 0;
-    sfTkError_t retVal = _theBus->readRegister16Region(SFE_XM125_PRESENCE_DETECTION_ON_GPIO, (uint8_t *)&detected,
-                                                       sizeof(uint32_t), readBytes);
-    detected = sftk_byte_swap(detected);
-    return retVal;
+    return _theBus->readRegister(SFE_XM125_PRESENCE_DETECTION_ON_GPIO, detected);
 }
 
 //--------------------------------------------------------------------------------
 sfTkError_t sfDevXM125Presence::setPresenceDetectionOnGPIO(uint32_t detected)
 {
-    detected = sftk_byte_swap(detected);
-    return _theBus->writeRegister16Region(SFE_XM125_PRESENCE_DETECTION_ON_GPIO, (uint8_t *)&detected, sizeof(uint32_t));
+    return _theBus->writeRegister(SFE_XM125_PRESENCE_DETECTION_ON_GPIO, detected);
 }
 
 sfTkError_t sfDevXM125Presence::setPresenceCommand(uint32_t cmd)
 {
-    cmd = sftk_byte_swap(cmd);
-    return _theBus->writeRegister16Region(SFE_XM125_PRESENCE_COMMAND, (uint8_t *)&cmd, sizeof(uint32_t));
+    return _theBus->writeRegister(SFE_XM125_PRESENCE_COMMAND, cmd);
 }
 
 //--------------------------------------------------------------------------------
@@ -743,17 +610,12 @@ sfTkError_t sfDevXM125Presence::presenceLogConfiguration()
 //--------------------------------------------------------------------------------
 sfTkError_t sfDevXM125Presence::getPresenceBusy(uint32_t &busy)
 {
-    sfTkError_t retVal;
-    uint32_t regVal = 0;
-
     // Read from 16-Bit Register
-    size_t readBytes = 0;
-    retVal = _theBus->readRegister16Region(SFE_XM125_PRESENCE_DETECTOR_STATUS, (uint8_t *)&regVal, sizeof(uint32_t),
-                                           readBytes);
 
-    regVal = sftk_byte_swap(regVal);
+    sfTkError_t retVal = _theBus->readRegister(SFE_XM125_PRESENCE_DETECTOR_STATUS, busy);
+
     // Mask unused bits from register
-    busy = (regVal & SFE_XM125_PRESENCE_BUSY_MASK) >> SFE_XM125_PRESENCE_BUSY_MASK_SHIFT;
+    busy = (busy & SFE_XM125_PRESENCE_BUSY_MASK) >> SFE_XM125_PRESENCE_BUSY_MASK_SHIFT;
 
     return retVal;
 }
@@ -761,21 +623,13 @@ sfTkError_t sfDevXM125Presence::getPresenceBusy(uint32_t &busy)
 //--------------------------------------------------------------------------------
 sfTkError_t sfDevXM125Presence::presenceBusyWait()
 {
-    sfTkError_t retVal = 0;
     uint32_t regVal = 0;
 
-    size_t readBytes = 0;
-    retVal = _theBus->readRegister16Region(SFE_XM125_PRESENCE_DETECTOR_STATUS, (uint8_t *)&regVal, sizeof(uint32_t),
-                                           readBytes);
-    regVal = sftk_byte_swap(regVal);
+    sfTkError_t retVal = _theBus->readRegister(SFE_XM125_PRESENCE_DETECTOR_STATUS, regVal);
 
     // Poll Detector Status until Busy bit is cleared
     while (((regVal & SFE_XM125_PRESENCE_BUSY_MASK) >> 30) != 0)
-    {
-        retVal = _theBus->readRegister16Region(SFE_XM125_PRESENCE_DETECTOR_STATUS, (uint8_t *)&regVal, sizeof(uint32_t),
-                                               readBytes);
-        regVal = sftk_byte_swap(regVal);
-    }
+        retVal = _theBus->readRegister(SFE_XM125_PRESENCE_DETECTOR_STATUS, regVal);
 
     return retVal;
 }
\ No newline at end of file
diff --git a/src/sfTk/sfDevXM125Presence.h b/src/sfTk/sfDevXM125Presence.h
index 7a7f1db..48c814d 100644
--- a/src/sfTk/sfDevXM125Presence.h
+++ b/src/sfTk/sfDevXM125Presence.h
@@ -243,7 +243,7 @@ class sfDevXM125Presence : public sfDevXM125Core
      * @param theBus Pointer to the I2C bus object. If nullptr, the default bus is used.
      * @return ksfTkErrOk on success, or error code (value < -1) on failure.
      */
-    sfTkError_t begin(sfTkII2C *theBus = nullptr);
+    sfTkError_t begin(sfTkII2C *theBus = nullptr) override;
     /// @brief This function sets all the beginning values for a basic I2C
     ///  example to be run on the device for presence sensing.
     /// @return ksfTkErrOk on success, or error code (value < -1)