#include <Wire.h>
#include <LiquidCrystal.h>
#include <Ethernet.h>
#include <SPI.h>
#include <SdFat.h>

#define BMP085_ADDRESS 0x77                      // I2C address of BMP085

// Ethernet settings
byte mac[] = {0x90, 0xA2, 0xDA, 0x00, 0xDC, 0x33};  // MAC address for ethernet controller, from the box
IPAddress ip(10,0,1,20);
EthernetServer server(9378);

// Sensor settings
const unsigned char OSS = 0;                    // oversampling Setting
int ac1;                                        // Calibration values
int ac2; 
int ac3; 
unsigned int ac4;
unsigned int ac5;
unsigned int ac6;
int b1; 
int b2;
int mb;
int mc;
int md;
long b5; 

int humiditySensorPin = 0;                      // Analog Pin 0

SdFat sd;                                      // SD card, for logging
SdFile myFile;
const int chipSelect = 4;

float adc = 0;
float voltage = 0;
float relativeHumidity = 0;
float degreesC = 0;
float degreesF = 0;
float millibar = 0;

LiquidCrystal lcd(4, 5, 6, 7, 8, 9);            // initialize LCD library with pins

long lastReadingTime = 0;
long pauseBetweenReadings = 60000;               // 60 seconds between data reading/recording


void setup()
{
  lcd.begin(16, 2);                            // lcd initialization
  Wire.begin();                                // initialize sensor
  bmp085Calibration();                         // sensor calibration
  Ethernet.begin(mac, ip);                     // ethernet connection
  server.begin();                              // web server
  
  Serial.begin(9600);                          // SD card setup
  while (!Serial) {}                           // wait for startup
  
  // Initialize SdFat or print a detailed error message and halt
  // Use half speed like the native library.
  // change to SPI_FULL_SPEED for more performance.
  if (!sd.begin(chipSelect, SPI_HALF_SPEED)) sd.initErrorHalt();

    // open the file for write at end like the Native SD library
    if (!myFile.open("data.txt", O_RDWR | O_CREAT | O_AT_END)) {
      sd.errorHalt("opening data.txt for write failed");
    }
    // if the file opened okay, write to it:
    Serial.print("Writing header to data.txt");
    myFile.println("degreesC, relativeHumidity, millibar");

    // close the file:
    myFile.close();
  
  delay(1000);                                // wait for sensor and ethernet shield to start up
}

void loop()
{
  if (millis() - lastReadingTime > pauseBetweenReadings) {
    getData();
    lastReadingTime = millis();               // record time of reading
    writeDataToCard();
    writeDataToSerial();
  }
  
  listenForEthernetClients();                 // listen for incoming Ethernet connections
}



void getData() {
  short temperatureValue = bmp085GetTemperature(bmp085ReadUT());
  degreesC = temperatureValue / 10;
  degreesF = degreesC * 1.8 + 32;
  
  const float p0 = 101325;                      // Pressure at sea level (Pa)
  long pressure = bmp085GetPressure(bmp085ReadUP());
  millibar = pressure/100;
  float altitude = (float)44330 * (1 - pow(((float) pressure/p0), 0.190295)) * 3.28084;
  
  adc = analogRead(humiditySensorPin);          // Read sensor adc voltage (adcValue is 0-1023)
  voltage = (adc/1023.0)*5.0;                   // Convert adc to voltage (5V circuit)
  relativeHumidity = (voltage-0.958)/0.0307;    // Convert voltage to relative humidity
  
  lcd.setCursor(0, 0);                          // column, line
  lcd.print(relativeHumidity,0);
  lcd.print("% RH   ");
  
  lcd.setCursor(9, 0);
  lcd.print(degreesC, 0);
  lcd.print(" C  ");
  
  lcd.setCursor(0, 1);
  lcd.print(millibar, 0);
  lcd.print(" mb     ");
}


void writeDataToCard() {
    if (!myFile.open("data.txt", O_RDWR | O_CREAT | O_AT_END)) {
      sd.errorHalt("opening data.txt for write failed");
    }
    
    myFile.print(degreesC);
    myFile.print(", ");
    myFile.print(relativeHumidity);
    myFile.print(", ");
    myFile.print(millibar);
    myFile.println();    // most reliable way to create a new line
    
    myFile.close();
}

void writeDataToSerial() {
    Serial.print(degreesC);
    Serial.print(", ");
    Serial.print(relativeHumidity);
    Serial.print(", ");
    Serial.print(millibar);
    Serial.print("\n");
}



void listenForEthernetClients() {
  EthernetClient client = server.available();
  
  if (client) {
    Serial.println("Got a client");
    boolean currentLineIsBlank = true;
    while (client.connected()) {
      if (client.available()) {                 // send a reply
        char c = client.read();
        if (c == "\n" && currentLineIsBlank) {
          //client.println("HTTP/1.1 200 OK");
          //client.println("Content-Type: text/html");
          client.println();
          client.print(degreesC, 0);
          client.print(", ");
          client.print(relativeHumidity,0);
          client.print(", ");
          client.print(millibar,0);
          break;
        }
        if (c == "\n") {                        // starting a new line
          currentLineIsBlank = true;
        } 
        else if (c != "\r") {                   // a character on the current line
          currentLineIsBlank = false;
        }
      }
    }

    delay(1);                                   // give browser time to receive data
    
    client.stop();                              // close the connection
  }
}





// Stores all of the bmp085&rsquo;s calibration values into global variables
// Calibration values are required to calculate temp and pressure
// This function should be called at the beginning of the program
void bmp085Calibration()
{
  ac1 = bmp085ReadInt(0xAA);
  ac2 = bmp085ReadInt(0xAC);
  ac3 = bmp085ReadInt(0xAE);
  ac4 = bmp085ReadInt(0xB0);
  ac5 = bmp085ReadInt(0xB2);
  ac6 = bmp085ReadInt(0xB4);
  b1 = bmp085ReadInt(0xB6);
  b2 = bmp085ReadInt(0xB8);
  mb = bmp085ReadInt(0xBA);
  mc = bmp085ReadInt(0xBC);
  md = bmp085ReadInt(0xBE);
}




// Calculate temperature given ut.
// Value returned will be in units of 0.1 deg C
short bmp085GetTemperature(unsigned int ut)
{
  long x1, x2;
  
  x1 = (((long)ut - (long)ac6)*(long)ac5) >> 15;
  x2 = ((long)mc << 11)/(x1 + md);
  b5 = x1 + x2;

  return ((b5 + 8)>>4);  
}




// Calculate pressure given up
// calibration values must be known
// b5 is also required so bmp085GetTemperature(...) must be called first.
// Value returned will be pressure in units of Pa.
long bmp085GetPressure(unsigned long up)
{
  long x1, x2, x3, b3, b6, p;
  unsigned long b4, b7;
  
  b6 = b5 - 4000;
  // Calculate B3
  x1 = (b2 * (b6 * b6)>>12)>>11;
  x2 = (ac2 * b6)>>11;
  x3 = x1 + x2;
  b3 = (((((long)ac1)*4 + x3)<<OSS) + 2)>>2;
  
  // Calculate B4
  x1 = (ac3 * b6)>>13;
  x2 = (b1 * ((b6 * b6)>>12))>>16;
  x3 = ((x1 + x2) + 2)>>2;
  b4 = (ac4 * (unsigned long)(x3 + 32768))>>15;
  
  b7 = ((unsigned long)(up - b3) * (50000>>OSS));
  if (b7 < 0x80000000)
    p = (b7<<1)/b4;
  else
    p = (b7/b4)<<1;
    
  x1 = (p>>8) * (p>>8);
  x1 = (x1 * 3038)>>16;
  x2 = (-7357 * p)>>16;
  p += (x1 + x2 + 3791)>>4;
  
  return p;
}




// Read 1 byte from the BMP085 at "address"
char bmp085Read(unsigned char address)
{
  unsigned char data;
  
  Wire.beginTransmission(BMP085_ADDRESS);
  Wire.write(address);
  Wire.endTransmission();
  
  Wire.requestFrom(BMP085_ADDRESS, 1);
  while(!Wire.available())
    ;
    
  return Wire.read();
}




// Read 2 bytes from the BMP085
// First byte will be from "address"
// Second byte will be from "address"+1
int bmp085ReadInt(unsigned char address)
{
  unsigned char msb, lsb;
  
  Wire.beginTransmission(BMP085_ADDRESS);
  Wire.write(address);
  Wire.endTransmission();
  
  Wire.requestFrom(BMP085_ADDRESS, 2);
  while(Wire.available()<2)
    ;
  msb = Wire.read();
  lsb = Wire.read();
  
  return (int) msb<<8 | lsb;
}




// Read the uncompensated temperature value
unsigned int bmp085ReadUT()
{
  unsigned int ut;
  
  // Write 0x2E into Register 0xF4
  // This requests a temperature reading
  Wire.beginTransmission(BMP085_ADDRESS);
  Wire.write(0xF4);
  Wire.write(0x2E);
  Wire.endTransmission();
  
  // Wait at least 4.5ms
  delay(5);
  
  // Read two bytes from registers 0xF6 and 0xF7
  ut = bmp085ReadInt(0xF6);
  return ut;
}




// Read the uncompensated pressure value
unsigned long bmp085ReadUP()
{
  unsigned char msb, lsb, xlsb;
  unsigned long up = 0;
  
  // Write 0x34+(OSS<<6) into register 0xF4
  // Request a pressure reading w/ oversampling setting
  Wire.beginTransmission(BMP085_ADDRESS);
  Wire.write(0xF4);
  Wire.write(0x34 + (OSS<<6));
  Wire.endTransmission();
  
  // Wait for conversion, delay time dependent on OSS
  delay(2 + (3<<OSS));
  
  // Read register 0xF6 (MSB), 0xF7 (LSB), and 0xF8 (XLSB)
  Wire.beginTransmission(BMP085_ADDRESS);
  Wire.write(0xF6);
  Wire.endTransmission();
  Wire.requestFrom(BMP085_ADDRESS, 3);
  
  // Wait for data to become available
  while(Wire.available() < 3)
    ;
  msb = Wire.read();
  lsb = Wire.read();
  xlsb = Wire.read();
  
  up = (((unsigned long) msb << 16) | ((unsigned long) lsb << 8) | (unsigned long) xlsb) >> (8-OSS);
  
  return up;
}