ds18b20 and dht22... cant get them to work together

somy problem is i cant get readings from both at once,
if i unplug the pin for my two ds18b20 and omit the line
for request.temperature, then i get a reading from my dht22. if i unplug the wire for my dht22 i get a reading from my two ds18b20 when i re add the request line.

at the bottom of my code, i have the dht22 being read every 4 seconds so i tried to throw everything in there
at the start of the loop is my 4 floats and request temperature,

i know im horrible at explaing myself, hopefully the error is easy to see

p.s. the reason theres so much print.serial things at the bottom is to be prepared for when i have my
sd data logger thats on the way, i have it set up how i want, where it should print every 4 seconds, but the two
sensors are blocking eachother i think?

thanks for any help. i also had to cut out a bunch of code so i could post this, but it was unrelated anyways

/*Grow tent brain, 
project started march 2018


people who helped along the way 

arduino.cc
- odometer
-sherzaad


*/







#include <Button.h>
#include <Adafruit_NeoPixel.h>
#ifdef __AVR__
#include <avr/power.h>
#endif
#include <dht_nonblocking.h>
#include "RTClib.h"
#include <Wire.h>
#include <LiquidCrystal.h>
DS3231 rtc;
#include <OneWire.h>
#include <DallasTemperature.h>


//sensor input pins
                                   
static const int DHT_SENSOR_PIN = 12;                                           //DHT22 pin number here
#define DHT_SENSOR_TYPE DHT_TYPE_22                                   //other pin infor for libraries
DHT_nonblocking dht_sensor( DHT_SENSOR_PIN, DHT_SENSOR_TYPE );
#define ONE_WIRE_BUS 13                                               //Dallas pin number here
OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);
DeviceAddress top = { 0x28, 0xFF, 0x38, 0x25, 0x63, 0x16, 0x04, 0x65 };   //Dallas device address (1/2)
DeviceAddress bottom   = { 0x28, 0xFF, 0x5D, 0x10, 0x62, 0x16, 0x04, 0xC4 }; //Dallas device address (2/2)


//Neo pixel 8 strip leds
#define PIN 11                                                        //pin number
#define NUMPIXELS      16                                               //number of leds in led strip
//colors
#define RED 250, 0, 0                                                  //color 1
#define GREEN 0, 250, 0                                                //color 2
#define BLUE 0, 0, 250                                                 //color 3
#define NOLIGHT 0, 0, 0                                                //no color/light
#define pixelbright 30
Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);


////////////////////////////////////////////////////////////////////////////////////////////////////////////Setup//////////////////////////////////////////////////////////



void setup() {
  Serial.begin(9600);
  Wire.begin();
  sensors.begin();
  rtc.begin();
  button1.begin();
  button2.begin();
  button3.begin();
  button4.begin();
  button5.begin();
  button6.begin();
  button7.begin();
  button8.begin();
  pixels.begin();
  pixels.setBrightness(pixelbright);
  rtc.adjust(DateTime(__DATE__, __TIME__));
  if (! rtc.isrunning()) {
    Serial.println("RTC is NOT running!");
  }
  //set pins (outputs)
  pinMode(waterpump, OUTPUT);
  pinMode(l1, OUTPUT);
  pinMode(l2, OUTPUT);
  pinMode(circulatepump, OUTPUT);
  pinMode(circulatefan, OUTPUT);
  pinMode(airstone, OUTPUT);
  pinMode(exhaustlight, OUTPUT);
  pinMode(exhausttent, OUTPUT);
  pinMode(dfloat, INPUT);
}
//Set DHT22 nnblocking
static bool measure_environment( float *temperature, float *humidity )
{
  static unsigned long measurement_timestamp = millis( );

  /* Measure once every four seconds. */
  if( millis( ) - measurement_timestamp > 4000ul )
  {
    if( dht_sensor.measure( temperature, humidity ) == true )
    {
      measurement_timestamp = millis( );
      return( true );
    }
  }

  return( false );
}

/////////////////////////////////////////////////////////////////////////////////////////Loop/////////////////////////////////////////////////////////////////////////

void loop() {
  sensors.requestTemperatures(); // Send the command to get temperatures
  float tempC1 = sensors.getTempC(top);
  float tempC2 = sensors.getTempC(bottom);
  float temperature;
  float humidity;

  

  

//Neo pixel activity


  //Red light means dump bucket is full

  if (digitalRead(dfloat) == HIGH) {
    pixels.setPixelColor(8, pixels.Color(RED));
    pixels.show();
  }
  else {
    pixels.setPixelColor(8, pixels.Color(NOLIGHT));
    pixels.show();
  }

  //Blue light means plants are being watered
  if (digitalRead(waterpump) == HIGH) {
    pixels.setPixelColor(9, pixels.Color(BLUE));
    pixels.show();
  }
  else {
    pixels.setPixelColor(9, pixels.Color(NOLIGHT));
    pixels.show();
  }

  //blue means resevior is being circulated
  if (digitalRead(circulatepump) == HIGH) {
    pixels.setPixelColor(10, pixels.Color(BLUE));
    pixels.show();
  }
  else {
    pixels.setPixelColor(10, pixels.Color(NOLIGHT));
    pixels.show();
  }

  //Green light means lights are on
  if (digitalRead(l2) == HIGH) {
    pixels.setPixelColor(11, pixels.Color(GREEN));
    pixels.show();
  }
  else {
    pixels.setPixelColor(11, pixels.Color(NOLIGHT));
    pixels.show();
  }

  //humidity
  if (humidity > 60.){
    pixels.setPixelColor(12, pixels.Color(BLUE));
  }
  if ((humidity < 59.99) && (humidity > 40)){
    pixels.setPixelColor(12, pixels.Color(GREEN));
  }
  if (humidity < 39.99){
    pixels.setPixelColor(12, pixels.Color(RED));
  }

  // side temp other
  if (tempC1 > 26.) {
    pixels.setPixelColor(13, pixels.Color(RED));
    pixels.show();
  }
  if ((tempC1 < 25.99) && (tempC1 > 20.00)) {
    pixels.setPixelColor(13, pixels.Color(GREEN));
    pixels.show();
  }
  if (tempC1 < 19.99) {
    pixels.setPixelColor(13, pixels.Color(BLUE));
    pixels.show();
  }


  // side temp
  if (tempC2 > 26.) {
    pixels.setPixelColor(14, pixels.Color(RED));
    pixels.show();
  }
  if ((tempC2 < 25.99) && (tempC1 > 20.00)) {
    pixels.setPixelColor(14, pixels.Color(GREEN));
    pixels.show();
  }
  if (tempC2 < 19.99) {
    pixels.setPixelColor(14, pixels.Color(BLUE));
    pixels.show();
  }


pixels.setPixelColor(15, pixels.Color(30, 20, 100));
  /*leave for Co2 upgrade
    // Red means co2 is on
    if (digitalRead( // ) == HIGH) {
    pixels.setPixelColor(15, pixels.Color(GREEN));
     pixels.show();
     else {
      pixels.setPixelColor(15, pixels.Color(NOLIGHT));
     pixels.show();
     }
    }
  */

     if ( measure_environment( &temperature, &humidity ) == true )
  {
   /* Measure temperature and humidity.  If the functions returns
     true, then a measurement is available. */
 
    //Temp&humid
    Serial.print( temperature, 1 );
    Serial.println( " C, " );
    Serial.print( humidity, 1 );
    Serial.println( " % " );
    Serial.println();
     
  
 
    //time
    DateTime now = rtc.now();
    char buf[100];
    strncpy(buf, "DD.MM.YYYY  hh:mm:ss\0", 100);
    Serial.println(now.format(buf));
  Serial.println();

Serial.print(tempC1, 1);
Serial.println(" C, ");
Serial.print(tempC2, 1);
Serial.println(" C, ");
Serial.println();

if (digitalRead(dfloat) == HIGH){
  Serial.println("Bucket Full!");
}
else{
  Serial.println("bucket Good");
}

if (digitalRead(waterpump) == HIGH){
  Serial.println("WaterPump Is On");
}
else{
  Serial.println("WaterPump Is Off");
}

if (digitalRead(circulatepump) == HIGH){
  Serial.println("Water Is Circulating");
}
else{
  Serial.println("Water Is Still");
}

if (digitalRead(l1) == HIGH){
  Serial.println("Light One Is On");
}
  else{
    Serial.println("Light One Is Off");
  }

if (digitalRead(l2) == HIGH){
  Serial.println("Light Two Is On");
}
else{
  Serial.println("Light Two Is Off");
}

if (digitalRead(circulatefan) == HIGH){
  Serial.println("Circulation Fans Are On");
}
else {Serial.println("Circulation Fans Are Off");
}

if (digitalRead(airstone) == HIGH){
  Serial.println("Resevior Is Being Aerated");
}
else {Serial.println("Airstone Is Off");
}


if (digitalRead(exhaustlight) == HIGH){
  Serial.println("Exhaust Fan Is On");
}
else {
  Serial.println("Exhaust Fan Is Off");
}

if (digitalRead(exhausttent) == HIGH){
  Serial.println("Tent Is Being Exhausted");
}
else {
  Serial.println("Air Is Still"); // Co2 upgrade, will say Co2 is on, leave
}
Serial.println();

  }
}

Hi,

Just to confirm… are you connecting the data line of the 2 sensors to the same pin on the arduino?

no the two ds18b2o are on one pin and the single dht22 is on its own pin

I think its the request.temperature line thats blocking the Dht22. But i still dont get a reading if they are both plugged into there respected pins.

The library for the dht22 im using is a non blocking library. And uses millis to request the temp and humidity. As the ds18b20 polls the device i believe.

It also seems that this is a pretty standard problem and that people cant get them working together.

Any solution that comes about has to be non blocking as theres a shit ton of code. And alot more yet to test and write.

If i have to ditch one it will be the dht22

You may follow this post consisting of 2xDS18B20 and 1xDHT22 as a tutorial guide.

//12-bit default resolution; external power supply

#include<OneWire.h>
#define OneWireBusPin 8
#include <SimpleDHT.h>
#define pinDHT22 2
SimpleDHT22 dht22;


float dsTempA, dsTempB;//Temp01, Temp02;

OneWire ds(OneWireBusPin);  //2
byte addrdsA[8];         //to hold 64-bit ROM Codes of DS-A
byte addrdsB[8];        //to ho;d 64-bit ROM-code DS-B
byte data[9];        //buffer to hold data coming from DS18B20
float celsius;

void setup() 
{
  Serial.begin(9600);
  //----------------------------
  
  ds.reset();
  ds.search(addrdsA);  //collect 64-bit ROM code from sensor (DS-A)
  ds.search(addrdsB); //auto collec of ROM address of DS-B
}

void loop()
{
  Serial.println("==Reading from DS18B20 Sensors================");
  showTempAOnSM();    //show temp of DS-A on Serial Monitor
  showTempBOnSM();
  
  Serial.println("==Reading form DHT22 Sensor=================");
  showHumiTempOnSM();  //show Temp/Humidity on Serial Monitor
  delay(2000);        //Humidity acquisition delay
}

void showTempAOnSM()
{
 //----------------------------
 ds.reset();       //bring 1-Wire into idle state
 ds.select(addrdsA); //slect with DS-1 with address addr1
 ds.write(0x44);    //conversion command
 delay(1000);   //data ready withinh DS18B20 or poll status word
 //---------------------------

 ds.reset();
 ds.select(addrdsA);  //selectimg the desired DS18B20
 ds.write(0xBE);    //Function command to read Scratchpad Memory (9Byte)
 ds.read_bytes(data, 9); //data comes from DS-A and are saved into buffer data[8]
 //---------------------------------

  int16_t raw = (data[1] << 8) | data[0]; //---data[0] and data[1] contains temperature data : 12-bit resolution-----
  celsius = (float)raw / 16.0;  //12-bit resolution
  dsTempA = celsius;
  Serial.print(celsius);
  Serial.println("  Reading from DS-A");
}


void showTempBOnSM()
{
 ds.reset();       //bring 1-Wire into idle state
 ds.select(addrdsB); //slect with DS-1 with address addr1
 ds.write(0x44);    //conversion command
 delay(1000);   //data ready withinh DS18B20 or poll status word
 //---------------------------

 ds.reset();
 ds.select(addrdsB);  //selectimg the desired DS18B20
 ds.write(0xBE);    //Function command to read Scratchpad Memory (9Byte)
 ds.read_bytes(data, 9); //data comes from DS-B and are saved into buffer data[8]
  //---------------------------------

  int16_t raw = (data[1] << 8) | data[0]; //---data[0] and data[1] contains temperature data : 12-bit resolution-----
  celsius = (float)raw / 16.0;  //12-bit resolution
  dsTempB = celsius;
  Serial.print(celsius);
  Serial.println("  Reading from DS-B");
 }

void showHumiTempOnSM()
{
  float temperature = 0;
  float humidity = 0;
  byte data[40] = {0};
  int err = SimpleDHTErrSuccess;
  if ((err = dht22.read2(pinDHT22, &temperature, &humidity, data)) != SimpleDHTErrSuccess) 
  {
  Serial.print("Read DHT22 failed, err="); 
  Serial.println(err);
  return;
  }
  
  Serial.print((float)temperature); Serial.print(" *C, ");
  Serial.print((float)humidity); Serial.println(" RH%");
  Serial.println();
}

GolamMostafa:
You may follow this post consisting of 2xDS18B20 and 1xDHT22 as a tutorial guide.

//12-bit default resolution; external power supply

#include<OneWire.h>
#define OneWireBusPin 8
#include <SimpleDHT.h>
#define pinDHT22 2
SimpleDHT22 dht22;

float dsTempA, dsTempB;//Temp01, Temp02;

OneWire ds(OneWireBusPin);  //2
byte addrdsA[8];        //to hold 64-bit ROM Codes of DS-A
byte addrdsB[8];        //to ho;d 64-bit ROM-code DS-B
byte data[9];        //buffer to hold data coming from DS18B20
float celsius;

void setup()
{
  Serial.begin(9600);
  //----------------------------
 
  ds.reset();
  ds.search(addrdsA);  //collect 64-bit ROM code from sensor (DS-A)
  ds.search(addrdsB); //auto collec of ROM address of DS-B
}

void loop()
{
  Serial.println("==Reading from DS18B20 Sensors================");
  showTempAOnSM();    //show temp of DS-A on Serial Monitor
  showTempBOnSM();
 
  Serial.println("==Reading form DHT22 Sensor=================");
  showHumiTempOnSM();  //show Temp/Humidity on Serial Monitor
  delay(2000);        //Humidity acquisition delay
}

void showTempAOnSM()
{
//----------------------------
ds.reset();      //bring 1-Wire into idle state
ds.select(addrdsA); //slect with DS-1 with address addr1
ds.write(0x44);    //conversion command
delay(1000);  //data ready withinh DS18B20 or poll status word
//---------------------------

ds.reset();
ds.select(addrdsA);  //selectimg the desired DS18B20
ds.write(0xBE);    //Function command to read Scratchpad Memory (9Byte)
ds.read_bytes(data, 9); //data comes from DS-A and are saved into buffer data[8]
//---------------------------------

int16_t raw = (data[1] << 8) | data[0]; //—data[0] and data[1] contains temperature data : 12-bit resolution-----
  celsius = (float)raw / 16.0;  //12-bit resolution
  dsTempA = celsius;
  Serial.print(celsius);
  Serial.println("  Reading from DS-A");
}

void showTempBOnSM()
{
ds.reset();      //bring 1-Wire into idle state
ds.select(addrdsB); //slect with DS-1 with address addr1
ds.write(0x44);    //conversion command
delay(1000);  //data ready withinh DS18B20 or poll status word
//---------------------------

ds.reset();
ds.select(addrdsB);  //selectimg the desired DS18B20
ds.write(0xBE);    //Function command to read Scratchpad Memory (9Byte)
ds.read_bytes(data, 9); //data comes from DS-B and are saved into buffer data[8]
  //---------------------------------

int16_t raw = (data[1] << 8) | data[0]; //—data[0] and data[1] contains temperature data : 12-bit resolution-----
  celsius = (float)raw / 16.0;  //12-bit resolution
  dsTempB = celsius;
  Serial.print(celsius);
  Serial.println("  Reading from DS-B");
}

void showHumiTempOnSM()
{
  float temperature = 0;
  float humidity = 0;
  byte data[40] = {0};
  int err = SimpleDHTErrSuccess;
  if ((err = dht22.read2(pinDHT22, &temperature, &humidity, data)) != SimpleDHTErrSuccess)
  {
  Serial.print(“Read DHT22 failed, err=”);
  Serial.println(err);
  return;
  }
 
  Serial.print((float)temperature); Serial.print(" *C, “);
  Serial.print((float)humidity); Serial.println(” RH%");
  Serial.println();
}

Cant . Its a blocking route. I need non blocking.

You may make an arrangement to interrupt the MCU at every 2-sec interval; the MCU will go the ISR and will acquire Temperature, Humidity, and etc. whatever is required!

GolamMostafa: You may make an arrangement to interrupt the MCU at every 2-sec interval; the MCU will go the ISR and will acquire Temperature, Humidity, and etc. whatever is required!

That sounds really fancy. What does it all mean?

Im a straight up beginner...

When used as-is, out of the box, temperature readings from the DallasTemperature library can be blocking.

I’ve written a simple wrapper for this library that makes it easier to use it in a non-blocking manner: https://github.com/gfvalvo/nonBlockingDS18B20

The device is so slow (relative to a micro-controller) that interrupts aren’t required, just a non-blocking loop() function.

Give the example a look. Feel free to use the wrapper or just the techniques contained therein.

gfvalvo: When used as-is, out of the box, temperature readings from the DallasTemperature library can be blocking.

I’ve written a simple wrapper for this library that makes it easier to use it in a non-blocking manner: https://github.com/gfvalvo/nonBlockingDS18B20

The device is so slow (relative to a micro-controller) that interrupts aren’t required, just a non-blocking loop() function.

Give the example a look. Feel free to use the wrapper or just the techniques contained therein.

Cool ill go threw it when i get home. Thanks

That sounds really fancy. What does it all mean?

Interrupt is a process in which we don't need to check again and again if the expected guest has arrived or not; rather, let the guest inform us once he has arrived by pressing the switch of the calling bell. We are interrupted by the music of the calling bell; we leave behind our jobs whatever we were doing; we opened the door, receive the guest, and let him sit down. After that, we go back to the jobs that we were doing before interruption. This is the very simple definition of an Interrupt Process.

Here, we have two jobs -- the job that we were doing before interruption, which is called the Main Line Program (MLP); the other one is the Side Job (aka Interrupt Service Routine, ISR) that we did after the interruption.

For further reading you are referred to this link.

Give the example a look. Feel free to use the wrapper or just the techniques contained therein.

Let me give you the good news first, and then I will add my comments/queries/questions later either editing this post or in a new post.

I downloaded the zip file of your Library and have included in the IDE. I have executed the example of the Library in the following setup of 2xDS18B20 sensors; it has fantastically worked; particularly, the Serial Monitor Display is appealing. Thanks+ for the good job. |500x344

So what is this below if you have in your schematic DHT22 connected to pin 2 static const int DHT_SENSOR_PIN = 12;

noweare: So what is this below if you have in your schematic DHT22 connected to pin 2 static const int DHT_SENSOR_PIN = 12;

One is declaring the type of sensor and one is the pin. Go re read it.

The code is correct. The ds request temp function is blocking the dth22.

With only one or the other plugged in and the request temp omitted then the dht22 works. And vice versa. So gonna try guys ds non blocking code.

The ds request temp function is blocking the dth22.

The recommended sampling time for DHT22 is 2/2.5 sec.

The conversion time of a 12-bit resolution DS18B20 is maximum 750 mS (in worse case let us take it as 1-sec). Even, we make a sequential operation of two DS18B20 sensors, the cumulative delay is maximum 2 sec. So, after 2-sec delay, we are reading the response of the DHT22; we are not missing the data of DHT22! Then --

Why are you expressing the quoted text?

GolamMostafa: The recommended sampling time for DHT22 is 2/2.5 sec.

The conversion time of a 12-bit resolution DS18B20 is maximum 750 mS (in worse case let us take it as 1-sec). Even, we make a sequential operation of two DS18B20 sensors, the cumulative delay is maximum 2 sec. So, after 2-sec delay, we are reading the response of the DHT22; we are not missing the data of DHT22! Then --

Why are you expressing the quoted text?

ya so my whole print code is a 4 second milli delay, or did you miss that? explain to me again why request.temperature isent at fault?

ok. so i got the non blocking dht22 and non blocking ds182bo working together,
what a pain,

just wondering if anyone sees a way to make it more clean ,

please ignore anything that doesent have to do with this

/*Grow tent brain, 
project started march 2018


people who helped along the way 

arduino.cc
- odometer
-sherzaad


*

#include <Button.h>
#include <Adafruit_NeoPixel.h>
#ifdef __AVR__
#include <avr/power.h>
#endif
#include <dht_nonblocking.h>
#include "RTClib.h"
#include <Wire.h>
#include <LiquidCrystal.h>
DS3231 rtc;
#include <OneWire.h>
#include <Arduino.h>
#include "nonBlockingDS18B20.h"




enum machineStates {
  IDLE, WAITING_FOR_CONVERSION, ABORTED
};
const uint8_t ONE_WIRE_BUS = 12;                                         // Change this to Pin # connected to OneWire bus
const uint8_t RESOLUTION = 9;
const unsigned long maxWaitTime = 5000;
const unsigned long interMeasurementPeriod = 1000;
machineStates currentState;
unsigned long measurementStartTime, measurementStopTime;
unsigned long interMeasurementTimer;
OneWire oneWire(ONE_WIRE_BUS);
nonBlockingDS18B20 tempSensors(&oneWire);
uint8_t numDS18;

                                   
static const int DHT_SENSOR_PIN = 13;                                           //DHT22 pin number here
#define DHT_SENSOR_TYPE DHT_TYPE_22                                   //other pin infor for libraries
DHT_nonblocking dht_sensor( DHT_SENSOR_PIN, DHT_SENSOR_TYPE );



////////////////////////////////////////////////////////////////////////////////////////////////////////////Setup//////////////////////////////////////////////////////////



void setup() {
  Serial.begin(9600);
  Wire.begin();
 
  rtc.begin();
  button1.begin();
  button2.begin();
  button3.begin();
  button4.begin();
  button5.begin();
  button6.begin();
  button7.begin();
  button8.begin();
  pixels.begin();
  pixels.setBrightness(pixelbright);
  rtc.adjust(DateTime(__DATE__, __TIME__));
  if (! rtc.isrunning()) {
    Serial.println("RTC is NOT running!");
  }
    uint8_t index;
  DeviceAddress addr;
  // Locate and Enumerate the DS18xx-type Temperature Sensors
  numDS18 = tempSensors.begin(RESOLUTION);
  
  //set
}
//Set DHT22 nnblocking
static bool measure_environment( float *temperature, float *humidity )
{
  static unsigned long measurement_timestamp = millis( );

  /* Measure once every four seconds. */
  if( millis( ) - measurement_timestamp > 4000ul )
  {
    if( dht_sensor.measure( temperature, humidity ) == true )
    {
      measurement_timestamp = millis( );
      return( true );
    }
  }

  return( false );
}

/////////////////////////////////////////////////////////////////////////////////////////Loop/////////////////////////////////////////////////////////////////////////

void loop() {

  float temperature;
  float humidity;
float tempC1 = tempSensors.getLatestTempC(0);
float tempC2 = tempSensors.getLatestTempC(1);




  unsigned long currentMillis;
  static uint32_t loopCount = 0;

  currentMillis = millis();
  switch (currentState) {
  case WAITING_FOR_CONVERSION:
    if ((tempSensors.isConversionDone()) && ( measure_environment( &temperature, &humidity ) == true )) {
      measurementStopTime = currentMillis;
        Serial.print(tempC1);
        Serial.println(F(" (C), "));
Serial.print(tempC2);
        Serial.println(F(" (C), "));
        //Temp&humid
    Serial.print( temperature);
    Serial.println( " (C), " );
    Serial.print( );
    Serial.println( " (%) " );
    Serial.println();
     
  




   /* Measure temperature and humidity.  If the functions returns
     true, then a measurement is available. */
 
    
 
    //time
    DateTime now = rtc.now();
    char buf[100];
    strncpy(buf, "DD.MM.YYYY  hh:mm:ss\0", 100);
    Serial.println(now.format(buf));
  Serial.println();
 


  

      currentState = IDLE;
      interMeasurementTimer = currentMillis;
    } 
    break;

  case IDLE:
    // Check if it's time to start another measurement
    if (currentMillis - interMeasurementTimer >= interMeasurementPeriod) {
      currentState = WAITING_FOR_CONVERSION;
      loopCount = 0;
      // Kick off another set of non-blocking sensor readings
      measurementStartTime = currentMillis;
      if (!tempSensors.startConvertion()) {
        Serial.println(F("Failed to Start Conversion Cycle, Aborting"));
        currentState = ABORTED;
      }
    }
    break;
  case ABORTED:
    break;
  }