/* ************************************************************************* *
 * A data logging appliation for the Arduino using light and                 *
 * temperature sensors, and logging to a pair of EEPROM chips                *
 *                                                                           *
 * For more information visit:                                               *
 * http://pskillenrules.blogspot.com/2009/06/arduino-based-data-logger.html  *
 *                                                                           *
 * License:                                                                  *
 * You are free to edit and/or redistribute this work or works derived from  *
 * this, provided that any redistribution/derived work remains free and open *
 * source, and also contains reference to my work.                           *
 *                                                                           *
 * ************************************************************************* */
#include <Wire.h>


/* Hardware configuation */
// analog pins
#define LDR_PIN                0
#define RTD_PIN                1
// digital pin
#define DOWNLOAD_PIN           2
#define WARNING_LED            11
#define STATUS_LED             13

#define LDR_EEPROM_ADDRESS     0x51
#define RTD_EEPROM_ADDRESS     0x55

/* Checksums */
#define CHECKSUM_1_VAL         0xF0
#define CHECKSUM_2_VAL         0x0F

/* EEPROM memory addresses */
#define CHECKSUM_1_ADDR         0x00
#define LAST_WRITE_ADDR_MSB    0x01
#define LAST_WRITE_ADDR_LSB    0x02
#define LOW_RAW_VAL_ADDR_MSB   0x03
#define LOW_RAW_VAL_ADDR_LSB   0x04
#define HIGH_RAW_VAL_ADDR_MSB  0x05
#define HIGH_RAW_VAL_ADDR_LSB  0x06
#define LOW_REAL_VAL_ADDR_MSB  0x07
#define LOW_REAL_VAL_ADDR_LSB  0x08
#define HIGH_REAL_VAL_ADDR_MSB 0x09
#define HIGH_REAL_VAL_ADDR_LSB 0x0A
#define CHECKSUM_2_ADDR        0x0B
#define MIN_WRITE_ADDR         0x0C
#define MAX_WRITE_ADDR         0xFFFF

/* Timing values */
#define READ_INTERVAL          15000 // ms
#define SERIAL_WAIT_DELAY      20 // ms


long    last_write_addr;


/* LDR Variables */
//long    ldr_last_write_addr;
long    ldr_low_raw_val;
long    ldr_low_real_val;
long    ldr_high_raw_val;
long    ldr_high_real_val;

/* RTD Variables */
//long    rtd_last_write_addr;
long    rtd_low_raw_val;
long    rtd_low_real_val;
long    rtd_high_raw_val;
long    rtd_high_real_val;

/* Calibration variables */
long    real;
long    raw;
int     val;
byte    cal_sensor;
byte    cal_sp;
int     after_dp;

/* Value reading variables */
long   next_read_time;

/* status vars */
boolean out_of_space;
byte    status_brightness;


void setup() {


  // setup the pins
  pinMode(STATUS_LED, OUTPUT);
  digitalWrite(STATUS_LED, LOW);
  pinMode(WARNING_LED, OUTPUT);
  digitalWrite(WARNING_LED, LOW);

  pinMode(DOWNLOAD_PIN, INPUT);           // set pin to input
  digitalWrite(DOWNLOAD_PIN, HIGH);       // turn on pullup resistors


  // Configure TWI and serial IO
  Wire.begin();
  delay(50); // wait for TWI to settle

  Serial.begin(19200);

  status();

  // Try to read calibration values from EEPROMs
  //readCal(); // status() calls this for us

    // Begin main loop

  Serial.println("Initialization complete");
  next_read_time = 0;

  out_of_space = 0;
}

void loop() {

  // find out if the user requests calibrations or not
  readSerial();

  // see if we need to save a new value
  if (millis() > next_read_time) {
    digitalWrite(STATUS_LED, HIGH);

    next_read_time += READ_INTERVAL;


    if (last_write_addr + 5 < MAX_WRITE_ADDR) {
      last_write_addr ++;
      last_write_addr ++;

      // get the LDR value
      val = analogRead(LDR_PIN);
      val = map(val, ldr_low_raw_val, ldr_high_raw_val, ldr_low_real_val, ldr_high_real_val);

      // save the value "val" into the next available space
      i2c_eeprom_write_byte( LDR_EEPROM_ADDRESS, last_write_addr, val >> 8);
      i2c_eeprom_write_byte( LDR_EEPROM_ADDRESS, last_write_addr+1, val & 0xFF);

      // save the last write address to the eeprom in case we lose power  
      i2c_eeprom_write_byte( LDR_EEPROM_ADDRESS, LAST_WRITE_ADDR_MSB, last_write_addr >> 8);
      i2c_eeprom_write_byte( LDR_EEPROM_ADDRESS, LAST_WRITE_ADDR_LSB, last_write_addr & 0xFF);

      //Serial.print("Logged LDR value of ");
      //Serial.print((float)val / 100.0);
      //Serial.print(" to addr ");
      //Serial.println(last_write_addr);

      // get the RTD value
      val = analogRead(RTD_PIN);
      val = map(val, rtd_low_raw_val, rtd_high_raw_val, rtd_low_real_val, rtd_high_real_val);

      // save the value "val" into the next available space
      i2c_eeprom_write_byte( RTD_EEPROM_ADDRESS, last_write_addr, val >> 8);
      i2c_eeprom_write_byte( RTD_EEPROM_ADDRESS, last_write_addr+1, val & 0xFF);
 
      // save the last write address to the eeprom in case we lose power  
      i2c_eeprom_write_byte( RTD_EEPROM_ADDRESS, LAST_WRITE_ADDR_MSB, last_write_addr >> 8);
      i2c_eeprom_write_byte( RTD_EEPROM_ADDRESS, LAST_WRITE_ADDR_LSB, last_write_addr & 0xFF);

      //Serial.print("Logged RTD value of ");
      //Serial.print((float)val / 100.0);
      //Serial.print(" to addr ");
      //Serial.println(last_write_addr);
    
    delay(10);
    digitalWrite(STATUS_LED, LOW);
    } 
    else {
      Serial.println("Out of space to log values");
      // flash the status LED
      out_of_space = 1;
    }


  }

  if (out_of_space) {
    status_brightness++;

    analogWrite(WARNING_LED, status_brightness);
    delay(10);
  }

}

void readSerial() {
  // listen for serial data
  if (Serial.available()) {
    // ensure all the data has been buffered
    delay(SERIAL_WAIT_DELAY);

    // read current command
    val = Serial.read();
    // clear the rest of the current serial buffer
    Serial.flush();

    if (val == 'c' || val == 'C') {
      doCal();
    }      
    else if (val == 'd' || val == 'D' || digitalRead(DOWNLOAD_PIN) == 0) {
      // dump data over serial
      sendData();
    } 
    else if (val == 'r' || val == 'R') {
      // reset
      reset();
    } 
    else if (val == 's' || val == 'S') {
      // status
      status();
    } 
    else {
      // inappropriate command received
      Serial.println("Inappropriate serial command received");
      Serial.println("Send 'c' to begin calibration");
      Serial.println("Send 'r' to reset write pointer");
      Serial.println("Send 'd' to download all data via serial");
      return;
    }

  }  
}

void status() {
  long l, l2;

  Serial.println("");
  Serial.println("");
  Serial.println("Paddy's Data Logger");
  Serial.println("Version 1.0 : 24 June 2009");

  readCal();

  Serial.println("");

  l = (last_write_addr - MIN_WRITE_ADDR) / 2;
  l2 = (MAX_WRITE_ADDR - MIN_WRITE_ADDR) / 2;
  Serial.print("Existing records: ");
  Serial.print(l);
  Serial.print(" / ");
  Serial.print(l2);
  Serial.print(" (");
  Serial.print(((float)l / (float)l2) * 100.0);
  Serial.println("%)");

  Serial.print("Read interval:    " );
  Serial.print(READ_INTERVAL);
  Serial.println("ms");

}

void reset() {
  Serial.print("Resetting write address to ");
  Serial.println((int) MIN_WRITE_ADDR);

  i2c_eeprom_write_byte ( RTD_EEPROM_ADDRESS, LAST_WRITE_ADDR_MSB, 0x00 );
  i2c_eeprom_write_byte ( RTD_EEPROM_ADDRESS, LAST_WRITE_ADDR_LSB, MIN_WRITE_ADDR );
  last_write_addr = MIN_WRITE_ADDR;
}

void readCal() {
  Serial.println("");
  Serial.println("Reading calibration data from EEPROM(s)");

  // read LDR values
  if ((val = i2c_eeprom_read_byte( LDR_EEPROM_ADDRESS, CHECKSUM_1_ADDR )) != CHECKSUM_1_VAL) {

    // we need to init this eeprom
    Serial.println("LDR EEPROM not initialized - low calibration required");
    Serial.print("Read ");
    Serial.print(val);
    Serial.println(" for checksum");

    last_write_addr        = MIN_WRITE_ADDR;
    ldr_low_raw_val        = 0;
    ldr_low_real_val       = 0.0;
    ldr_high_raw_val       = 1;
    ldr_high_real_val      = 1.0;

  } 
  else if ((val = i2c_eeprom_read_byte( LDR_EEPROM_ADDRESS, CHECKSUM_2_ADDR )) != CHECKSUM_2_VAL)  {

    // we need to init this eeprom
    Serial.println("LDR EEPROM not initialized - high calibration required");
    Serial.print("Read ");
    Serial.print(val);
    Serial.println(" for checksum");

    last_write_addr        = MIN_WRITE_ADDR;
    ldr_low_raw_val        = 0;
    ldr_low_real_val       = 0.0;
    ldr_high_raw_val       = 1;
    ldr_high_real_val      = 1.0;

  } 
  else {

    // read the last write address
    last_write_addr = i2c_eeprom_read_byte( LDR_EEPROM_ADDRESS, LAST_WRITE_ADDR_MSB ) << 8;
    last_write_addr += i2c_eeprom_read_byte( LDR_EEPROM_ADDRESS, LAST_WRITE_ADDR_LSB );

    // read the low raw value    
    ldr_low_raw_val = i2c_eeprom_read_byte( LDR_EEPROM_ADDRESS, LOW_RAW_VAL_ADDR_MSB ) << 8;
    ldr_low_raw_val += i2c_eeprom_read_byte( LDR_EEPROM_ADDRESS, LOW_RAW_VAL_ADDR_LSB );

    // read the high raw value
    ldr_high_raw_val = i2c_eeprom_read_byte( LDR_EEPROM_ADDRESS, HIGH_RAW_VAL_ADDR_MSB ) << 8;
    ldr_high_raw_val += i2c_eeprom_read_byte( LDR_EEPROM_ADDRESS, HIGH_RAW_VAL_ADDR_LSB );

    // read the low real value
    ldr_low_real_val = i2c_eeprom_read_byte( LDR_EEPROM_ADDRESS, LOW_REAL_VAL_ADDR_MSB ) << 8;
    ldr_low_real_val += i2c_eeprom_read_byte( LDR_EEPROM_ADDRESS, LOW_REAL_VAL_ADDR_LSB );

    // read the high real value
    ldr_high_real_val = i2c_eeprom_read_byte( LDR_EEPROM_ADDRESS, HIGH_REAL_VAL_ADDR_MSB ) << 8;
    ldr_high_real_val += i2c_eeprom_read_byte( LDR_EEPROM_ADDRESS, HIGH_REAL_VAL_ADDR_LSB );

    Serial.println("LDR Calibration read:");
    Serial.print("Low: ");
    Serial.print(ldr_low_raw_val);
    Serial.print(" (raw) = ");
    Serial.print((float) ldr_low_real_val / 100.0);
    Serial.println(" %");

    Serial.print("High: ");
    Serial.print(ldr_high_raw_val);
    Serial.print(" (raw) = ");
    Serial.print((float) ldr_high_real_val / 100.0);
    Serial.println(" %");

    Serial.print("Current: ");
    val = analogRead(LDR_PIN);
    Serial.print(val);
    Serial.print(" (raw) = ");
    val = map(val, ldr_low_raw_val, ldr_high_raw_val, ldr_low_real_val, ldr_high_real_val);
    Serial.print((float) val / 100.0);
    Serial.println(" %");

  }

  // read RTD values
  if ((val = i2c_eeprom_read_byte( RTD_EEPROM_ADDRESS, CHECKSUM_1_ADDR )) != CHECKSUM_1_VAL) {

    // we need to init this eeprom
    Serial.println("RTD EEPROM not initialized - low calibration required");
    Serial.print("Read ");
    Serial.print(val);
    Serial.println(" for checksum");

    last_write_addr        = MIN_WRITE_ADDR;
    rtd_low_raw_val        = 0;
    rtd_low_real_val       = 0.0;
    rtd_high_raw_val       = 1;
    rtd_high_real_val      = 1.0;

  } 
  else if ((val = i2c_eeprom_read_byte( RTD_EEPROM_ADDRESS, CHECKSUM_2_ADDR )) != CHECKSUM_2_VAL)  {

    // we need to init this eeprom
    Serial.println("RTD EEPROM not initialized - high calibration required");
    Serial.print("Read ");
    Serial.print(val);
    Serial.println(" for checksum");

    last_write_addr        = MIN_WRITE_ADDR;
    rtd_low_raw_val        = 0;
    rtd_low_real_val       = 0.0;
    rtd_high_raw_val       = 1;
    rtd_high_real_val      = 1.0;

  } 
  else {

    // read the last write address
    last_write_addr = i2c_eeprom_read_byte( RTD_EEPROM_ADDRESS, LAST_WRITE_ADDR_MSB ) << 8;
    last_write_addr += i2c_eeprom_read_byte( RTD_EEPROM_ADDRESS, LAST_WRITE_ADDR_LSB );

    // read the low raw value    
    rtd_low_raw_val = i2c_eeprom_read_byte( RTD_EEPROM_ADDRESS, LOW_RAW_VAL_ADDR_MSB ) << 8;
    rtd_low_raw_val += i2c_eeprom_read_byte( RTD_EEPROM_ADDRESS, LOW_RAW_VAL_ADDR_LSB );

    // read the high raw value
    rtd_high_raw_val = i2c_eeprom_read_byte( RTD_EEPROM_ADDRESS, HIGH_RAW_VAL_ADDR_MSB ) << 8;
    rtd_high_raw_val += i2c_eeprom_read_byte( RTD_EEPROM_ADDRESS, HIGH_RAW_VAL_ADDR_LSB );

    // read the low real value
    rtd_low_real_val = i2c_eeprom_read_byte( RTD_EEPROM_ADDRESS, LOW_REAL_VAL_ADDR_MSB ) << 8;
    rtd_low_real_val += i2c_eeprom_read_byte( RTD_EEPROM_ADDRESS, LOW_REAL_VAL_ADDR_LSB );

    // read the high real value
    rtd_high_real_val = i2c_eeprom_read_byte( RTD_EEPROM_ADDRESS, HIGH_REAL_VAL_ADDR_MSB ) << 8;
    rtd_high_real_val += i2c_eeprom_read_byte( RTD_EEPROM_ADDRESS, HIGH_REAL_VAL_ADDR_LSB );

    Serial.println("RTD Calibration read:");
    Serial.print("Low: ");
    Serial.print(rtd_low_raw_val);
    Serial.print(" (raw) = ");
    Serial.print((float) rtd_low_real_val / 100.0);
    Serial.println(" 'C");

    Serial.print("High: ");
    Serial.print(rtd_high_raw_val);
    Serial.print(" (raw) = ");
    Serial.print((float) rtd_high_real_val / 100.0);
    Serial.println(" 'C");

    Serial.print("Current: ");
    val = analogRead(RTD_PIN);
    Serial.print(val);
    Serial.print(" (raw) = ");
    val = map(val, rtd_low_raw_val, rtd_high_raw_val, rtd_low_real_val, rtd_high_real_val);
    Serial.print((float) val / 100.0);
    Serial.println(" 'C");
  }
}


void doCal() {
  // if serial data is requesting cal


    cal_sensor = 0;
  cal_sp = 0;
  after_dp = 0;
  raw = 0;
  real = 0;

  // we need to do a calibration
  Serial.println("Adjust sensor to setpoint and submit value in this format:");
  Serial.println("[sensor][sp#]=[value.00]");
  Serial.println("Where [sensor] = 1 for LDR, 2 for RTD");
  Serial.println("  and [sp#]    = 1 for low, 2 for high");

  // now block until serial data is available      
  while (!Serial.available())
    delay(SERIAL_WAIT_DELAY);

  // delay another 10ms to ensure all serial data has arrived
  delay(SERIAL_WAIT_DELAY);

  // read sensor number
  val = Serial.read();
  if (val == '1') {
    // Grab LDR reading
    cal_sensor = 1;
    raw = analogRead(LDR_PIN);
  } 
  else if (val == '2') {
    // Grab RTD reading
    cal_sensor = 2;
    raw = analogRead(RTD_PIN);
  }
  else {
    Serial.println("Invalid sensor specified. Calibration aborted");
    Serial.flush();
    return;
  }

  // read sp number
  val = Serial.read();
  if (val == '1') {
    // low
    cal_sp = 1;
  } 
  else if (val == '2') {
    // high
    cal_sp = 2;
  }
  else {
    Serial.println("Invalid setpoint specified. Calibration aborted");
    Serial.flush();
    return;
  }

  // skip over any whitespace
  while ((val = Serial.read()) == ' ');

  // ensure there's an equals sign    
  //val = Serial.read(); // need to examine last char from previous bit
  if (val != '=') {
    Serial.println("Invalid character in sequence. Expected '=' in this position. Calibration aborted");
    Serial.flush();
    return;
  }

  // skip over any more whitespace
  while ((val = Serial.read()) == ' ');

  // now build the real value
  while (val != -1) {

    if (val >= '0' && val <= '9') {

      if (after_dp == 0) {
        // multiply the previous f by 10
        real *= 10;
        real += (val - '0') * 100;
      } 
      else if (after_dp == 1) {
        real += (val - '0') * 10;
        after_dp ++;
      }
      else if (after_dp == 2) {
        real += (val - '0');
        after_dp ++;
      }
    }
    else if (val == '.') {
      // check we haven't already had a DP
      if (after_dp) {
        Serial.println("Invalid character in sequence. Too many '.' in number. Calibration aborted");
        Serial.flush();
        return;
      }

      after_dp ++;
    } 
    else {
      Serial.print("Invalid character in sequence. Didn't expect '");
      Serial.print((char) val);
      Serial.print("' (");
      Serial.print((int) val);
      Serial.println(") in number. Calibration aborted");

      Serial.println("Calibration NOT saved:");
      Serial.print("Values: ");
      Serial.print(raw);
      Serial.print(" (raw) = ");
      Serial.println((float)real / 100.0);

      Serial.flush();
      return;
    }

    // the read should come after the actions, since the actions need to be performed
    // on the last read from the previous bit
    val = Serial.read();
  }


  // now save the values
  if (cal_sensor == 1 && cal_sp == 1) {
    // save the low point of the LDR

    // clear the last write address
    i2c_eeprom_write_byte ( LDR_EEPROM_ADDRESS, LAST_WRITE_ADDR_MSB, 0x00 );
    i2c_eeprom_write_byte ( LDR_EEPROM_ADDRESS, LAST_WRITE_ADDR_LSB, MIN_WRITE_ADDR );
    last_write_addr = MIN_WRITE_ADDR;

    // write the low raw value
    ldr_low_raw_val = raw;
    i2c_eeprom_write_byte( LDR_EEPROM_ADDRESS, LOW_RAW_VAL_ADDR_MSB, raw >> 8 );
    i2c_eeprom_write_byte( LDR_EEPROM_ADDRESS, LOW_RAW_VAL_ADDR_LSB, raw & 0xFF );

    // write the low real value
    ldr_low_real_val = real;
    i2c_eeprom_write_byte( LDR_EEPROM_ADDRESS, LOW_REAL_VAL_ADDR_MSB, real >> 8 );
    i2c_eeprom_write_byte( LDR_EEPROM_ADDRESS, LOW_REAL_VAL_ADDR_LSB, real & 0xFF );

    // Write the first checksum to the eeprom
    i2c_eeprom_write_byte( LDR_EEPROM_ADDRESS, CHECKSUM_1_ADDR, CHECKSUM_1_VAL );

    val = i2c_eeprom_read_byte( LDR_EEPROM_ADDRESS, CHECKSUM_1_ADDR );
    if (val != CHECKSUM_1_VAL) {
      Serial.println("Error writing to EEPROM!");
      Serial.print("Wrote value: ");
      Serial.print((int) CHECKSUM_1_VAL);
      Serial.print(" but read: ");
      Serial.println(val);
    } 
    else {
      Serial.println("Calibration point saved:");
      Serial.print("LDR Low: ");
      Serial.print(raw);
      Serial.print(" (raw) = ");
      Serial.print((float)real / 100.0);
      Serial.println(" %");
    }

  }
  else if (cal_sensor == 1 && cal_sp == 2) {
    // save the low point of the LDR

    // clear the last write address
    i2c_eeprom_write_byte ( LDR_EEPROM_ADDRESS, LAST_WRITE_ADDR_MSB, 0x00 );
    i2c_eeprom_write_byte ( LDR_EEPROM_ADDRESS, LAST_WRITE_ADDR_LSB, MIN_WRITE_ADDR );
    last_write_addr = MIN_WRITE_ADDR;

    // write the low raw value
    ldr_high_raw_val = raw;
    i2c_eeprom_write_byte( LDR_EEPROM_ADDRESS, HIGH_RAW_VAL_ADDR_MSB, raw >> 8 );
    i2c_eeprom_write_byte( LDR_EEPROM_ADDRESS, HIGH_RAW_VAL_ADDR_LSB, raw & 0xFF );

    // write the low real value
    ldr_high_real_val = real;
    i2c_eeprom_write_byte( LDR_EEPROM_ADDRESS, HIGH_REAL_VAL_ADDR_MSB, real >> 8 );
    i2c_eeprom_write_byte( LDR_EEPROM_ADDRESS, HIGH_REAL_VAL_ADDR_LSB, real & 0xFF );

    // Write the second checksum to the eeprom
    i2c_eeprom_write_byte( LDR_EEPROM_ADDRESS, CHECKSUM_2_ADDR, CHECKSUM_2_VAL );

    val = i2c_eeprom_read_byte( LDR_EEPROM_ADDRESS, CHECKSUM_2_ADDR );
    if (val != CHECKSUM_2_VAL) {
      Serial.println("Error writing to EEPROM!");
      Serial.print("Wrote value: ");
      Serial.print((int) CHECKSUM_2_VAL);
      Serial.print(" but read: ");
      Serial.println(val);
    } 
    else {
      Serial.println("Calibration point saved:");
      Serial.print("LDR High: ");
      Serial.print(raw);
      Serial.print(" (raw) = ");
      Serial.print((float)real / 100.0);
      Serial.println(" %");
    }
  }
  else if (cal_sensor == 2 && cal_sp == 1) {
    // save the low point of the RTD

    // clear the last write address
    i2c_eeprom_write_byte ( RTD_EEPROM_ADDRESS, LAST_WRITE_ADDR_MSB, 0x00 );
    i2c_eeprom_write_byte ( RTD_EEPROM_ADDRESS, LAST_WRITE_ADDR_LSB, MIN_WRITE_ADDR );
    last_write_addr = MIN_WRITE_ADDR;

    // write the low raw value
    rtd_low_raw_val = raw;
    i2c_eeprom_write_byte( RTD_EEPROM_ADDRESS, LOW_RAW_VAL_ADDR_MSB, raw >> 8 );
    i2c_eeprom_write_byte( RTD_EEPROM_ADDRESS, LOW_RAW_VAL_ADDR_LSB, raw & 0xFF );

    // write the low real value
    rtd_low_real_val = real;
    i2c_eeprom_write_byte( RTD_EEPROM_ADDRESS, LOW_REAL_VAL_ADDR_MSB, real >> 8 );
    i2c_eeprom_write_byte( RTD_EEPROM_ADDRESS, LOW_REAL_VAL_ADDR_LSB, real & 0xFF );

    // Write the first checksum to the eeprom
    i2c_eeprom_write_byte( RTD_EEPROM_ADDRESS, CHECKSUM_1_ADDR, CHECKSUM_1_VAL );

    val = i2c_eeprom_read_byte( RTD_EEPROM_ADDRESS, CHECKSUM_1_ADDR );
    if (val != CHECKSUM_1_VAL) {
      Serial.println("Error writing to EEPROM!");
      Serial.print("Wrote value: ");
      Serial.print((int) CHECKSUM_1_VAL);
      Serial.print(" but read: ");
      Serial.println(val);
    } 
    else {
      Serial.println("Calibration point saved:");
      Serial.print("RTD Low: ");
      Serial.print(raw);
      Serial.print(" (raw) = ");
      Serial.print((float)real / 100.0);
      Serial.println(" %");
    }

  }
  else if (cal_sensor == 2 && cal_sp == 2) {
    // save the low point of the RTD

    // clear the last write address
    i2c_eeprom_write_byte ( RTD_EEPROM_ADDRESS, LAST_WRITE_ADDR_MSB, 0x00 );
    i2c_eeprom_write_byte ( RTD_EEPROM_ADDRESS, LAST_WRITE_ADDR_LSB, MIN_WRITE_ADDR );
    last_write_addr = MIN_WRITE_ADDR;

    // write the low raw value
    rtd_high_raw_val = raw;
    i2c_eeprom_write_byte( RTD_EEPROM_ADDRESS, HIGH_RAW_VAL_ADDR_MSB, raw >> 8 );
    i2c_eeprom_write_byte( RTD_EEPROM_ADDRESS, HIGH_RAW_VAL_ADDR_LSB, raw & 0xFF );

    // write the low real value
    rtd_high_real_val = real;
    i2c_eeprom_write_byte( RTD_EEPROM_ADDRESS, HIGH_REAL_VAL_ADDR_MSB, real >> 8 );
    i2c_eeprom_write_byte( RTD_EEPROM_ADDRESS, HIGH_REAL_VAL_ADDR_LSB, real & 0xFF );

    // Write the second checksum to the eeprom
    i2c_eeprom_write_byte( RTD_EEPROM_ADDRESS, CHECKSUM_2_ADDR, CHECKSUM_2_VAL );

    val = i2c_eeprom_read_byte( RTD_EEPROM_ADDRESS, CHECKSUM_2_ADDR );
    if (val != CHECKSUM_2_VAL) {
      Serial.println("Error writing to EEPROM!");
      Serial.print("Wrote value: ");
      Serial.print((int) CHECKSUM_2_VAL);
      Serial.print(" but read: ");
      Serial.println(val);
    } 
    else {
      Serial.println("Calibration point saved:"); 
      Serial.print("RTD High: ");
      Serial.print(raw);
      Serial.print(" (raw) = ");
      Serial.print((float)real / 100.0);
      Serial.println(" %");
    }
  }



}

void sendData() {
  delay(50);
  
  long count;
  
  digitalWrite(WARNING_LED, HIGH);

  // send RTD data to serial  
  Serial.println("\nRTD,");
  count = 0;
  for (long addr = MIN_WRITE_ADDR; addr < last_write_addr; addr += 2){

    val = i2c_eeprom_read_byte( RTD_EEPROM_ADDRESS, addr ) << 8;
    val += i2c_eeprom_read_byte( RTD_EEPROM_ADDRESS, addr+1 );

    Serial.print((float)val / 100.0);
    Serial.print(',');

    count ++; 
    if (count % 250 == 0) {
      Serial.print(count);
      Serial.print('/');
      Serial.print((last_write_addr - MIN_WRITE_ADDR) / 2);
      Serial.print(",");
    }
  }

  // send LDR data to serial  
  Serial.println("\nLDR,");
  count = 0;
  for (long addr = MIN_WRITE_ADDR; addr < last_write_addr; addr += 2){

    val = i2c_eeprom_read_byte( LDR_EEPROM_ADDRESS, addr ) << 8;
    val += i2c_eeprom_read_byte( LDR_EEPROM_ADDRESS, addr+1 );

    Serial.print((float)val / 100.0);
    Serial.print(',');
    
    count ++;
    if (count % 250 == 0) {
      Serial.print(count);
      Serial.print('/');
      Serial.print((last_write_addr - MIN_WRITE_ADDR) / 2);
      Serial.print(",");
    }
  }

  Serial.println("Download complete.");
  Serial.print("Sent ");
  Serial.print((last_write_addr - MIN_WRITE_ADDR) / 2);
  Serial.println(" records");

  digitalWrite(WARNING_LED, LOW);
}


static void i2c_eeprom_write_byte( int deviceaddress, unsigned int eeaddress, byte data ) {
  delay(5);

  int rdata = data;
  Wire.beginTransmission(deviceaddress);
  Wire.send((int)(eeaddress >> 8)); // MSB
  Wire.send((int)(eeaddress & 0xFF)); // LSB
  Wire.send(rdata);
  Wire.endTransmission();
}

static byte i2c_eeprom_read_byte( int deviceaddress, unsigned int eeaddress ) {
  delay(5);
  byte rdata = 0xFF;
  Wire.beginTransmission(deviceaddress);
  Wire.send((int)(eeaddress >> 8)); // MSB
  Wire.send((int)(eeaddress & 0xFF)); // LSB
  Wire.endTransmission();
  Wire.requestFrom(deviceaddress,1);

  if (Wire.available()) rdata = Wire.receive();
  return rdata;
}