Diff: MAX31856.cpp

Revision:

1:b58719a76fc3

Parent:

0:456e9e702d57

Child:

2:296485923589

diff -r 456e9e702d57 -r b58719a76fc3 MAX31856.cpp
--- a/MAX31856.cpp	Wed Jul 19 17:05:46 2017 +0000
+++ b/MAX31856.cpp	Wed Jul 26 17:03:59 2017 +0000
@@ -3,36 +3,51 @@
 
 #define LOG(args...)    printf(args)
 
-MAX31856::MAX31856(SPI& _spi, PinName _ncs, uint8_t _type, uint8_t _fltr) : spi(_spi), ncs(_ncs)//, setThermocoupleType(_type), setEmiFilterFreq(_fltr)
-{
+MAX31856::MAX31856(SPI& _spi, PinName _ncs, uint8_t _type, uint8_t _fltr, uint8_t _samples, uint8_t _conversion_mode) : spi(_spi), ncs(_ncs), samples(_samples) {  //, setThermocoupleType(_type), setEmiFilterFreq(_fltr)
+    spi.format(8,3);
     setThermocoupleType(_type);
     setEmiFilterFreq(_fltr);
+    setNumSamplesAvg(_samples);
+    setConversionMode(_conversion_mode);
 }
 
 float MAX31856::readTC()
 {
     int32_t temp;
-    uint8_t buf_read[4], buf_write=MAX31856_ADDRESS_LTCBH_READ;
+    uint8_t buf_read[3], buf_write[3]={ADDRESS_LTCBH_READ,ADDRESS_LTCBM_READ,ADDRESS_LTCBL_READ};
+    
+//    uint32_t time = us_ticker_read();
+//    uint32_t duration = time - lastReadTime;
+//    if (duration > 200000) {   // more than 250ms
+/*        for(int i=0; i<3; i++) {
+            spiEnable();
+            buf_read[i]=spi.write(buf_write[i]);
+            buf_read[i]=spi.write(buf_write[i]);
+            spiDisable();
+        }   
+*/
     
     spiEnable();
-    for(int i=0; i<4; i++)
-    {
-        buf_read[i]=spi.write(buf_write);
-    }
+    buf_read[0]=spi.write(0x0C);
+    buf_read[0]=spi.write(0x0C);
+    buf_read[1]=spi.write(0x0C);
+    buf_read[2]=spi.write(0x0C);
     spiDisable();
-    
-    //Convert the registers contents into the correct value
-    temp =((int32_t)(buf_read[1] << 16));       //Shift Byte 2 into place
-    temp|=((int32_t)(buf_read[2] << 3));        //Shift Byte 1 into place
-    temp|=((int32_t)(buf_read[3] >> 5));        //Shift Byte 0 into place
-    float val=((float)(temp/128.0));            //Divide the binary string by 2 to the 7th power
-    return val;
+
+        
+        //Convert the registers contents into the correct value
+        temp =((buf_read[0] & 0xFF) << 11);       //Shift Byte 2 into place
+        temp|=((buf_read[1] & 0xFF) << 3);        //Shift Byte 1 into place
+        temp|=((buf_read[2] & 0xFF) >> 5);        //Shift Byte 0 into place
+        float val=(temp/128.0f);            //Divide the binary string by 2 to the 7th power
+        return val;
+//  }
 }
 
 float MAX31856::readCJ()
 {
     int32_t temp;
-    uint8_t buf_read[3], buf_write=MAX31856_ADDRESS_CJTH_READ;
+    uint8_t buf_read[3], buf_write=ADDRESS_CJTH_READ;
     
     spiEnable();
     for(int i=0; i<3; i++)
@@ -49,110 +64,370 @@
     return val;
 }
 
-bool MAX31856::setNumSamplesAvg(uint8_t val)
-{   
-    int return_val;
+//Register:CR0    Bits: 7
+bool MAX31856::setConversionMode(uint8_t val) {
+    bool return_val;
+    //Check if the parameter passed in is valid
+    if      (val==CR0_CONV_MODE_NORMALLY_OFF) {
+        return_val=registerReadWriteByte(ADDRESS_CR0_READ, ADDRESS_CR0_WRITE, CR0_CLEAR_BITS_7, val);
+        conversion_mode=0;
+    } 
+    else if (val==CR0_CONV_MODE_NORMALLY_ON) {
+        return_val=registerReadWriteByte(ADDRESS_CR0_READ, ADDRESS_CR0_WRITE, CR0_CLEAR_BITS_7, val);
+        conversion_mode=1;
+    }
+    else {
+        LOG("Incorrect parameter selected for Control Register 0 (CR0) bit 7. Default value not changed.\r\nPlease see MAX31856.h for list of valid parameters. \r\n"); 
+        return_val=0; //returns a 0 to flag that the parameter wasn't programmed due to wrong parameter in function call
+    }
+    return return_val;
+}
+
+//Register:CR0    Bits: 6
+bool MAX31856::setOneShotMode(uint8_t val) {
+    bool return_val;
+    //Check if the parameter passed in is valid
+    if (val==CR0_1_SHOT_MODE_NO_CONVERSIONS || val==CR0_1_SHOT_MODE_ONE_CONVERSION) 
+        return_val=registerReadWriteByte(ADDRESS_CR0_READ, ADDRESS_CR0_WRITE, CR0_CLEAR_BITS_6, val);
+    else {
+        LOG("Incorrect parameter selected for Control Register 0 (CR0) bit 6. Default value not changed.\r\nPlease see MAX31856.h for list of valid parameters. \r\n"); 
+        return_val=0; //returns a 0 to flag that the parameter wasn't programmed due to wrong parameter in function call
+    }
+    return return_val;
+}
+
+//Register:CR0    Bits: 5:4
+bool MAX31856::setOpenCircuitFaultDetection(uint8_t val) {
+    bool return_val;
+    //Check if the parameter passed in is valid
+    if (val==CR0_OC_DETECT_DISABLED || val==CR0_OC_DETECT_ENABLED_R_LESS_5k || val==CR0_OC_DETECT_ENABLED_TC_LESS_2ms || val==CR0_OC_DETECT_ENABLED_TC_MORE_2ms)  
+        return_val=registerReadWriteByte(ADDRESS_CR0_READ, ADDRESS_CR0_WRITE, CR0_CLEAR_BITS_5_4, val);
+    else {
+        LOG("Incorrect parameter selected for Control Register 0 (CR0) bits 5:4. Default value not changed.\r\nPlease see MAX31856.h for list of valid parameters. \r\n"); 
+        return_val=0; //returns a 0 to flag that the parameter wasn't programmed due to wrong parameter in function call
+    }
+    return return_val;
+}
+
+//Register:CR0    Bits: 3
+bool MAX31856::setColdJunctionDisable(uint8_t val) {
+    bool return_val;
+    //Check if the parameter passed in is valid
+    if (val==CR0_COLD_JUNC_ENABLE) { 
+        return_val=registerReadWriteByte(ADDRESS_CR0_READ, ADDRESS_CR0_WRITE, CR0_CLEAR_BITS_3, val);
+        cold_junction_enabled=1;
+    }
+    else if (val==CR0_COLD_JUNC_DISABLE) {
+        return_val=registerReadWriteByte(ADDRESS_CR0_READ, ADDRESS_CR0_WRITE, CR0_CLEAR_BITS_3, val);
+        cold_junction_enabled=0;
+    }
+    else {
+        LOG("Incorrect parameter selected for Control Register 0 (CR0) bit 3. Default value not changed.\r\nPlease see MAX31856.h for list of valid parameters. \r\n"); 
+        return_val=0; //returns a 0 to flag that the parameter wasn't programmed due to wrong parameter in function call
+    }
+    return return_val;
+}
+
+//Register:CR0    Bits: 2
+bool MAX31856::setFaultMode(uint8_t val) {
+    bool return_val;
     //Check if the parameter passed in is valid
-    if (val==MAX31856_CR1_AVG_TC_SAMPLES_1 || val==MAX31856_CR1_AVG_TC_SAMPLES_2 || val==MAX31856_CR1_AVG_TC_SAMPLES_4 || val==MAX31856_CR1_AVG_TC_SAMPLES_8 || val==MAX31856_CR1_AVG_TC_SAMPLES_16)
-    {
-        uint8_t buf_read[2], buf_write=MAX31856_ADDRESS_CR1_READ;
-        //Read the current contents of CR1
-        spiEnable();
-        for(int i=0; i<2; i++)
-        {
-            buf_read[i]=spi.write(buf_write);
-        }
-        spiDisable();
-        //Modify contents of CR1
-        buf_read[1]&=MAX31856_CR1_CLEAR_PREV_VOLT_AVG_SAMPLES;  //Clear the contents of bits 6:4 of CR1 to 000 to set new parameter
-        buf_read[1]|=val;                                       //Bitwise OR the input parameter with cleaned buf_read[1] to create new byte for CR1
-        buf_write=buf_read[1];
-        //Write the contents of CR1 with the updated bits 6:4 needed for setting number of samples to average
-        spiEnable();
-        for(int i=0; i<2; i++)
-        {
-            buf_read[i]=spi.write(buf_write);
-        }
-        spiDisable();
-        return_val=1; //returns a 1 to flag that the parameter was programmed
+    if (val==CR0_FAULT_MODE_COMPARATOR || val==CR0_FAULT_MODE_INTERUPT) 
+        return_val=registerReadWriteByte(ADDRESS_CR0_READ, ADDRESS_CR0_WRITE, CR0_CLEAR_BITS_2, val);
+    else {
+        LOG("Incorrect parameter selected for Control Register 0 (CR0) bit 2. Default value not changed.\r\nPlease see MAX31856.h for list of valid parameters. \r\n"); 
+        return_val=0; //returns a 0 to flag that the parameter wasn't programmed due to wrong parameter in function call
+    }
+    return return_val;
+}
+
+//Register:CR0    Bits: 1
+bool MAX31856::setFaultStatusClear(uint8_t val) {
+    bool return_val;
+    //Check if the parameter passed in is valid
+    if (val==CR0_FAULTCLR_DEFAULT_VAL || val==CR0_FAULTCLR_RETURN_FAULTS_TO_ZERO) 
+        return_val=registerReadWriteByte(ADDRESS_CR0_READ, ADDRESS_CR0_WRITE, CR0_CLEAR_BITS_1, val);
+    else {
+        LOG("Incorrect parameter selected for Control Register 0 (CR0) bit 1. Default value not changed.\r\nPlease see MAX31856.h for list of valid parameters. \r\n"); 
+        return_val=0; //returns a 0 to flag that the parameter wasn't programmed due to wrong parameter in function call
+    }
+    return return_val;
+}
+
+//Register:CR0    Bits: 0
+bool MAX31856::setEmiFilterFreq(uint8_t val) {
+    bool return_val;
+    //Check if the parameter passed in is valid
+    if      (val==CR0_FILTER_OUT_60Hz) {
+        return_val=registerReadWriteByte(ADDRESS_CR0_READ, ADDRESS_CR0_WRITE, CR0_CLEAR_BITS_0, val);
+        filter_mode=0;
+    }
+    else if (val==CR0_FILTER_OUT_50Hz) {
+        return_val=registerReadWriteByte(ADDRESS_CR0_READ, ADDRESS_CR0_WRITE, CR0_CLEAR_BITS_0, val);
+        filter_mode=1;
     }
-    else
-    {
+    else {
+        LOG("Incorrect parameter selected for Control Register 0 (CR0) bit 0. Default value not changed.\r\nPlease see MAX31856.h for list of valid parameters. \r\n"); 
+        return_val=0; //returns a 0 to flag that the parameter wasn't programmed due to wrong parameter in function call
+    }
+    return return_val;
+}
+
+//Register:CR1    Bits: 6:4
+bool MAX31856::setNumSamplesAvg(uint8_t val) {   
+    bool return_val;
+    
+    //Check if the parameter passed in is valid and set the 
+    if      (val==CR1_AVG_TC_SAMPLES_1) {
+        return_val=registerReadWriteByte(ADDRESS_CR1_READ, ADDRESS_CR1_WRITE, CR1_CLEAR_BITS_6_4, val);
+        samples=1;
+    }
+    else if (val==CR1_AVG_TC_SAMPLES_2) {
+        return_val=registerReadWriteByte(ADDRESS_CR1_READ, ADDRESS_CR1_WRITE, CR1_CLEAR_BITS_6_4, val);
+        samples=2;
+    }
+    else if (val==CR1_AVG_TC_SAMPLES_4) {
+        return_val=registerReadWriteByte(ADDRESS_CR1_READ, ADDRESS_CR1_WRITE, CR1_CLEAR_BITS_6_4, val);
+        samples=4;
+    }
+    else if (val==CR1_AVG_TC_SAMPLES_8) {
+        return_val=registerReadWriteByte(ADDRESS_CR1_READ, ADDRESS_CR1_WRITE, CR1_CLEAR_BITS_6_4, val);
+        samples=8;
+    }
+    else if (val==CR1_AVG_TC_SAMPLES_16) {
+        return_val=registerReadWriteByte(ADDRESS_CR1_READ, ADDRESS_CR1_WRITE, CR1_CLEAR_BITS_6_4, val);
+        samples=16;
+    }
+    else {
         LOG("Incorrect parameter selected for Control Register 1 (CR1) bits 6:4. Default value not changed.\r\nPlease see MAX31856.h for list of valid parameters. \r\n"); 
         return_val=0; //returns a 0 to flag that the parameter wasn't programmed due to wrong parameter in function call
     }
     return return_val;
 }
 
-bool MAX31856::setThermocoupleType(uint8_t val)
-{   
-    int return_val;
+//Register:CR1    Bits: 3:0
+bool MAX31856::setThermocoupleType(uint8_t val) {   
+    bool return_val;
     //Check if the parameter passed in is valid
-    if (val==MAX31856_CR1_TC_TYPE_B || val==MAX31856_CR1_TC_TYPE_E || val==MAX31856_CR1_TC_TYPE_J || val==MAX31856_CR1_TC_TYPE_K || val==MAX31856_CR1_TC_TYPE_N || val==MAX31856_CR1_TC_TYPE_R || val==MAX31856_CR1_TC_TYPE_S || val==MAX31856_CR1_TC_TYPE_T || val==MAX31856_CR1_TC_TYPE_VOLT_MODE_GAIN_8 || val==MAX31856_CR1_TC_TYPE_VOLT_MODE_GAIN_32)
-    {
-        uint8_t buf_read[2], buf_write=MAX31856_ADDRESS_CR1_READ;
-        //Read the current contents of CR1
-        spiEnable();
-        for(int i=0; i<2; i++)
-        {
-            buf_read[i]=spi.write(buf_write);
+    if (val==CR1_TC_TYPE_B || val==CR1_TC_TYPE_E || val==CR1_TC_TYPE_J || val==CR1_TC_TYPE_K || val==CR1_TC_TYPE_N || val==CR1_TC_TYPE_R || val==CR1_TC_TYPE_S || val==CR1_TC_TYPE_T) {
+        return_val=registerReadWriteByte(ADDRESS_CR1_READ, ADDRESS_CR1_WRITE, CR1_CLEAR_BITS_3_0, val);
+        voltage_mode=false;
+    }
+    else if (val==CR1_TC_TYPE_VOLT_MODE_GAIN_8 || val==CR1_TC_TYPE_VOLT_MODE_GAIN_32) {
+        return_val=registerReadWriteByte(ADDRESS_CR1_READ, ADDRESS_CR1_WRITE, CR1_CLEAR_BITS_3_0, val);
+        voltage_mode=true;
+    }
+    else {
+        LOG("Incorrect parameter selected for Control Register 1 (CR1) bits 3:0. Default value not changed.\r\nPlease see MAX31856.h for list of valid parameters. \r\n"); 
+        return_val=0; //returns a 0 to flag that the parameter wasn't programmed due to wrong parameter in function call
+    }
+    return return_val;
+}
+
+//Register:MASK    Bits: 5:0
+bool MAX31856::setFaultMasks(uint8_t val, bool enable) {
+    bool return_val;
+    uint8_t temp_val;
+    if(enable)
+        temp_val=0;
+    else
+        temp_val=val;
+    if      (val==MASK_CJ_FAULT_THRESHOLD_HIGH)           //Cold Junction High Threshold Fault Mask
+        return_val=registerReadWriteByte(ADDRESS_MASK_READ, ADDRESS_MASK_WRITE, MASK_CLEAR_BITS_5, temp_val);
+    else if (val==MASK_CJ_FAULT_THRESHOLD_LOW)            //Cold Junction Low  Threshold Fault Mask
+        return_val=registerReadWriteByte(ADDRESS_MASK_READ, ADDRESS_MASK_WRITE, MASK_CLEAR_BITS_4, temp_val);
+    else if (val==MASK_TC_FAULT_THRESHOLD_HIGH)           //Thermocouple High Threshold Fault Mask
+        return_val=registerReadWriteByte(ADDRESS_MASK_READ, ADDRESS_MASK_WRITE, MASK_CLEAR_BITS_3, temp_val);
+    else if (val==MASK_TC_FAULT_THRESHOLD_LOW)            //Thermocouple Low  Threshold Fault Mask
+        return_val=registerReadWriteByte(ADDRESS_MASK_READ, ADDRESS_MASK_WRITE, MASK_CLEAR_BITS_2, temp_val);
+    else if (val==MASK_OVER_UNDER_VOLT_FAULT)             //Over-Voltage/Under-Voltage Input Fault Mask
+        return_val=registerReadWriteByte(ADDRESS_MASK_READ, ADDRESS_MASK_WRITE, MASK_CLEAR_BITS_1, temp_val);
+    else if (val==MASK_OPEN_CIRCUIT_FAULT)                //Thermocouple Open-Circuit Fault Mask
+        return_val=registerReadWriteByte(ADDRESS_MASK_READ, ADDRESS_MASK_WRITE, MASK_CLEAR_BITS_0, temp_val);
+    else {
+        LOG("Incorrect parameter selected for Control Register 1 (CR1) bits 3:0. Default value not changed.\r\nPlease see MAX31856.h for list of valid parameters. \r\n"); 
+        return_val=0; //returns a 0 to flag that the parameter wasn't programmed due to wrong parameter in function call
+    }
+    return return_val;
+}
+
+//Register:MASK    Bits: 5:0
+float MAX31856::setFaultThresholds(uint8_t val, bool enable_mask, float temperature) {
+    float return_val;
+    uint8_t temp_val;
+    if(enable_mask) {
+        temp_val=0;
+    }
+    else {
+        temp_val=val;
+    }
+    if      (val==MASK_CJ_FAULT_THRESHOLD_HIGH) {          //Cold Junction High Threshold Fault Mask
+        return_val=registerReadWriteByte(ADDRESS_MASK_READ, ADDRESS_MASK_WRITE, MASK_CLEAR_BITS_5, temp_val);
+        
+        int8_t temperature_byte=temperature;
+        
+        if      (temperature_byte>CJ_MAX_VAL_FAULT)
+            temperature_byte=CJ_MAX_VAL_FAULT;
+        else if (temperature_byte<=0 || temperature_byte>=CJ_MIN_VAL_FAULT)            
+            temperature_byte=twosComplimentToSigned8(temperature_byte);    //Convert the 2's compliment int into a signed value
+        else if (temperature_byte<CJ_MIN_VAL_FAULT)
+            temperature_byte=twosComplimentToSigned8(CJ_MIN_VAL_FAULT);    //Convert the 2's compliment int into a signed value
+        //else the data is within range, no more manipulation of data is needed
+        return_val=registerWriteByte(ADDRESS_CJHF_WRITE, temperature_byte);
+    }
+    else if (val==MASK_CJ_FAULT_THRESHOLD_LOW) {           //Cold Junction Low  Threshold Fault Mask
+        return_val=registerReadWriteByte(ADDRESS_MASK_READ, ADDRESS_MASK_WRITE, MASK_CLEAR_BITS_4, temp_val);
+        
+        int8_t temperature_byte=temperature;
+        
+        if      (temperature_byte>CJ_MAX_VAL_FAULT)
+            temperature_byte=CJ_MAX_VAL_FAULT;
+        else if (temperature_byte<=0 || temperature_byte>=CJ_MIN_VAL_FAULT) 
+            temperature_byte=twosComplimentToSigned8(temperature_byte);    //Convert the 2's compliment int into a signed value
+        else if (temperature_byte<CJ_MIN_VAL_FAULT)
+            temperature_byte=twosComplimentToSigned8(CJ_MIN_VAL_FAULT);    //Convert the 2's compliment int into a signed value
+        //else the data is within range, no more manipulation of data is needed
+        
+        return_val=registerWriteByte(ADDRESS_CJLF_WRITE, temperature_byte);
+    }
+    else if (val==MASK_TC_FAULT_THRESHOLD_HIGH) {          //Thermocouple High Threshold Fault Mask
+        return_val=registerReadWriteByte(ADDRESS_MASK_READ, ADDRESS_MASK_WRITE, MASK_CLEAR_BITS_3, temp_val);
+        
+        if (temperature) {
+            int8_t temperature_byte[2];
+            int16_t temperature_multi_byte =(int16_t)(temperature*4.0);
+            if      (temperature_multi_byte>(TC_MAX_VAL_FAULT*4.0f))                     
+                temperature_multi_byte=TC_MAX_VAL_FAULT*4.0f;
+            else if (temperature_multi_byte<=0 || temperature_multi_byte>=(TC_MIN_VAL_FAULT*4.0f)) 
+                temperature_multi_byte=twosComplimentToSigned16(temperature_multi_byte);    //Convert the 2's compliment int into a signed value
+            else if (temperature_multi_byte<(TC_MIN_VAL_FAULT*4.0f))
+                temperature_multi_byte=twosComplimentToSigned16(TC_MIN_VAL_FAULT*4.0f);    //Convert the 2's compliment int into a signed value
+            
+            //now split up the 32bit int into two bytes to program the registers with
+            temperature_byte[0]=((uint8_t)((temperature_multi_byte)&(0xFF00) >> 8));
+            temperature_byte[1]=((uint8_t)((temperature_multi_byte)&(0x00FF)));
+            
+            return_val=registerWriteByte(ADDRESS_LTHFTH_WRITE, temperature_byte[0]);
+            return_val=registerWriteByte(ADDRESS_LTHFTL_WRITE, temperature_byte[1]);
+            
+            return_val=temperature;
         }
-        spiDisable();
-        //Modify contents of CR1
-        buf_read[1]&=MAX31856_CR1_CLEAR_PREV_TC_TYPE;  //Clear the contents of bits 3:0 of CR1 to 0000 to set new thermocouple type
-        buf_read[1]|=val;                                       //Bitwise OR the input parameter with cleaned buf_read[1] to create new byte for CR1
-        val=buf_read[1];
-        //Write the contents of CR1 with the updated bits 6:4 needed for setting new thermocouple type
-        spiEnable();
-        for(int i=0; i<2; i++)
-        {
-            buf_read[i]=spi.write(buf_write);
-        }
-        spiDisable();
-        return_val=1; //returns a 1 to flag that the parameter was programmed
+//        else {
+//            /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////return_val="WHATEVER IS IN THE REGISTERS WHEN YOU SET THE FLAG JUST INCASE YOU NEED TO SEE WHAT IS INSISIDE THE REGISTER";
+//        }
     }
-    else
-    {
-        LOG("Incorrect parameter selected for Control Register 1 (CR1) bits 3:0. Default value not changed.\r\nPlease see MAX31856.h for list of valid parameters. \r\n"); 
+    else if (val==MASK_TC_FAULT_THRESHOLD_LOW)            //Thermocouple Low  Threshold Fault Mask
+        return_val=registerReadWriteByte(ADDRESS_MASK_READ, ADDRESS_MASK_WRITE, MASK_CLEAR_BITS_2, temp_val);
+    else if (val==MASK_OVER_UNDER_VOLT_FAULT)             //Over-Voltage/Under-Voltage Input Fault Mask
+        return_val=registerReadWriteByte(ADDRESS_MASK_READ, ADDRESS_MASK_WRITE, MASK_CLEAR_BITS_1, temp_val);
+    else if (val==MASK_OPEN_CIRCUIT_FAULT)                //Thermocouple Open-Circuit Fault Mask
+        return_val=registerReadWriteByte(ADDRESS_MASK_READ, ADDRESS_MASK_WRITE, MASK_CLEAR_BITS_0, temp_val);
+    else {
+        LOG("Incorrect parameter selected for MASK Register. Default value not changed.\r\nPlease see MAX31856.h for list of valid parameters. \r\n"); 
         return_val=0; //returns a 0 to flag that the parameter wasn't programmed due to wrong parameter in function call
     }
     return return_val;
 }
 
 
-bool MAX31856::changeOneBit(uint8_t address, uint8_t val)
-{   
-    uint8_t inverse_val=~(val), buf_read[2], buf_write=address;
+
+
+
+
+//The following functions are for internal library use only
+void MAX31856::spiEnable() {
+    ncs=0; //Set CS high to start transmission (interrupts conversion)
+    return;
+}
+void MAX31856::spiDisable() {
+    ncs=1; //Set CS low to stop transmission (restarts conversion)
+    return;
+}
+
+bool MAX31856::registerReadWriteByte(uint8_t read_address, uint8_t write_address, uint8_t clear_bits, uint8_t val) {   
+    uint8_t buf_read[2];
+    
     //Read the current contents of a register
     spiEnable();
-    for(int i=0; i<2; i++)
-    {
-        buf_read[i]=spi.write(buf_write);
+    for(int i=0; i<2; i++) {
+        buf_read[i]=spi.write(read_address);
     }
     spiDisable();
-    //Modify contents of CR1
-    buf_read[1]&=inverse_val;  //Clear the contents of bits of parameter you are trying to clear for later or equal operation
-    buf_read[1]|=val;          //Bitwise OR the input parameter with cleaned buf_read[1] to create new byte
+    
+    //Modify contents pulled from the register 
+    buf_read[1]&=clear_bits;    //Clear the contents of bits of parameter you are trying to clear for later or equal operation
+    buf_read[1]|=val;       //Bitwise OR the input parameter with cleaned buf_read[1] to create new byte
     val=buf_read[1];
+    
     //Write the updated byte to the register 
     spiEnable();
-    buf_read[0]=spi.write(address);
+    buf_read[0]=spi.write(write_address);
+    buf_read[1]=spi.write(val);
+    spiDisable();
+    return true;
+}
+
+bool MAX31856::registerWriteByte(uint8_t write_address, uint8_t val) {   
+    uint8_t buf_read[2];
+    //Write the updated byte to the register 
+    spiEnable();
+    buf_read[0]=spi.write(write_address);
     buf_read[1]=spi.write(val);
     spiDisable();
     return true;
 }
 
+int8_t MAX31856::twosComplimentToSigned8(int8_t temp){
+    temp=(~(temp)+1);               //Take two's complement of the negative number
+    temp|=(int8_t)(0x80UL);                 //And convert it into 7-bit val with msb as sign bit
+    return temp;
+}
+int16_t MAX31856::twosComplimentToSigned16(int16_t temp){
+    temp=(~(temp)+1);               //Take two's complement of the negative number
+    temp|=(int16_t)(0x8000UL);               //And convert it into 15-bit val with msb as sign bit
+    return temp;
+}
+
+//bool MAX31856::checkForFaults() {
+//    
+//}
+
+
 
 
-void spiEnable()
-{
-    ncs=1; //Set CS high to start transmission (interrupts conversion)
-    return;
-}
-void spiDisable()
-{
-    ncs=0; //Set CS low to stop transmission (restarts conversion)
-    return;
-}
+///Define parameters for control register one (CR1)
+/** Adding Samples increases the conversion time and reduces noise.
+    Typical conversion times:
+        1-shot or first conversion in Auto mode:
+            = t_Conversion + (samples-1)*33.33mS (60Hz rejection)
+            = t_Conversion + (samples-1)*40.00mS (50Hz rejection)
+        2 thru n conversions in Auto mode:
+            = t_Conversion + (samples-1)*16.67mS (60Hz rejection)
+            = t_Conversion + (samples-1)*20.00mS (50Hz rejection)
+*/
+
 
 
+//uint32_t MAX31856::calculateDelayTime() {
+//    uint32_t delayTime;
+//    
+//    if      (auto_convert_mode==1 && samples==1) { //single conversion
+//        if (filter_mode==0)  //60Hz
+//            delayTime=82+(samples-1)*33.33f;
+//        if (filter_mode==1)  //50Hz
+//            delayTime=98+(samples-1)*40.00f;
+//    }
+//    else if (auto_convert_mode==1 && samples>1) { //single conversion
+//        if (filter_mode==0)  //60Hz
+//            delayTime=82+(samples-1)*33.33f;
+//        if (filter_mode==1)  //50Hz
+//            delayTime=98+(samples-1)*40.00f;
+//    }
+//    
+//            
+//            
+//            
+//auto 50   169
+//auto 60   143
+//1shot 50  98
+//1shot 60  82