Home Tags Posts tagged with "Temperature sensor"
Tag:

Temperature sensor

STM32

STM32 Nucleo and MCP9808 digital temperature sensor Arduino example

by shedboy71
written by shedboy71

OK we are now going to look at an MCP9808 attached to the STM32 Nucleo and all development will be done on the Arduino IDE – Install STM32 support in the Arduino IDE

The MCP9808 digital temperature sensor converts temperatures between -20°C and +100°C to a digital word with ±0.5°C (max.) accuracy. The MCP9808 comes with user-programmable registers that provide flexibility for temperature sensing applications. The registers allow user-selectable settings such as Shutdown or low-power modes and the specification of temperature Event and Critical output boundaries. When the temperature changes beyond the specified boundary limits, the MCP9808 outputs an Event signal.

The user has the option of setting the event output signal polarity as an active-low or active-high comparator output for thermostat operation, or as temperature event interrupt output for microprocessor-based systems. The event output can also be configured as a Critical temperature output.

This sensor has an industry standard 2-wire, SMBus and Standard I2C™Compatible compatible (100kHz/400kHz bus clock) serial interface, allowing up to eight sensors to be controlled in a single serial bus.

Features

Accuracy:
±0.25°C (typical) from -40°C to +125°C
±0.5°C (maximum) from -20°C to +100°C

User Selectable Measurement Resolution:
0.5°C, 0.25°C, 0.125°C, 0.0625°C

User Programmable Temperature Limits:
Temperature Window Limit
Critical Temperature Limit

User Programmable Temperature Alert Output
Operating Voltage Range: 2.7V to 5.5V

More details about the sensor at http://www.microchip.com/wwwproducts/en/MCP9808

 

Connection

stm32 and mcp9808

stm32 and mcp9808

Code

You will need the adafruit MCP9808 library which is available at https://github.com/adafruit/Adafruit_MCP9808_Library/archive/master.zip

[codesyntax lang=”cpp”]

#include <Wire.h>
#include "Adafruit_MCP9808.h"

// Create the MCP9808 temperature sensor object
Adafruit_MCP9808 tempsensor = Adafruit_MCP9808();

void setup() {
  Serial.begin(9600);
  
  if (!tempsensor.begin()) 
  {
    Serial.println("Couldn't find MCP9808!");
    while (1);
  }
}

void loop() {
  // Read and print out the temperature, then convert to *F
  float c = tempsensor.readTempC();
  float f = c * 9.0 / 5.0 + 32;
  Serial.print("Temp: "); 
  Serial.print(c); 
  Serial.print(" C\t"); 
  Serial.print(f); 
  Serial.println(" F");
  delay(250);
  
  tempsensor.shutdown_wake(1);
  delay(2000);
  tempsensor.shutdown_wake(0);
  
   
}

[/codesyntax]

 

Results

Open the serial monitor and you should see something like this

Temp: 24.94 C 76.89 F
Temp: 27.50 C 81.50 F
Temp: 28.25 C 82.85 F
Temp: 27.44 C 81.39 F
Temp: 26.75 C 80.15 F
Temp: 26.50 C 79.70 F
Temp: 26.25 C 79.25 F
Temp: 26.06 C 78.91 F
Temp: 25.94 C 78.69 F
Temp: 25.75 C 78.35 F

Links

Adafruit MCP9808 High Accuracy I2C Temperature Sensor Breakout Board [ADA1782]

0 comment
0 FacebookTwitterPinterestEmail
STM32

STM32 Nucleo and HDC1008 sensor Arduino example

by shedboy71
written by shedboy71

OK we are now going to look at an HDC1008 attached to the STM32 Nucleo and all development will be done on the Arduino IDE – Install STM32 support in the Arduino IDE

The HDC1008 is a digital humidity sensor with integrated temperature sensor that provides excellent measurement accuracy at very low power. The device measures humidity based on a novel capacitive sensor. The humidity and temperature sensors are factory calibrated.

The sensing element of the HDC1008 is placed on the bottom part of the device, which makes the HDC1000 more robust against dirt, dust, and other environmental contaminants. The HDC1000 is functional within the full –40°C to +125°C temperature range.

Key Features

  • Relative Humidity (RH) Operating Range 0% to 100%
  • 14 Bit Measurement Resolution
  • Relative Humidity Accuracy ±3%
  • Temperature Accuracy ±0.2°C
  • Supply Voltage 3 V to 5 V
  • I2C Interface

Connection

Code

[codesyntax lang=”python”]

#include<Wire.h>

// HDC1008 I2C address is 0x40(64)
#define hdcAddr 0x40

void setup()
{
  Wire.begin();
  Serial.begin(9600);

  // Starts I2C communication
  Wire.beginTransmission(hdcAddr);
  // Select configuration register
  Wire.write(0x02);
  // Temperature, humidity enabled, resolultion = 14-bits, heater on
  Wire.write(0x30);
  // Stop I2C Transmission
  Wire.endTransmission();
  delay(300);
}

void loop()
{
  unsigned int data[2];

  Wire.beginTransmission(hdcAddr);
  // Send temp measurement command
  Wire.write(0x00);
  Wire.endTransmission();
  delay(500);

  // Request 2 bytes of data
  Wire.requestFrom(hdcAddr, 2);

  // Read 2 bytes of data for temperature
  if (Wire.available() == 2)
  {
    data[0] = Wire.read();
    data[1] = Wire.read();
  }

  int temp = (data[0] * 256) + data[1];
  float celsTemp = (temp / 65536.0) * 165.0 - 40;
  float fahrTemp = celsTemp * 1.8 + 32;


  Wire.beginTransmission(hdcAddr);
  // Send humidity measurement command
  Wire.write(0x01);
  Wire.endTransmission();
  delay(500);

  // Request 2 bytes of data
  Wire.requestFrom(hdcAddr, 2);
  // Read 2 bytes of data to get humidity
  if (Wire.available() == 2)
  {
    data[0] = Wire.read();
    data[1] = Wire.read();
  }

  // Convert the data
  float humidity = (data[0] * 256) + data[1];
  humidity = (humidity / 65536.0) * 100.0;

  Serial.print("Humidity : ");
  Serial.print(humidity);
  Serial.println(" %RH");
  Serial.print("Celsius : ");
  Serial.print(celsTemp);
  Serial.println(" C");
  Serial.print("Fahrenheit : ");
  Serial.print(fahrTemp);
  Serial.println(" F");
  delay(500);
}

[/codesyntax]

 

Links

HDC1008 Temperature Humidity Sensor Breakout Board for Arduino

0 comment
0 FacebookTwitterPinterestEmail
MBed

LM75 temperature sensor and MBed 1768 example

by shedboy71
written by shedboy71

In this particular example we connect an LM75 temperature sensor to an MBed 1768

The LM75 temperature sensor includes a delta-sigma analog-to-digital converter, and a digital overtemperature detector. The host can query the LM75 through its I²C interface to read temperature at any time. The open-drain overtemperature output (OS) sinks current when the programmable temperature limit is exceeded. The OS output operates in either of two modes, comparator or interrupt.

The host controls the temperature at which the alarm is asserted (TOS) and the hysteresis temperature below which the alarm condition is not valid (THYST). Also, the LM75’s TOS and THYST registers can be read by the host. The address of the LM75 is set with three pins to allow multiple devices to work on the same bus.

Power-up is in comparator mode, with defaults of TOS = +80°C and THYST = +75°C. The 3.0V to 5.5V supply voltage range, low supply current, and I²C interface make the LM75 ideal for many applications in thermal management and protection.

Features
SO (SOP) and µMAX® (µSOP) Packages
I²C Bus Interface
Separate Open-Drain OS Output Operates as Interrupt or Comparator/Thermostat Input
Register Readback Capability
Power-Up Defaults Permit Stand-Alone Operation as a Thermostat
3.0V to 5.5V Supply Voltage
Low Operating Supply Current 250µA (typ), 1mA (max)
4µA (typ) Shutdown Mode Minimizes Power Consumption
Up to Eight LM75s Can Be Connected to a Single Bus

 

Layout

mbed and lm75

mbed and lm75

Code

I used the following example for the MBed compiler – https://os.mbed.com/components/LM75B-Temperature-Sensor/

[codesyntax lang=”cpp”]

#include "mbed.h"
#include "LM75B.h"

//Create an LM75B object at the default address (ADDRESS_0)
LM75B sensor(p28, p27);

int main()
{
    //Try to open the LM75B
    if (sensor.open()) 
    {
        printf("Device detected!\n");

        while (1) 
        {
            //Print the current temperature
            printf("Temp = %.3f\r\n", (float)sensor);
            //Sleep for 0.5 seconds
            wait(0.5);
        }
    } 
    else 
    {
        error("Device not detected!\n");
    }
}

[/codesyntax]

Testing

using a terminal program such as TeraTerm and you should see something like this

Temp = 30.000
Temp = 29.750
Temp = 29.750
Temp = 29.625
Temp = 29.750
Temp = 29.875
Temp = 30.000
Temp = 30.125
Temp = 30.250
Temp = 30.000
Temp = 29.750
Temp = 29.750
Temp = 29.625

 

Links

LM75 CJMCU-75 temperature sensor high speed I2C interface high precision development board module

0 comment
0 FacebookTwitterPinterestEmail
Intel Galileo

DS1624 temperature sensor and Intel Galileo example

by shedboy71
written by shedboy71

This example shows how to connect a DS1624 sensor to an Intel Galileo

The DS1624 consists of two separate functional units: a 256-byte nonvolatile E2 memory and a direct-to-digital temperature sensor.

The nonvolatile memory is made up of 256 bytes of E2 memory. This memory can be used to store any type of information the user wishes. These memory locations are accessed through the 2-wire serial bus.

The direct-to-digital temperature sensor allows the DS1624 to measure the ambient temperature and report the temperature in a 12-bit word with 0.0625°C resolution. The temperature sensor and its related registers are accessed through the 2-wire serial interface. Figure 1 in the full data sheet shows a block diagram of the DS1624.

DS1624: Block DiagramDS1624: Block Diagram

Key Features

  • Reduces Component Count with Integrated Temperature Sensor and Nonvolatile E2 Memory
    • Measures Temperatures from -55°C to +125°C in 0.0625°C Increments
    • ±0.5°C Accuracy from 0°C to 70°C
    • 256 Bytes of E2 Memory for Storing Information Such as Frequency Compensation Coefficients
    • No External Components
  • Easy-to-Use 2-Wire Serial Interface
    • Temperature is Read as a 12-Bit Value (2-Byte Transfer)

 

Layout

 

Code

I used the following library – https://github.com/bluemurder/DS1624

[codesyntax lang=”cpp”]

#include <DS1624.h>

// Sensor presents all address pins connected to ground
DS1624 ds1624(0x00);

void setup()
{  
  // Begin serial connection at 9600 baud
  Serial.begin(9600);
} 

void loop()
{
  float temperature;
  bool valid;
  
  // Get current temperature
  ds1624.GetTemperature(temperature, valid);

  // Print it
  if(valid)
  {
    Serial.println(temperature);
  }
  else
  {
    Serial.println("Invalid value read from I2C bus");
  }

  // Wait a while
  delay(1000);
}

[/codesyntax]

Testing

Open the serial monitor and you should see something like this

25.06
25.00
24.94
24.94
24.88
24.88
24.88
24.81
24.75
24.69
24.62
24.56
24.50
24.44
24.37
24.31
24.25
24.19

 

Links

DS1624 temperature sensor, high precision digital thermometer with memory function

0 comment
0 FacebookTwitterPinterestEmail
Arduino Sensors

Arduino MCP9808 digital temperature sensor

by shedboy71
written by shedboy71

The MCP9808 digital temperature sensor converts temperatures between -20°C and +100°C to a digital word with ±0.5°C (max.) accuracy. The MCP9808 comes with user-programmable registers that provide flexibility for temperature sensing applications. The registers allow user-selectable settings such as Shutdown or low-power modes and the specification of temperature Event and Critical output boundaries.

When the temperature changes beyond the specified boundary limits, the MCP9808 outputs an Event signal. The user has the option of setting the event output signal polarity as an active-low or active-high comparator output for thermostat operation, or as temperature event interrupt output for microprocessor-based systems. The event output can also be configured as a Critical temperature output. This sensor has an industry standard 2-wire, SMBus and Standard I2C™Compatible compatible (100kHz/400kHz bus clock) serial interface, allowing up to eight sensors to be controlled in a single serial bus.
Features

Accuracy:
±0.25°C (typical) from -40°C to +125°C
±0.5°C (maximum) from -20°C to +100°C

User Selectable Measurement Resolution:
0.5°C, 0.25°C, 0.125°C, 0.0625°C

User Programmable Temperature Limits:
Temperature Window Limit
Critical Temperature Limit

User Programmable Temperature Alert Output
Operating Voltage Range: 2.7V to 5.5V

More details about the sensor at http://www.microchip.com/wwwproducts/en/MCP9808

This typically comes in a breakout such as the one in the breakout below

MCP9808 digital temperature sensor

MCP9808 digital temperature sensor

Code

You will need the adafruit MCP9808 library which is available at https://github.com/adafruit/Adafruit_MCP9808_Library/archive/master.zip

[codesyntax lang=”cpp”]

#include <Wire.h>
#include "Adafruit_MCP9808.h"

// Create the MCP9808 temperature sensor object
Adafruit_MCP9808 tempsensor = Adafruit_MCP9808();

void setup() {
  Serial.begin(9600);
  
  if (!tempsensor.begin()) 
  {
    Serial.println("Couldn't find MCP9808!");
    while (1);
  }
}

void loop() {
  // Read and print out the temperature, then convert to *F
  float c = tempsensor.readTempC();
  float f = c * 9.0 / 5.0 + 32;
  Serial.print("Temp: "); 
  Serial.print(c); 
  Serial.print(" C\t"); 
  Serial.print(f); 
  Serial.println(" F");
  delay(250);
  
  tempsensor.shutdown_wake(1);
  delay(2000);
  tempsensor.shutdown_wake(0);
  
   
}

[/codesyntax]

Results

Open the serial monitor and you should see something like this

Temp: 21.69 C 71.04 F
Temp: 21.62 C 70.93 F
Temp: 24.50 C 76.10 F
Temp: 25.06 C 77.11 F
Temp: 25.37 C 77.68 F
Temp: 25.56 C 78.01 F
Temp: 24.25 C 75.65 F
Temp: 23.87 C 74.97 F

Links

Adafruit MCP9808 High Accuracy I2C Temperature Sensor Breakout Board [ADA1782]

0 comment
0 FacebookTwitterPinterestEmail
Arduino Sensors

Arduino HDC1008 sensor example

by shedboy71
written by shedboy71

The HDC1000 is a digital humidity sensor with integrated temperature sensor that provides excellent measurement accuracy at very low power. The device measures humidity based on a novel capacitive sensor. The humidity and temperature sensors are factory calibrated.

The sensing element of the HDC1000 is placed on the bottom part of the device, which makes the HDC1000 more robust against dirt, dust, and other environmental contaminants. The HDC1000 is functional within the full –40°C to +125°C temperature range.

hdc1000

Key Features

  • Relative Humidity (RH) Operating Range 0% to 100%
  • 14 Bit Measurement Resolution
  • Relative Humidity Accuracy ±3%
  • Temperature Accuracy ±0.2°C
  • Supply Voltage 3 V to 5 V
  • I2C Interface

Connection information

The easiest way is to purchase some sort of breakout

Connect Vin to 5VDC
Connect GND to ground
Connect SCL to A5 on UNO
Connect SDA to A4 on UNO

Code

The good folks at Adafruit have done the hard work and produced a library for this device – https://github.com/adafruit/Adafruit_HDC1000_Library  . If you are using Arduino IDE 1.6.5 or later you can easily import this library by going to Sketch -> Include Library -> Manage Libraries

[codesyntax lang=”cpp”]

#include <Wire.h>
#include "Adafruit_HDC1000.h"


Adafruit_HDC1000 hdc = Adafruit_HDC1000();

void setup() 
{
  Serial.begin(9600);
  Serial.println("HDC100x test");

  if (!hdc.begin()) 
  {
    Serial.println("Couldn't find sensor!");
    while (1);
  }
}


void loop() 
{
  Serial.print("Temp: "); Serial.print(hdc.readTemperature());
  Serial.print("\t\tHum: "); Serial.println(hdc.readHumidity());
  delay(500);
}

[/codesyntax]

Links

Adafruit HDC1008 Temperature & Humidity Sensor Breakout Board

0 comment
0 FacebookTwitterPinterestEmail
Arduino Sensors

Arduino BME280 sensor example

by shedboy71
written by shedboy71

The BME280 is a humidity sensor features an extremely fast response time which supports performance requirements for emerging applications such as context awareness, and high accuracy over a wide temperature range. The pressure sensor is an absolute barometric pressure sensor with features exceptionally high accuracy and resolution at very low noise. The integrated temperature sensor has been optimized for very low noise and high resolution. It is primarily used for temperature compensation of the pressure and humidity sensors, and can also be used for estimating ambient temperature.

The best way to use the device is a module like the one pictured below

bme280-module

I found this schematic for a breakout online for the bme280, you’ll see in the sparkun image above they are using 4k7’s rather than 10K

Sparkfun has all of the design files for their module available from https://github.com/sparkfun/SparkFun_BME280_Breakout_Board ,

bme280-module-schematic

You can use this module in either SPI or I2C modes, in this case we went for SPI mode, here is the wiring for our module to our arduino Uno

Connect Vin to 5V.
Connect GND to ground
Connect the SCK pin to Digital #13
Connect the SDO pin to Digital #12
Connect the SDI pin to Digital #11
Connect the CS pin Digital #10

Code

The code uses the sparkfun library, I tried 2 others and couldn’t get them to compile. There are several examples available. I removed some code from a basic example

Library – https://github.com/sparkfun/SparkFun_BME280_Arduino_Library

[codesyntax lang=”cpp”]

#include <stdint.h>
#include "SparkFunBME280.h"
#include "Wire.h"
#include "SPI.h"

//Global sensor object
BME280 mySensor;

void setup()
{
  Serial.begin(57600);
  //SPI
  mySensor.settings.commInterface = SPI_MODE;
  mySensor.settings.chipSelectPin = 10;

  //Operation settings
  mySensor.settings.runMode = 3; //Normal mode
  mySensor.settings.tStandby = 0;
  mySensor.settings.filter = 0;
  mySensor.settings.tempOverSample = 1;
  mySensor.settings.pressOverSample = 1;
  mySensor.settings.humidOverSample = 1;
  
  Serial.print("Starting BME280... result of .begin(): 0x");
  delay(10);  //BME280 requires 2ms to start up.
  Serial.println(mySensor.begin(), HEX);
  
}

void loop()
{
  //Each loop, take a reading.

  Serial.print("Temperature: ");
  Serial.print(mySensor.readTempC(), 2);
  Serial.println(" degrees C");

  Serial.print("Temperature: ");
  Serial.print(mySensor.readTempF(), 2);
  Serial.println(" degrees F");

  Serial.print("Pressure: ");
  Serial.print(mySensor.readFloatPressure(), 2);
  Serial.println(" Pa");

  Serial.print("Altitude: ");
  Serial.print(mySensor.readFloatAltitudeMeters(), 2);
  Serial.println("m");

  Serial.print("Altitude: ");
  Serial.print(mySensor.readFloatAltitudeFeet(), 2);
  Serial.println("ft"); 

  Serial.print("%RH: ");
  Serial.print(mySensor.readFloatHumidity(), 2);
  Serial.println(" %");
  
  Serial.println();
  
  delay(1000);

}

[/codesyntax]

Output

All going well if you open your serial monitor window you should see something like this

Temperature: 22.55 degrees C
Temperature: 72.61 degrees F
Pressure: 100637.00 Pa
Altitude: 59.39m
Altitude: 194.01ft
%RH: 0.00 %

Temperature: 22.54 degrees C
Temperature: 72.57 degrees F
Pressure: 100640.00 Pa
Altitude: 59.13m
Altitude: 194.58ft
%RH: 0.00 %

Temperature: 22.53 degrees C
Temperature: 72.59 degrees F
Pressure: 100638.00 Pa
Altitude: 59.31m
Altitude: 195.99ft
%RH: 0.00 %

The temperature looked accurate, I looked up the air pressure and altitude of my location on the internet. Not bad on air pressure as I looked it up a bit later than when I gathered the readings

Pressure 1011.2 mb, Steady [Min 1010.5 Max 1012.5]

Altitude was about 40m out, according to http://elevationmap.net. I’ll need to investigate this as that’s not that good

 

Links

You can pick up one of these breakout/modules for under $8
BME280 Embedded high-precision barometric pressure sensor module

0 comment
0 FacebookTwitterPinterestEmail
Arduino Sensors

Arduino and DS18B20 temperature sensor example

by shedboy71
written by shedboy71

Description

The DS18B20 is a  temperature sensor that can be used in various simple projects.  This part uses the 1 wire (I2C) bus and you can connect multiple sensors up to your Arduino.

The part is also relatively low cost and only requires an additional 4k7 pull up resistor. In the example below we shall make a basic example that reads the temperature and outputs via serial and can be verified using the serial monitor in the Arduino IDE.

 

Parts List

Label Part Type
DS1 DS18B20 1-Wire Temperature Sensor
Part1 Arduino Uno (Rev3)
R1 4.7k Ω Resistor

 

As always be careful not to get the connections incorrect, you can refer to the pinout for the device below to help . The DS18B20 can be powered by between 3.0V and 5.5V so you can simply connect its GND pin to 0V and the VDD pin to +5V from the Arduino.

ds18b20 pinout

ds18b20 pinout

I personally find that using a module is the easiest way, the components are soldered for you and the connections come out to a header, here is a module that I have used

 

AliExpress.com Product – DS18B20 temperature module temperature sensor module

 

Breadboard layout

Here is the connection diagram showing how to connect your arduino to the resistor and sensor.

ds1820 breadboard layout

ds1820 breadboard layout

Code

There are a couple of  libraries and copy them into your Arduino libraries folder.

Dallas 18b20 Temperature Library
“1-Wire” Library

Now copy and paste the following code into a new sketch

[codesyntax lang=”cpp”]

#include <OneWire.h>
#include <DallasTemperature.h>

//the pin you connect the ds18b20 to
#define DS18B20 2

OneWire ourWire(DS18B20);
DallasTemperature sensors(&ourWire);

void setup()
{
Serial.begin(9600);
delay(1000);
//start reading
sensors.begin();
}

void loop()
{
//read temperature and output via serial
sensors.requestTemperatures();
Serial.print(sensors.getTempCByIndex(0));
Serial.println(" degrees C");
}

[/codesyntax]

 

Output

When you upload the sketch, go to Tools -> Serial Monitor and you should see something like the following.

 

ds18b20 serial output

ds18b20 serial output

Links
DS18B20 Stainless Steel Waterproof Temperature Probe Sensor For Arduino

DS18B20 temperature module temperature sensor module

0 comment
0 FacebookTwitterPinterestEmail
37 Sensor Kit

KY-001 Temperature sensor module

by shedboy71
written by shedboy71

Description
This module measures the temperature and reports it through the 1-wire bus to the Arduino.  It uses the extremely popular DS18b20 digital thermometer.

 

KY001

KY001

Specs

The DS18B20 digital thermometer provides 9-bit to 12-bit Celsius temperature measurements and has an alarm function with nonvolatile user-programmable upper and lower trigger points. The DS18B20 communicates over a 1-Wire® bus that by definition requires only one data line (and ground) for communication with a central microprocessor. It has an operating temperature range of -55°C to +125°C and is accurate to ±0.5°C over the range of -10°C to +85°C. In addition, the DS18B20 can derive power directly from the data line (“parasite power”), eliminating the need for an external power supply.

Each DS18B20 has a unique 64-bit serial code, which allows multiple DS18B20s to function on the same 1-Wire bus.

Parts Required

You will require the following

Arduino UNO (or equivalent)
KY-001 Temperature sensor module
USB cable

 

Connections

Pin – = connect to GND
Pin (middle) = connect to +5V
Pin S = Signal, connect to Arduino Digital port 10

 

Code

Arduino Example

[codesyntax lang=”cpp”]

#include <OneWire.h>
 
// DS18S20 Temperature chip i/o
OneWire ds(10);  // on pin 10
 
void setup(void) {
  // initialize inputs/outputs
  // start serial port
  Serial.begin(9600);
}
 
void loop(void) {
 
  //For conversion of raw data to C
  int HighByte, LowByte, TReading, SignBit, Tc_100, Whole, Fract;
 
  byte i;
  byte present = 0;
  byte data[12];
  byte addr[8];
 
  if ( !ds.search(addr)) {
      Serial.print("No more addresses.\n");
      ds.reset_search();
      return;
  }
 
  Serial.print("R=");
  for( i = 0; i < 8; i++) {
    Serial.print(addr[i], HEX);
    Serial.print(" ");
  }
 
  if ( OneWire::crc8( addr, 7) != addr[7]) {
      Serial.print("CRC is not valid!\n");
      return;
  }
 
  if ( addr[0] == 0x10) {
      Serial.print("Device is a DS18S20 family device.\n");
  }
  else if ( addr[0] == 0x28) {
      Serial.print("Device is a DS18B20 family device.\n");
  }
  else {
      Serial.print("Device family is not recognized: 0x");
      Serial.println(addr[0],HEX);
      return;
  }
 
  ds.reset();
  ds.select(addr);
  ds.write(0x44,1);         // start conversion, with parasite power on at the end
 
  delay(1000);     // maybe 750ms is enough, maybe not
  // we might do a ds.depower() here, but the reset will take care of it.
 
  present = ds.reset();
  ds.select(addr);    
  ds.write(0xBE);         // Read Scratchpad
 
  Serial.print("P=");
  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();
 
  //Conversion of raw data to C
  LowByte = data[0];
  HighByte = data[1];
  TReading = (HighByte << 8) + LowByte;
  SignBit = TReading & 0x8000;  // test most sig bit
  if (SignBit) // negative
  {
    TReading = (TReading ^ 0xffff) + 1; // 2's comp
  }
  Tc_100 = (6 * TReading) + TReading / 4;    // multiply by (100 * 0.0625) or 6.25
 
  Whole = Tc_100 / 100;  // separate off the whole and fractional portions
  Fract = Tc_100 % 100;
 
 
  if (SignBit) // If its negative
  {
     Serial.print("-");
  }
  Serial.print(Whole);
  Serial.print(".");
  if (Fract < 10)
  {
     Serial.print("0");
  }
  Serial.print(Fract);
 
  Serial.print("\n");
  //End conversion to C
}

[/codesyntax]

0 comment
0 FacebookTwitterPinterestEmail