Ingo Lohs
Published © GPL3+

MyDallas DS18B20 Controlled by Photon

A water-resistant temperature sensor is suitable to signal the reaching of the core temperature of the meat during the grilling time.

EasyProtip1 hour667
MyDallas DS18B20 Controlled by Photon

Things used in this project

Hardware components

Photon
Particle Photon
×1
DS18B20
×1
Resistor 4.75k ohm
Resistor 4.75k ohm
×1
Breadboard (generic)
Breadboard (generic)
×1
Jumper wires (generic)
Jumper wires (generic)
×1
Alligator Clips
Alligator Clips
optional but easy to fix the sensor
×1

Software apps and online services

Maker service
IFTTT Maker service
Trigger with E-Mail if threshold is reached
Blynk
Blynk
stay informed with the measured values by using Blynk-Widgets

Story

Read more

Code

changed Particle-Example from Maker Kit

C/C++
#include <blynk.h>
#include <OneWire.h>

/************************************************************************
This sketch reads the temperature from a 1-Wire device and then publishes
to the Particle cloud. From there, IFTTT can be used to log the date,
time, and temperature to a Google Spreadsheet. Read more in our tutorial
here: https://docs.particle.io/tutorials/topics/maker-kit

Temperature is read from: DS18S20, DS18B20, DS1822, DS2438

Expanding on the enumeration process in the address scanner, this example
reads the temperature and outputs it from known device types as it scans.

I/O setup:
These made it easy to just 'plug in' my 18B20 (note that a bare TO-92
sensor may read higher than it should if it's right next to the Photon)

A pull-up resistor is required on the signal line. The spec calls for a 4.7K.

************************************************************************

Rindfleisch	    englisch bis rosa	  medium	    well done (durch)
Filet	          38-55°C	            55-62°C	    ab 63°C
Lende/Roastbeef	38-55°C	            55-60°C	    ab 65°C
Rouladen	      --	                --	        70°C
Braten	        --	                --	        85-90°C
Tafelspitz	    --	                --	        90°C
Entrecoté	      --	                55-58°C	    --

************************************************************************/

// You should get Auth Token in the Blynk App.
// Go to the Project Settings (nut icon).
char auth[] = ">>>your code here<<<";

OneWire ds = OneWire(D4);  // 1-wire signal on pin D4
unsigned long lastUpdate = 0;
float lastTemp;

float temperature;
float temperature_threshold = 55.00; 
unsigned long lastmillis = 0;
#define vThresholdSlider V3


// *********    

    BLYNK_WRITE(vThresholdSlider)     // Blynk app WRITES Slider widget on V3
    {
    temperature_threshold = param.asInt();
    Serial.println("******************************");    
    Serial.print(temperature_threshold);    
    Serial.println(" C = new Temperature Threshold");    
    Serial.println("******************************");    
    }
    
// *********  

void setup() {
  Serial.begin(9600);
  Blynk.begin(auth);
}

void loop(void) {
Blynk.run();   
//    Blynk.virtualWrite(V4, humidity_threshold); 
//    !!! http://docs.blynk.cc/#troubleshooting-flood-error  
//    DO NEVER in LOOP!

            // update in 2 sec intervals
            if ((millis() - lastmillis) > 2000) {
                lastmillis = millis();
                readData();
            }
}


// up to here, it is the same as the address acanner
// we need a few more variables for this example

void readData() {
  byte i;
  byte present = 0;
  byte type_s;
  byte data[12];
  byte addr[8];
  float celsius, fahrenheit;

  if ( !ds.search(addr)) {
    Serial.println("No more addresses.");
    Serial.println();
    ds.reset_search();
    delay(250);
    return;
  }

  // The order is changed a bit in this example
  // first the returned address is printed

  Serial.print("ROM =");
  for( i = 0; i < 8; i++) {
    Serial.write(' ');
    Serial.print(addr[i], HEX);
  }

  // second the CRC is checked, on fail,
  // print error and just return to try again

  if (OneWire::crc8(addr, 7) != addr[7]) {
      Serial.println("CRC is not valid!");
      return;
  }
  Serial.println();

  // we have a good address at this point
  // what kind of chip do we have?
  // we will set a type_s value for known types or just return

  // the first ROM byte indicates which chip
  switch (addr[0]) {
    case 0x10:
      Serial.println("  Chip = DS1820/DS18S20");
      type_s = 1;
      break;
    case 0x28:
      Serial.println("  Chip = DS18B20");
      type_s = 0;
      break;
    case 0x22:
      Serial.println("  Chip = DS1822");
      type_s = 0;
      break;
    case 0x26:
      Serial.println("  Chip = DS2438");
      type_s = 2;
      break;
    default:
      Serial.println("Unknown device type.");
      return;
  }

  // this device has temp so let's read it

  ds.reset();               // first clear the 1-wire bus
  ds.select(addr);          // now select the device we just found
  // ds.write(0x44, 1);     // tell it to start a conversion, with parasite power on at the end
  ds.write(0x44, 0);        // or start conversion in powered mode (bus finishes low)

  // just wait a second while the conversion takes place
  // different chips have different conversion times, check the specs, 1 sec is worse case + 250ms
  // you could also communicate with other devices if you like but you would need
  // to already know their address to select them.

  delay(1000);     // maybe 750ms is enough, maybe not, wait 1 sec for conversion

  // we might do a ds.depower() (parasite) here, but the reset will take care of it.

  // first make sure current values are in the scratch pad

  present = ds.reset();
  ds.select(addr);
  ds.write(0xB8,0);         // Recall Memory 0
  ds.write(0x00,0);         // Recall Memory 0

  // now read the scratch pad

  present = ds.reset();
  ds.select(addr);
  ds.write(0xBE,0);         // Read Scratchpad
  if (type_s == 2) {
    ds.write(0x00,0);       // The DS2438 needs a page# to read
  }

  // transfer and print the values

  Serial.print("  Data = ");
  Serial.print(present, HEX);
  Serial.print(" ");
  for ( i = 0; i < 9; i++) {           // we need 9 bytes
    data[i] = ds.read();
    Serial.print(data[i], HEX);
    Serial.print(" ");
  }
  Serial.print(" CRC=");
  Serial.print(OneWire::crc8(data, 8), HEX);
  Serial.println();

  // Convert the data to actual temperature
  // because the result is a 16 bit signed integer, it should
  // be stored to an "int16_t" type, which is always 16 bits
  // even when compiled on a 32 bit processor.
  int16_t raw = (data[1] << 8) | data[0];
  if (type_s == 2) raw = (data[2] << 8) | data[1];
  byte cfg = (data[4] & 0x60);

  switch (type_s) {
    case 1:
      raw = raw << 3; // 9 bit resolution default
      if (data[7] == 0x10) {
        // "count remain" gives full 12 bit resolution
        raw = (raw & 0xFFF0) + 12 - data[6];
      }
      celsius = (float)raw * 0.0625;
      break;
    case 0:
      // at lower res, the low bits are undefined, so let's zero them
      if (cfg == 0x00) raw = raw & ~7;  // 9 bit resolution, 93.75 ms
      if (cfg == 0x20) raw = raw & ~3; // 10 bit res, 187.5 ms
      if (cfg == 0x40) raw = raw & ~1; // 11 bit res, 375 ms
      // default is 12 bit resolution, 750 ms conversion time
      celsius = (float)raw * 0.0625;
      break;

    case 2:
      data[1] = (data[1] >> 3) & 0x1f;
      if (data[2] > 127) {
        celsius = (float)data[2] - ((float)data[1] * .03125);
      }else{
        celsius = (float)data[2] + ((float)data[1] * .03125);
      }
  }

  // remove random errors
  if((((celsius <= 0 && celsius > -1) && lastTemp > 5)) || celsius > 125) {
      celsius = lastTemp;
  }
  

  fahrenheit = celsius * 1.8 + 32.0;
  lastTemp = celsius;
  Serial.print("  Temperature = ");
  Serial.print(celsius);
  Serial.print(" Celsius, ");
  Serial.print(fahrenheit);
  Serial.println(" Fahrenheit");

  // now that we have the readings, we can publish them to the cloud
  String temperature = String(celsius); // store temp in "temperature" string
  Particle.publish("temperature_meat", temperature, PRIVATE); // publish to cloud
  
    if ((celsius) <= temperature_threshold) 
        {
        Serial.println("Celsius <= Threshold");
        }
      else
        {  
        Serial.println("Attention - Core Temperature from Meat is reached!");
        Particle.publish("temperature_meat", "Attention", PRIVATE); // triggers IFTTT
    }
  
  Blynk.virtualWrite(V0, temperature);
  Blynk.virtualWrite(V1, temperature);
  Blynk.virtualWrite(V2, temperature_threshold); 

}

Github

Credits

Ingo Lohs

Ingo Lohs

29 projects • 43 followers
I am well over 40 years and come from the middle of Germany. You can contact me also in German. Donation for projects: paypal.me/ingolohs
Contact

Comments

Add projectSign up / Login