Arduino I2C - data stream stopped unexpectedly - arduino

Question

I am trying to connect an Arduino Uno to a temperature sensor using I2C. At first, the Arduino can send the data stream, but it stops a few minutes later...
If I restart the board, the Arduino can send the data stream, but again it stops a few minutes later. I wonder whether my code is wrong. Please help me.
/*
Program akses DT-SENSE Temp SENSOR - Arduino
Vizard Vision # 2013
*/
#include <Wire.h>
void setup() {
Wire.begin();
Serial.begin(38400);
}
int buffer = 0;
int count = 0;
void loop() {
if(count >= 6000) {
count = 0;
}
Wire.beginTransmission(112); // transmit to device #112 (0x70)
// the address specified in the datasheet is 224 (0xE0) --> 1110 0000 = E0H
// but i2c adressing uses the high 7 bits so it's 112 --> 0111 0000 = 70H
Wire.send(0x00);
// command sensor to measure 16 Byte of Temperature Data
Wire.endTransmission();
delay(100);
Wire.requestFrom(112, 2);
// request 2 bytes from slave device #112
if(2 <= Wire.available()) {
// if two bytes were received
buffer = Wire.receive();
// receive high byte (overwrites previous reading)
buffer = buffer << 8;
// shift high byte to be high 8 bits
buffer |= Wire.receive();
// receive low byte as lower 8 bits
buffer = (buffer - 400)/10;
// Conversion data to Temperature (from datasheet)
Serial.print(count);
Serial.print(" Suhu = ");
Serial.print(buffer);
Serial.write(176);
// Unicode value of Degree Symbol
Serial.println("Celsius");
count ++;
Serial.flush();
}
delay(40);
}

Answer 1

There could be a problem here:
if(2 <= Wire.available()) // if two bytes were received
{
buffer = Wire.receive(); // receive high byte (overwrites previous reading)
buffer = buffer << 8; // shift high byte to be high 8 bits
buffer |= Wire.receive(); // receive low byte as lower 8 bits
It will get into the block if there is 1 or 2 bytes available. If there is 2 bytes, it will go through both Wire.receive() and your buffer variable will be setup correctly, and you're happy. If there is only 1 byte, it will pass first Wire.receive(), and on second Wire.receive() you'll have an unexpected behaviour (i.e. documentation does not tell what it does when that happens). So I'd expect it to be blocking until a byte comes, but as it will never come, it blocks infinitely.
Then you'd wonder "why would this ever return a single byte?". And there can be many reasons:
the datasheet may be lying and on very specific circumstances your i2c slave may return a single byte,
your connection is mishandled at one point, and the slave writes both bytes at an incorrect speed making your lib believe it's only one byte,
there's a false contact in your i2c line and under weird circumstances (temperature, pressure, vibration, a storm in Nicaragua) and only one of the two bytes are getting through the connection...
So you should do the following:
if(Wire.available() == 2) // if two bytes were received
{
buffer = Wire.receive(); // receive high byte (overwrites previous reading)
buffer = buffer << 8; // shift high byte to be high 8 bits
buffer |= Wire.receive(); // receive low byte as lower 8 bits
which will make you avoid going through the unexpected behavior!