fix: Resolved merge conflicts - take three

Author: Miles Burton

DallasTemperature.cpp

@@ -22,6 +22,18 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 */
 
+#if defined(PLATFORM_ID)  // Only defined if a Particle device
+inline void yield() {
+    Particle.process();
+}
+#elif ARDUINO >= 100
+#include "Arduino.h"
+#else
+extern "C" {
+#include "WConstants.h"
+}
+#endif
+
 #include "DallasTemperature.h"
 
 // OneWire commands
@@ -50,6 +62,7 @@ SOFTWARE.
 #define TEMP_11_BIT 0x5F // 11 bit
 #define TEMP_12_BIT 0x7F // 12 bit
 
+// Constructors
 DallasTemperature::DallasTemperature() {
 #if REQUIRESALARMS
     setAlarmHandler(nullptr);
@@ -121,6 +134,50 @@ void DallasTemperature::begin(void) {
     }
 }
 
+// Device Information Methods
+bool DallasTemperature::validFamily(const uint8_t* deviceAddress) {
+    switch (deviceAddress[0]) {
+        case DS18S20MODEL:
+        case DS18B20MODEL:
+        case DS1822MODEL:
+        case DS1825MODEL:
+        case DS28EA00MODEL:
+            return true;
+        default:
+            return false;
+    }
+}
+
+bool DallasTemperature::validAddress(const uint8_t* deviceAddress) {
+    return (_wire->crc8(const_cast<uint8_t*>(deviceAddress), 7) == deviceAddress[7]);
+}
+
+bool DallasTemperature::getAddress(uint8_t* deviceAddress, uint8_t index) {
+    if (index < devices) {
+        uint8_t depth = 0;
+        
+        _wire->reset_search();
+        
+        while (depth <= index && _wire->search(deviceAddress)) {
+            if (depth == index && validAddress(deviceAddress)) {
+                return true;
+            }
+            depth++;
+        }
+    }
+    
+    return false;
+}
+
+// Device Count Methods
+uint8_t DallasTemperature::getDeviceCount(void) {
+    return devices;
+}
+
+uint8_t DallasTemperature::getDS18Count(void) {
+    return ds18Count;
+}
+
 // Alternative device count verification method
 bool DallasTemperature::verifyDeviceCount(void) {
     uint8_t actualCount = 0;
@@ -144,34 +201,200 @@ bool DallasTemperature::verifyDeviceCount(void) {
     return false;
 }
 
-// Returns the number of devices found on the bus
-uint8_t DallasTemperature::getDeviceCount(void) {
-    return devices;
+// Temperature reading with retry functionality
+int32_t DallasTemperature::getTemp(const uint8_t* deviceAddress, byte retryCount) {
+    ScratchPad scratchPad;
+    byte retries = 0;
+    
+    while (retries++ <= retryCount) {
+        if (isConnected(deviceAddress, scratchPad)) {
+            return calculateTemperature(deviceAddress, scratchPad);
+        }
+    }
+    
+    return DEVICE_DISCONNECTED_RAW;
 }
 
-uint8_t DallasTemperature::getDS18Count(void) {
-    return ds18Count;
+float DallasTemperature::getTempC(const uint8_t* deviceAddress, byte retryCount) {
+    return rawToCelsius(getTemp(deviceAddress, retryCount));
 }
 
-bool DallasTemperature::validFamily(const uint8_t* deviceAddress) {
-    switch (deviceAddress[0]) {
-        case DS18S20MODEL:
-        case DS18B20MODEL:
-        case DS1822MODEL:
-        case DS1825MODEL:
-        case DS28EA00MODEL:
-            return true;
-        default:
-            return false;
+float DallasTemperature::getTempF(const uint8_t* deviceAddress) {
+    return rawToFahrenheit(getTemp(deviceAddress));
+}
+
+// Temperature request methods
+request_t DallasTemperature::requestTemperatures(void) {
+    request_t req = {};
+    req.result = true;
+
+    _wire->reset();
+    _wire->skip();
+    _wire->write(STARTCONVO, parasite);
+
+    req.timestamp = millis();
+    if (!waitForConversion) {
+        return req;
     }
+    
+    blockTillConversionComplete(bitResolution, req.timestamp);
+    return req;
 }
 
-bool DallasTemperature::validAddress(const uint8_t* deviceAddress) {
-    return (_wire->crc8(const_cast<uint8_t*>(deviceAddress), 7) == deviceAddress[7]);
+request_t DallasTemperature::requestTemperaturesByAddress(const uint8_t* deviceAddress) {
+    request_t req = {};
+    uint8_t deviceBitResolution = getResolution(deviceAddress);
+    
+    if (deviceBitResolution == 0) {
+        req.result = false;
+        return req;
+    }
+
+    _wire->reset();
+    _wire->select(deviceAddress);
+    _wire->write(STARTCONVO, parasite);
+
+    req.timestamp = millis();
+    req.result = true;
+    
+    if (!waitForConversion) {
+        return req;
+    }
+
+    blockTillConversionComplete(deviceBitResolution, req.timestamp);
+    return req;
 }
 
-bool DallasTemperature::getAddress(uint8_t* deviceAddress, uint8_t index) {
-    if (index < devices) {
-        uint8_t depth = 0;
+// Resolution control methods
+void DallasTemperature::setResolution(uint8_t newResolution) {
+    bitResolution = constrain(newResolution, 9, 12);
+    
+    DeviceAddress deviceAddress;
+    _wire->reset_search();
+    
+    for (uint8_t i = 0; i < devices; i++) {
+        if (_wire->search(deviceAddress) && validAddress(deviceAddress)) {
+            setResolution(deviceAddress, bitResolution, true);
+        }
+    }
+}
+
+bool DallasTemperature::setResolution(const uint8_t* deviceAddress, uint8_t newResolution, bool skipGlobalBitResolutionCalculation) {
+    bool success = false;
+    
+    // DS1820 and DS18S20 have no resolution configuration register
+    if (deviceAddress[0] == DS18S20MODEL) {
+        success = true;
+    } else {
+        newResolution = constrain(newResolution, 9, 12);
+        uint8_t newValue = 0;
+        ScratchPad scratchPad;
+
+        if (isConnected(deviceAddress, scratchPad)) {
+            switch (newResolution) {
+                case 12:
+                    newValue = TEMP_12_BIT;
+                    break;
+                case 11:
+                    newValue = TEMP_11_BIT;
+                    break;
+                case 10:
+                    newValue = TEMP_10_BIT;
+                    break;
+                case 9:
+                default:
+                    newValue = TEMP_9_BIT;
+                    break;
+            }
+
+            if (scratchPad[CONFIGURATION] != newValue) {
+                scratchPad[CONFIGURATION] = newValue;
+                writeScratchPad(deviceAddress, scratchPad);
+            }
+            success = true;
+        }
+    }
+
+    // Update global resolution if needed
+    if (!skipGlobalBitResolutionCalculation && success) {
+        bitResolution = newResolution;
 
-        _wire->reset_
+        if (devices > 1) {
+            DeviceAddress deviceAddr;
+            _wire->reset_search();
+            
+            for (uint8_t i = 0; i < devices; i++) {
+                if (bitResolution == 12) break;
+                
+                if (_wire->search(deviceAddr) && validAddress(deviceAddr)) {
+                    uint8_t b = getResolution(deviceAddr);
+                    if (b > bitResolution) bitResolution = b;
+                }
+            }
+        }
+    }
+
+    return success;
+}
+
+// Utility methods
+float DallasTemperature::toFahrenheit(float celsius) {
+    return (celsius * 1.8f) + 32.0f;
+}
+
+float DallasTemperature::toCelsius(float fahrenheit) {
+    return (fahrenheit - 32.0f) * 0.555555556f;
+}
+
+float DallasTemperature::rawToCelsius(int32_t raw) {
+    if (raw <= DEVICE_DISCONNECTED_RAW) {
+        return DEVICE_DISCONNECTED_C;
+    }
+    return (float)raw * 0.0078125f;  // 1/128
+}
+
+float DallasTemperature::rawToFahrenheit(int32_t raw) {
+    if (raw <= DEVICE_DISCONNECTED_RAW) {
+        return DEVICE_DISCONNECTED_F;
+    }
+    return (float)raw * 0.0140625f + 32.0f;  // 1/128*1.8 + 32
+}
+
+int16_t DallasTemperature::celsiusToRaw(float celsius) {
+    return static_cast<int16_t>(celsius * 128.0f);
+}
+
+// Internal helper methods
+bool DallasTemperature::isAllZeros(const uint8_t* const scratchPad, const size_t length) {
+    for (size_t i = 0; i < length; i++) {
+        if (scratchPad[i] != 0) {
+            return false;
+        }
+    }
+    return true;
+}
+
+void DallasTemperature::activateExternalPullup() {
+    if (useExternalPullup) {
+        digitalWrite(pullupPin, LOW);
+    }
+}
+
+void DallasTemperature::deactivateExternalPullup() {
+    if (useExternalPullup) {
+        digitalWrite(pullupPin, HIGH);
+    }
+}
+
+// Memory management if required
+#if REQUIRESNEW
+void* DallasTemperature::operator new(unsigned int size) {
+    void* p = malloc(size);
+    memset(p, 0, size);
+    return p;
+}
+
+void DallasTemperature::operator delete(void* p) {
+    free(p);
+}
+#endif

DallasTemperature.h

@@ -146,6 +146,7 @@ class DallasTemperature {
     bool getAutoSaveScratchPad(void);
 
 #if REQUIRESALARMS
+    // Alarm Handlers and Operations
     typedef void AlarmHandler(const uint8_t*);
     void setHighAlarmTemp(const uint8_t*, int8_t);
     void setLowAlarmTemp(const uint8_t*, int8_t);
@@ -174,10 +175,12 @@ class DallasTemperature {
     static float rawToFahrenheit(int32_t);
 
 #if REQUIRESNEW
+    // Memory Management
     void* operator new(unsigned int);
     void operator delete(void*);
 #endif
 
+    // Conversion Completion Handlers
     void blockTillConversionComplete(uint8_t);
     void blockTillConversionComplete(uint8_t, unsigned long);
     void blockTillConversionComplete(uint8_t, request_t);
@@ -204,6 +207,7 @@ class DallasTemperature {
     void deactivateExternalPullup(void);
 
 #if REQUIRESALARMS
+    // Internal Alarm State
     uint8_t alarmSearchAddress[8];
     int8_t alarmSearchJunction;
     uint8_t alarmSearchExhausted;