Alexander Dechant, Jerome Stull, Danilo12

Published April 17, 2018 © GPL3+

Thermo-Texter

Takes the difference between two temperature sensors and texts the results to your phone.

BeginnerFull instructions provided1 hour757

Things used in this project

Hardware components

Adafruit Waterproof DS18B20 Digital temperature sensor

Maxim Integrated DS18B20 Programmable Resolution 1-Wire Digital Thermometer

LED (generic)

Arduino SSD1306 OLED

Jumper wires (generic)

Particle Photon

Software apps and online services

IFTT

Adafruit

Particle Pi

Story

Overview

The thermo-texter was created to fulfill the need for a real time comparison system, allowing the user to simultaneously read temperatures from two separate locations. The first photon (sensor one) used in this project was placed at an indoor living space, while the second photon (sensor two) measured outdoor temperature. The third photon then receives this data and then uses it to report it back to the user through a Short Message Service (SMS). It notifies the user only when a text is sent to the device, signaled by the LED light turning on. In addition it displays this data continuously on a small LED screen, allowing the user to make decisions about the information he or she receives.

Our configuration uses an exposed and a sealed DS18B20 sensor to collect temperature data, allowing for different combinations depending on the application required. The Photon configuration containing the sealed DS18B20 is shown in the picture below.

Image of Photon taking outside temperature measurements

Video of thermo-texter changing temperature as outside temperature thermometer is being held

The Primary Photon in the video funnels data from two other photons and displays the information on the OLED screen. The other two collect and transfer temperature data to the primary one. When the user requests temperature information via text, the photon's LED turns on to acknowledge the inquiry.

It's functionality can be easily expanded with additional sensors and simple changes to the programming. For example, by using sealed sensors, it could potentially be used to measure differences in water temperature in a pool or other type of liquid based circulation system where exposure to external elements needs to be avoided. Multiple sensors could be placed throughout the house allowing the user to record data on the fluctuations of temperature during different seasons and throughout different rooms. A sensor placed by the exhaust fan of a PC can be used to compare the outtake temperature to the environmental temperature of the room.

It could even be used more generally to read temperatures in different locations, or the temperature in your basement, car, garage, shed, storage unit, summer home, yacht, nuclear bunker, or evil villain lair. The possibilities are endless!

Setup of IFTTT for Messaging

Information gathered from the photon can be accessed on demand via texts by utilizing “If This Then That”. Getting started with IFFT is quite a simple process, requiring an account (https://ifttt.com/).To establish communication with the photon, there are two applets that need to be created. The first applet is the text activated event generator, which publishes an event that is later discovered by the photon.

1 / 5 • Steps to set up IFTTT

Final configuration for Particle to receive texts

The final configuration should appear as shown in the image above. The tag can be altered to whatever the user wants to text the photon. Additionally, the published event name should be changed here and in the code as well in order for the user to receive the events without interference from other photons.

After following these steps, repeat the process using Particle for the “This” statement and SMS for the “That” statement. Using the image below as reference, the final configuration should be as follows:

Final configuration to return data to user

IFTTT was then used to return the data back to the user. Again, the “Event Name” should be changed here and in the code to a unique identifier, ensuring the user receives the data directly back to the photon. The device name or ID should be set to the name of the user’s individual photon and the message can be configured to output the event’s contents; any changes to the message must be made directly within the code.

Adafruit Publishing

The data is output continuously to an Adafruit graph, allowing the user to record and view both temperatures at any point in time.

Adafruit was set up through IFTTT with the setup shown below, using the “This” statement forthe Particle and the “Then” statement using Adafruit:

IFTTT setup for Adafruit publishing

The above IFTTT statement looks for the inside temperature photon to publish data, and then in turn publishes the data from the inside temperature photon to a feed in Adafruit.

Two further IFTTT statements were created in the same manner as the one above, grabbing data from both the indoor and outdoor photons at the same time and sending them to feeds in Adafruit. These two feeds are then graphed in a Adafruit dashboard for a comparison of the overlaid graphs.

Live examples of the data being displayed can be found at the following links: https://io.adafruit.com/Carud/feeds/welcome-feed

Live Graph of Inside Temperature Sensor data: https://io.adafruit.com/Carud/dashboards/temperature

Code

// This #include statement was automatically added by the Particle IDE.
#include <Adafruit_SSD1306.h>

float T1;
float T2;
float difference;

int led1 = D0;

#define OLED_DC     D3
#define OLED_CS     D4
#define OLED_RESET  D5
Adafruit_SSD1306 display(OLED_DC, OLED_RESET, OLED_CS);


void setup() {
  Particle.subscribe("Naas_temperature", FirstTemp);
  Particle.subscribe("0042_temperature", SecondTemp);
  
  Particle.subscribe("TempReturn0595", TempReturn);
  
  pinMode(led1, OUTPUT);
  
  display.begin(SSD1306_SWITCHCAPVCC);
  
  display.setTextSize(2); //Adjust text size here to fit on screen
  display.setTextColor(WHITE);
  display.setTextWrap(false);
}

void FirstTemp(const char *event, const char *data1) {
    T1 = atof(data1);
    Serial.print(T1);
}

void SecondTemp(const char *event, const char *data2) {
    T2 = atof(data2);
    Serial.print(T2);
}


void TempReturn (const char *event, const char *data3) {
    String printTemp;
    
    if (strcmp(data3, "True") == 0) {
        
        printTemp = ("Inside temperature: " + String(int(T1)) + "; Outside temperature: " + String(int(T2)) + "; Their exact difference is: " + String(difference)); //Can edit text here to change what is sent to phone
        Particle.publish("TempCollect0595", printTemp);
        
        digitalWrite(led1, HIGH);
        delay(30000); //Can adjust value to change length of time LED lights (ms)
        digitalWrite(led1, LOW);
    }
}

void loop() {
    if (Particle.connected() == false) {
        Particle.connect();
    }
    
    Particle.publish("Temp1", String(T1));
    Particle.publish("Temp2", String(T2));
    difference = T2 - T1;
    
  display.clearDisplay();
  display.setCursor(0,0);
  display.print("In: ");
  display.print(int(T1));
  display.println(" F");
  display.print("Out: ");
  display.print(int(T2));
  display.println(" F");
  display.println("Diff: ");
  display.print(difference);
  display.display();
}

// This #include statement was automatically added by the Particle IDE.
#include <OneWire.h>

OneWire ds = OneWire(D4);  // 1-wire signal on pin D4

unsigned long lastUpdate = 0;

float lastTemp;
int led1 = D0; 
int led2 = D7; 

void setup() {
  Serial.begin(9600);
  // Set up 'power' pins, comment out if not used!
  pinMode(D3, OUTPUT);
  pinMode(D5, OUTPUT);
  digitalWrite(D3, LOW);
  digitalWrite(D5, HIGH);
  
  Particle.subscribe("TempReturn0595", Blinker);
     
  pinMode(led1, OUTPUT);
  pinMode(led2, OUTPUT);
}

void Blinker(const char *event, const char *data) {
    if (strcmp(data,"True")==0) {

  // To blink the LED, first we'll turn it on...
  digitalWrite(led1, HIGH);
  digitalWrite(led2, HIGH);

  // We'll leave it on for 1 second...
  delay(1000);

  // Then we'll turn it off...
  digitalWrite(led1, LOW);
  digitalWrite(led2, LOW);

  // Wait 1 second...
  delay(1000);

  // And repeat!
  }
}

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

void loop(void) {
  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 > 50) {
      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(fahrenheit); // store temp in "temperature" string
  Particle.publish("0042_temperature", temperature, PUBLIC); // publish to cloud
  delay(10000); // 60 second delay
}

// This #include statement was automatically added by the Particle IDE.
#include <OneWire.h>


OneWire ds = OneWire(D4);  // 1-wire signal on pin D4

unsigned long lastUpdate = 0;

float lastTemp;
int led1 = D0; 
int led2 = D7; 

void setup() {
  Serial.begin(9600);
  // Set up 'power' pins, comment out if not used!
  pinMode(D3, OUTPUT);
  pinMode(D5, OUTPUT);
  digitalWrite(D3, LOW);
  digitalWrite(D5, HIGH);
  
  Particle.subscribe("TempReturn0595", Blinker);
     
  pinMode(led1, OUTPUT);
  pinMode(led2, OUTPUT);
  
}


void Blinker(const char *event, const char *data) {
    if (strcmp(data,"True")==0) {

  // To blink the LED, first we'll turn it on...
  digitalWrite(led1, HIGH);
  digitalWrite(led2, HIGH);

  // We'll leave it on for 1 second...
  delay(1000);

  // Then we'll turn it off...
  digitalWrite(led1, LOW);
  digitalWrite(led2, LOW);

  // Wait 1 second...
  delay(1000);

  // And repeat!
  }
}



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

void loop(void) {
  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 > 45) {
      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(fahrenheit); // store temp in "temperature" string
  Particle.publish("Naas_temperature", temperature, PUBLIC); // publish to cloud
  delay(10000); // 10 second delay
  
}

Thermo-Texter

Things used in this project

Hardware components

Software apps and online services

Story

Overview

Setup of IFTTT for Messaging

Adafruit Publishing

Schematics

Primary Photon

Outside Temperature

Inside Temperature Photon

Code

Primary Photon

Outside Temperature Code

Inside Temperature Code

Credits

Alexander Dechant

Jerome Stull

Danilo12

Comments

Embed the widget on your own site

Thermo-Texter

Thermo-Texter

Things used in this project

Hardware components

Software apps and online services

Story

Overview

Setup of IFTTT for Messaging

Adafruit Publishing

Schematics

Primary Photon

Outside Temperature

Inside Temperature Photon

Code

Primary Photon

Outside Temperature Code

Inside Temperature Code

Credits

Alexander Dechant

Jerome Stull

Danilo12

Comments

Related channels and tags