#include <OneWire.h>
// vim:set ft=arduino:

// DS18S20 Temperature chip i/o
#define ONEWIRE 8
#define OONEWIRE 9
#define LIGHT 0
float LMAX = 1023;
float LMIN = 0;

// Pressure sensor
// define spi bus pins
#define SLAVESELECT 10 // CSB
#define SPICLOCK 13 // SCK
#define DATAOUT 11 //MOSI
#define DATAIN 12 //MISO
#define UBLB(a,b)  ( ( (a) << 8) | (b) )
#define UBLB19(a,b) ( ( (a) << 16 ) | (b) )

//Addresses
#define REVID 0x01	//ASIC Revision Number
#define OPSTATUS 0x04   //Operation Status
#define STATUS 0x07     //ASIC Status
#define START 0x0A      //Constant Readings, high resolution
#define START 0x0B      // Low power mode
#define PRESSURE 0x1F   //Pressure 3 MSB
#define PRESSURE_LSB 0x20 //Pressure 16 LSB
#define TEMP 0x21       //16 bit temp

// Light sensor
#define TSL_FREQ_PIN 2 // output use digital pin2 for interrupt  
#define TSL_S0       3
#define TSL_S1       5
#define TSL_S2       4
#define TSL_S3       6
#define READ_TM 1000 // milleseconds between frequency calculations

// Pressure variables
char rev_in_byte;	    
int temp_in;
unsigned long pressure_lsb;
unsigned long pressure_msb;
unsigned long temp_pressure;
unsigned long pressure;

// Light variables
int calcSensitivity;   
unsigned long sensitivityHighThresh = 2000;
unsigned long sensitivityLowThresh = 100000;

unsigned long pulseCount = 0;
unsigned long currentTime = millis(); 
unsigned long startTime = currentTime;
unsigned int tm_diff = 0;

// freq will be modified by the interrupt handler so needs to be volatile
// freq holds the latest frequency calculation
unsigned long frequency;
float uWattCm2;
volatile unsigned long curPulseCount;
unsigned int count = 0;
unsigned int scale;   // holds the TLS scale value, see below

// Temperature variables
OneWire ds(ONEWIRE);   // pin 8, outdoor, 3 temps
OneWire ds2(OONEWIRE); // pin 9, indoor, 2 temps
int HighByte, LowByte, TReading, SignBit, Tc_100, Tf_100, Whole, Fract;
int i;
byte data[12];

void setup(void) {
    // Pressure setup
    byte clr;
    pinMode(DATAOUT, OUTPUT);
    pinMode(DATAIN, INPUT);
    pinMode(SPICLOCK,OUTPUT);
    pinMode(SLAVESELECT,OUTPUT);
    digitalWrite(SLAVESELECT,HIGH); //disable device  
    
    SPCR = (1<<SPE)|(1<<MSTR);
    clr=SPSR;
    clr=SPDR;
    delay(10);
    Serial.begin(9600);
    // delay(1000);

    // Serial.println("Initialize High Speed Constant Reading Mode");
    // write_register(0x03,0x09);
    // Serial.println("Initialize low noise configuration");
    write_register(0x02, 0x2D);
    write_register(0x01, 0x03);
    write_register(0x03, 0x02);
    delay(10);
    // Serial.println("Select high resolution mode");
    // write_register(0x03, 0x0A);
    // Serial.println("Select low power mode");
    write_register(0x00, 0x05);
    write_register(0x03, 0x0C);

    // Light sensor setup
    sensitivity(1);
    // Serial.print("Sensitivity  ");
    // Serial.println(calcSensitivity, DEC);
    // Serial.println("Start...");

    // attach interrupt to pin2, send output pin of TSL230R to arduino 2
    // call handler on each rising pulse
    attachInterrupt(0, add_pulse, RISING);

    pinMode(TSL_FREQ_PIN, INPUT);
    pinMode(TSL_S0, OUTPUT); 
    pinMode(TSL_S1, OUTPUT);
    pinMode(TSL_S2, OUTPUT);
    pinMode(TSL_S3, OUTPUT);

    digitalWrite(TSL_S2, HIGH);   // S2 and S3 HIGH = /100 output scaling
    digitalWrite(TSL_S3, HIGH);
    scale = 100; // set this to match TSL_S2 and TSL_S3
}

void write_all(int tc1, int tc2, int tc3, int tc4, int tc5, int light0, unsigned long pressure, unsigned long light) {
    write_temp(tc1);
    Serial.print(",");
    write_temp(tc2);
    Serial.print(",");
    write_temp(tc3);
    Serial.print(",");
    write_temp(tc4);
    Serial.print(",");
    write_temp(tc5);
    Serial.print(",");
    Serial.print(light0);
    Serial.print(",");
    // Serial.print(pressure);
    write_pres(pressure);
    Serial.print(",");
    Serial.print(light);
    Serial.println();
}

void get_all_data(void) {
    // Temperature reads
    byte present = 0;
    byte addr1[] = {40, 24, 188, 246, 1, 0, 0, 89};  // pin 8 master
    byte addr2[] = {40, 214, 63, 2, 2, 0, 0, 203};   // pin 8 slave
    byte addr3[] = {40, 223, 70, 2, 2, 0, 0, 195};   // pin 8 slave
    byte addr4[] = {40, 102, 13, 2, 2, 0, 0, 203};   // pin 9 master
    byte addr5[] = {40, 27, 232, 246, 1, 0, 0, 138}; // pin 9 slave
    int tc1 = 0;
    int tc2 = 0;
    int tc3 = 0;
    int tc4 = 0;
    int tc5 = 0;
    int light0 = 0; // Analog sensor
    unsigned long pressure = 0;
    unsigned long light = 0;

    // Temp 1
    ds.reset();
    ds.select(addr1);
    ds.write(0x44,1); // start conversion, with parasite power on at the end
    delay(750);
    present = ds.reset();
    ds.select(addr1);    
    ds.write(0xBE); // Read Scratchpad
    tc1 = get_c(&ds);

    // Temp 2
    ds.reset();
    ds.select(addr2);
    ds.write(0x44,1); // start conversion, with parasite power on at the end
    delay(750);  // maybe 750ms is enough, maybe not
    present = ds.reset();
    ds.select(addr2);    
    ds.write(0xBE);         // Read Scratchpad
    tc2 = get_c(&ds);

    // Temp 3
    ds.reset();
    ds.select(addr3);
    ds.write(0x44,1);         // start conversion, with parasite power on at the end
    delay(750);     // maybe 750ms is enough, maybe not
    present = ds.reset();
    ds.select(addr3);    
    ds.write(0xBE);         // Read Scratchpad
    tc3 = get_c(&ds);

    // Temp 4
    ds2.reset();
    ds2.select(addr4);
    ds2.write(0x44,1);         // start conversion, with parasite power on at the end
    delay(750);     // maybe 750ms is enough, maybe not
    present = ds2.reset();
    ds2.select(addr4);    
    ds2.write(0xBE);         // Read Scratchpad
    tc4 = get_c(&ds2);

    // Temp 5
    ds2.reset();
    ds2.select(addr5);
    ds2.write(0x44,1);         // start conversion, with parasite power on at the end
    delay(750);     // maybe 750ms is enough, maybe not
    present = ds2.reset();
    ds2.select(addr5);    
    ds2.write(0xBE);         // Read Scratchpad
    tc5 = get_c(&ds2);

    // Analog light sensor
    light0 = scale_light(LMIN, LMAX, analogRead(LIGHT)) * 1000;

    // Pressure sensor
    write_register(0x03, 0x0C);
    delay(10);
    rev_in_byte = read_register(REVID);
    pressure_msb = read_register(PRESSURE);
    pressure_msb &= B00000111;
    pressure_lsb = read_register16(PRESSURE_LSB);
    pressure_lsb &= 0xffff;
    pressure = UBLB19(pressure_msb, pressure_lsb);
    pressure /= 4;
    // Serial.println(pressure);

    temp_in = read_register16(TEMP);
    temp_in = temp_in & 0xffff;
    temp_in = temp_in / 20;
    temp_in = ((1.8) *temp_in) + 32;
    // Serial.println(temp_in);

    // Real light sensor
    light = getUwattCm2();
    setSensitivity();
    write_all(tc1, tc2, tc3, tc4, tc5, light0, pressure, light);
}

void loop(void) {
    get_all_data();
    delay(1000);	// 1.0 second delay.  Adjust as necessary
}

// Pressure functions
char spi_transfer(volatile char data) {
    SPDR = data;			  // Start the transmission
    while (!(SPSR & (1<<SPIF))) {   // Wait for the end of the transmission
    };
    return SPDR;			  // return the received byte
}

char read_register(char register_name) {
    char in_byte;
    register_name <<= 2;
    register_name &= B11111100; //Read command
  
    digitalWrite(SLAVESELECT,LOW); //Select SPI Device
    spi_transfer(register_name); //Write byte to device
    in_byte = spi_transfer(0x00); //Send nothing, but we should get back the register value
    digitalWrite(SLAVESELECT,HIGH);
    delay(20);
    return(in_byte);
}

float read_register16(char register_name) {
    byte in_byte1;
    byte in_byte2;
    float in_word;
    
    register_name <<= 2;
    register_name &= B11111100; //Read command

    digitalWrite(SLAVESELECT,LOW); //Select SPI Device
    spi_transfer(register_name); //Write byte to device
    in_byte1 = spi_transfer(0x00);    
    in_byte2 = spi_transfer(0x00);
    digitalWrite(SLAVESELECT,HIGH);
    in_word = UBLB(in_byte1,in_byte2);
    return(in_word);
}

void write_register(char register_name, char register_value) {
    register_name <<= 2;
    register_name |= B00000010; //Write command

    digitalWrite(SLAVESELECT,LOW); //Select SPI device
    spi_transfer(register_name); //Send register location
    spi_transfer(register_value); //Send value to record into register
    digitalWrite(SLAVESELECT,HIGH);
} 

// Light sensor functions
void add_pulse() {
    // increase pulse count
    pulseCount++;

    // DON'T calculate the frequency every READ_TM ms
    // just store the pulse count to be used outside of the interrupt
    currentTime = millis();
    if( currentTime - startTime >= READ_TM ) {
        curPulseCount = pulseCount;  // use curPulseCount for calculating freq/uW
        pulseCount = 0;    
        startTime = millis();
    }
}

long getUwattCm2() {
    // copy pulse counter and multiply.
    // the multiplication is necessary for the current
    // frequency scaling level. 

    frequency = curPulseCount * scale;

    // get uW observed - assume 640nm wavelength
    // calc_sensitivity is our divide-by to map to a given signal strength
    // for a given sensitivity (each level of greater sensitivity reduces the signal
    // (uW) by a factor of 10)

    float uw_cm2 = (float) frequency / (float) calcSensitivity;

    // extrapolate into entire cm2 area
    uWattCm2  = uw_cm2  * ( (float) 1 / (float) 0.0136 );

    return(uWattCm2);
}
void setSensitivity() {
    getUwattCm2();
    if (uWattCm2 <  sensitivityHighThresh) {
        sensitivity(3);
        return;
    } 
    if (uWattCm2 > sensitivityLowThresh ) {
        sensitivity(1);
        return;
    }
    sensitivity(2);
}
void sensitivity(uint8_t level) {
    switch (level) {
        case 1:
            digitalWrite(TSL_S0, HIGH);  // S0 HIGH and S1 LOW = 1x sensitivity
            digitalWrite(TSL_S1, LOW);
            calcSensitivity = 10;
            break;
        case 2:
            digitalWrite(TSL_S0, LOW);  // S0 LOW and S1 HIGH = 10x sensitivity
            digitalWrite(TSL_S1, HIGH);
            calcSensitivity = 100;
            break;
        case 3:
            digitalWrite(TSL_S0, HIGH);  // S0 HIGH and S1 HIGH = 100x sensitivity
            digitalWrite(TSL_S1, HIGH);
            calcSensitivity = 1000;
            break;
    }
    return;
}

// Temp functions
void flash_led(int led, int dly) {
    digitalWrite(led, HIGH);
    delay(dly);
    digitalWrite(led, LOW);
}

float scale_light(float mn, float mx, int v) {
    // Returns a float between mn and mx 
    // return ((v - mn) / (mx - mn));
    return ((v - mn) / (mx - mn));
}

int get_c(OneWire *d) {
    byte i;
    for ( i = 0; i < 9; i++) {           // we need 9 bytes
        data[i] = d->read();
    }
    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
    return(Tc_100);
}

void write_temp(int Tc_100) {
    Whole = Tc_100 / 100;  // separate off the whole and fractional portions
    Fract = Tc_100 % 100;
    if (SignBit) {
        Serial.print("-");
    }
    Serial.print(Whole);
    Serial.print(".");
    if (Fract < 10) {
        Serial.print("0");
    }
    Serial.print(Fract);
    Serial.print(",");

    Tf_100 = ((Tc_100 * 9) / 5) + 3200;
    Whole = Tf_100 / 100;  // separate off the whole and fractional portions
    Fract = Tf_100 % 100;

    if (SignBit) {
        Serial.print("-");
    }
    Serial.print(Whole);
    Serial.print(".");
    if (Fract < 10) {
        Serial.print("0");
    }
    Serial.print(Fract);
}

void write_pres(unsigned long pres) {
    Whole = pres / 100;  // separate off the whole and fractional portions
    Fract = pres % 100;
    if (SignBit) {
        Serial.print("-");
    }
    Serial.print(Whole);
    Serial.print(".");
    if (Fract < 10) {
        Serial.print("0");
    }
    Serial.print(Fract);
}