Diff: MAX31856.cpp

Revision:

2:296485923589

Parent:

1:b58719a76fc3

Child:

3:a99a4367c909

--- a/MAX31856.cpp	Wed Jul 26 17:03:59 2017 +0000
+++ b/MAX31856.cpp	Wed Jul 26 18:46:23 2017 +0000
@@ -1,4 +1,5 @@
 #include <mbed.h>
+#include <string>
 #include "MAX31856.h"
 
 #define LOG(args...)    printf(args)
@@ -19,20 +20,20 @@
 //    uint32_t time = us_ticker_read();
 //    uint32_t duration = time - lastReadTime;
 //    if (duration > 200000) {   // more than 250ms
-/*        for(int i=0; i<3; i++) {
+        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();
-    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();
+//    spiEnable();
+//    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
@@ -66,15 +67,15 @@
 
 //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;
+        LOG("Register containing\t\t","setConversionMode","\t\twas programmed with the parameter\t\t","CR0_CONV_MODE_NORMALLY_OFF");
     } 
     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;
+        LOG("Register containing\t\t","setConversionMode","\t\twas programmed with the parameter\t\t","CR0_CONV_MODE_NORMALLY_ON");
     }
     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"); 
@@ -85,10 +86,14 @@
 
 //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) 
+    if      (val==CR0_1_SHOT_MODE_NO_CONVERSION) {
         return_val=registerReadWriteByte(ADDRESS_CR0_READ, ADDRESS_CR0_WRITE, CR0_CLEAR_BITS_6, val);
+        LOG("Register containing\t\t","setOneShotMode","\t\twas programmed with the parameter\t\t","CR0_1_SHOT_MODE_NO_CONVERSIONS");
+    }
+    else if (val==CR0_1_SHOT_MODE_ONE_CONVERSION) { 
+        return_val=registerReadWriteByte(ADDRESS_CR0_READ, ADDRESS_CR0_WRITE, CR0_CLEAR_BITS_6, val);
+        LOG("Register containing\t\t","setOneShotMode","\t\twas programmed with the parameter\t\t","CR0_1_SHOT_MODE_NO_CONVERSIONS");
+    }
     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
@@ -98,10 +103,22 @@
 
 //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)  
+    if      (val==CR0_OC_DETECT_DISABLED) { 
+        return_val=registerReadWriteByte(ADDRESS_CR0_READ, ADDRESS_CR0_WRITE, CR0_CLEAR_BITS_5_4, val);
+        LOG("Register containing\t\t","setOpenCircuitFaultDetection","\t\twas programmed with the parameter\t\t","CR0_OC_DETECT_DISABLED");
+    }
+    else if (val==CR0_OC_DETECT_ENABLED_R_LESS_5k) {  
         return_val=registerReadWriteByte(ADDRESS_CR0_READ, ADDRESS_CR0_WRITE, CR0_CLEAR_BITS_5_4, val);
+        LOG("Register containing\t\t","setOpenCircuitFaultDetection","\t\twas programmed with the parameter\t\t","CR0_OC_DETECT_ENABLED_R_LESS_5k");
+    }
+    else if (val==CR0_OC_DETECT_ENABLED_TC_LESS_2ms) {
+        return_val=registerReadWriteByte(ADDRESS_CR0_READ, ADDRESS_CR0_WRITE, CR0_CLEAR_BITS_5_4, val);
+        LOG("Register containing\t\t","setOpenCircuitFaultDetection","\t\twas programmed with the parameter\t\t","CR0_OC_DETECT_ENABLED_TC_LESS_2ms");
+    }
+    else if (val==CR0_OC_DETECT_ENABLED_TC_MORE_2ms) { 
+        return_val=registerReadWriteByte(ADDRESS_CR0_READ, ADDRESS_CR0_WRITE, CR0_CLEAR_BITS_5_4, val);
+        LOG("Register containing\t\t","setOpenCircuitFaultDetection","\t\twas programmed with the parameter\t\t","CR0_OC_DETECT_ENABLED_TC_MORE_2ms");
+    }
     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
@@ -111,15 +128,15 @@
 
 //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;
+        LOG("Register containing\t\t","setColdJunctionDisable","\t\twas programmed with the parameter\t\t","CR0_COLD_JUNC_ENABLE");
     }
     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;
+        LOG("Register containing\t\t","setColdJunctionDisable","\t\twas programmed with the parameter\t\t","CR0_COLD_JUNC_DISABLE");
     }
     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"); 
@@ -130,10 +147,14 @@
 
 //Register:CR0    Bits: 2
 bool MAX31856::setFaultMode(uint8_t val) {
-    bool return_val;
-    //Check if the parameter passed in is valid
-    if (val==CR0_FAULT_MODE_COMPARATOR || val==CR0_FAULT_MODE_INTERUPT) 
+    if      (val==CR0_FAULT_MODE_COMPARATOR) {
         return_val=registerReadWriteByte(ADDRESS_CR0_READ, ADDRESS_CR0_WRITE, CR0_CLEAR_BITS_2, val);
+        LOG("Register containing\t\t","setFaultMode","\t\twas programmed with the parameter\t\t","CR0_FAULT_MODE_COMPARATOR");
+    }
+    else if (val==CR0_FAULT_MODE_INTERUPT) {
+        return_val=registerReadWriteByte(ADDRESS_CR0_READ, ADDRESS_CR0_WRITE, CR0_CLEAR_BITS_2, val);
+        LOG("Register containing\t\t","setFaultMode","\t\twas programmed with the parameter\t\t","CR0_FAULT_MODE_INTERUPT");
+    }
     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
@@ -143,10 +164,14 @@
 
 //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) 
+    if      (val==CR0_FAULTCLR_DEFAULT_VAL) { 
         return_val=registerReadWriteByte(ADDRESS_CR0_READ, ADDRESS_CR0_WRITE, CR0_CLEAR_BITS_1, val);
+        LOG("Register containing\t\t","setFaultStatusClear","\t\twas programmed with the parameter\t\t","CR0_FAULTCLR_DEFAULT_VAL");
+    }
+    else if (val==CR0_FAULTCLR_RETURN_FAULTS_TO_ZERO) { 
+        return_val=registerReadWriteByte(ADDRESS_CR0_READ, ADDRESS_CR0_WRITE, CR0_CLEAR_BITS_1, val);
+        LOG("Register containing\t\t","setFaultStatusClear","\t\twas programmed with the parameter\t\t","CR0_FAULTCLR_RETURN_FAULTS_TO_ZERO");
+    }
     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
@@ -156,15 +181,15 @@
 
 //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;
+        LOG("Register containing\t\t","setEmiFilterFreq","\t\twas programmed with the parameter\t\t","CR0_FILTER_OUT_60Hz");
     }
     else if (val==CR0_FILTER_OUT_50Hz) {
         return_val=registerReadWriteByte(ADDRESS_CR0_READ, ADDRESS_CR0_WRITE, CR0_CLEAR_BITS_0, val);
         filter_mode=1;
+        LOG("Register containing\t\t","setEmiFilterFreq","\t\twas programmed with the parameter\t\t","CR0_FILTER_OUT_50Hz");
     }
     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"); 
@@ -175,28 +200,30 @@
 
 //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;
+        LOG("Register containing\t\t","setNumSamplesAvg","\t\twas programmed with the parameter\t\t","CR1_AVG_TC_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;
+        LOG("Register containing\t\t","setNumSamplesAvg","\t\twas programmed with the parameter\t\t","CR1_AVG_TC_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;
+        LOG("Register containing\t\t","setNumSamplesAvg","\t\twas programmed with the parameter\t\t","CR1_AVG_TC_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;
+        LOG("Register containing\t\t","setNumSamplesAvg","\t\twas programmed with the parameter\t\t","CR1_AVG_TC_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;
+        LOG("Register containing\t\t","setNumSamplesAvg","\t\twas programmed with the parameter\t\t","CR1_AVG_TC_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"); 
@@ -207,15 +234,55 @@
 
 //Register:CR1    Bits: 3:0
 bool MAX31856::setThermocoupleType(uint8_t val) {   
-    bool return_val;
-    //Check if the parameter passed in is valid
-    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) {
+    if      (val==CR1_TC_TYPE_B) {
+        return_val=registerReadWriteByte(ADDRESS_CR1_READ, ADDRESS_CR1_WRITE, CR1_CLEAR_BITS_3_0, val);
+        voltage_mode=false;
+        LOG("Register containing\t\t","setThermocoupleType","\t\twas programmed with the parameter\t\t","CR1_TC_TYPE_B");
+    }
+    else if (val==CR1_TC_TYPE_E) {
+        return_val=registerReadWriteByte(ADDRESS_CR1_READ, ADDRESS_CR1_WRITE, CR1_CLEAR_BITS_3_0, val);
+        voltage_mode=false;
+        LOG("Register containing\t\t","setThermocoupleType","\t\twas programmed with the parameter\t\t","CR1_TC_TYPE_E");
+    }
+    else if (val==CR1_TC_TYPE_J) {
+        return_val=registerReadWriteByte(ADDRESS_CR1_READ, ADDRESS_CR1_WRITE, CR1_CLEAR_BITS_3_0, val);
+        voltage_mode=false;
+        LOG("Register containing\t\t","setThermocoupleType","\t\twas programmed with the parameter\t\t","CR1_TC_TYPE_J");
+    }
+    else if (val==CR1_TC_TYPE_K) {
+        return_val=registerReadWriteByte(ADDRESS_CR1_READ, ADDRESS_CR1_WRITE, CR1_CLEAR_BITS_3_0, val);
+        voltage_mode=false;
+        LOG("Register containing\t\t","setThermocoupleType","\t\twas programmed with the parameter\t\t","CR1_TC_TYPE_K");
+    }
+    else if (val==CR1_TC_TYPE_N) {
         return_val=registerReadWriteByte(ADDRESS_CR1_READ, ADDRESS_CR1_WRITE, CR1_CLEAR_BITS_3_0, val);
         voltage_mode=false;
+        LOG("Register containing\t\t","setThermocoupleType","\t\twas programmed with the parameter\t\t","CR1_TC_TYPE_N");
     }
-    else if (val==CR1_TC_TYPE_VOLT_MODE_GAIN_8 || val==CR1_TC_TYPE_VOLT_MODE_GAIN_32) {
+    else if (val==CR1_TC_TYPE_R) {
+        return_val=registerReadWriteByte(ADDRESS_CR1_READ, ADDRESS_CR1_WRITE, CR1_CLEAR_BITS_3_0, val);
+        voltage_mode=false;
+        LOG("Register containing\t\t","setThermocoupleType","\t\twas programmed with the parameter\t\t","CR1_TC_TYPE_R");
+    }
+    else if (val==CR1_TC_TYPE_S) {
+        return_val=registerReadWriteByte(ADDRESS_CR1_READ, ADDRESS_CR1_WRITE, CR1_CLEAR_BITS_3_0, val);
+        voltage_mode=false;
+        LOG("Register containing\t\t","setThermocoupleType","\t\twas programmed with the parameter\t\t","CR1_TC_TYPE_S");
+    }
+    else if (val==CR1_TC_TYPE_T) {
+        return_val=registerReadWriteByte(ADDRESS_CR1_READ, ADDRESS_CR1_WRITE, CR1_CLEAR_BITS_3_0, val);
+        voltage_mode=false;
+        LOG("Register containing\t\t","setThermocoupleType","\t\twas programmed with the parameter\t\t","CR1_TC_TYPE_T");
+    }
+    else if (val==CR1_TC_TYPE_VOLT_MODE_GAIN_8) {
         return_val=registerReadWriteByte(ADDRESS_CR1_READ, ADDRESS_CR1_WRITE, CR1_CLEAR_BITS_3_0, val);
         voltage_mode=true;
+        LOG("Register containing\t\t","setThermocoupleType","\t\twas programmed with the parameter\t\t","CR1_TC_TYPE_VOLT_MODE_GAIN_8");
+    }
+    else if (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;
+        LOG("Register containing\t\t","setThermocoupleType","\t\twas programmed with the parameter\t\t","CR1_TC_TYPE_VOLT_MODE_GAIN_32");
     }
     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"); 
@@ -226,24 +293,35 @@
 
 //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
+    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
+        LOG("Register containing\t\t","setFaultMasks","\t\twas programmed with the parameter\t\t","MASK_CJ_FAULT_THRESHOLD_HIGH");
+    }
+    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
+        LOG("Register containing\t\t","setFaultMasks","\t\twas programmed with the parameter\t\t","MASK_CJ_FAULT_THRESHOLD_LOW");
+    }
+    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
+        LOG("Register containing\t\t","setFaultMasks","\t\twas programmed with the parameter\t\t","MASK_TC_FAULT_THRESHOLD_HIGH");
+    }
+    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
+        LOG("Register containing\t\t","setFaultMasks","\t\twas programmed with the parameter\t\t","MASK_TC_FAULT_THRESHOLD_LOW");
+    }
+    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
+        LOG("Register containing\t\t","setFaultMasks","\t\twas programmed with the parameter\t\t","MASK_OVER_UNDER_VOLT_FAULT");
+    }
+    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);
+        LOG("Register containing\t\t","setFaultMasks","\t\twas programmed with the parameter\t\t","MASK_OPEN_CIRCUIT_FAULT");
+    }
     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
@@ -253,7 +331,7 @@
 
 //Register:MASK    Bits: 5:0
 float MAX31856::setFaultThresholds(uint8_t val, bool enable_mask, float temperature) {
-    float return_val;
+    float return_val;///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////ghjkcghjcfczseraweraenaet aert e
     uint8_t temp_val;
     if(enable_mask) {
         temp_val=0;
@@ -388,6 +466,10 @@
     return temp;
 }
 
+//void MAX31856::printSetting(string register_bits, string register_info) {
+//    printf("Register containing\t\t",register_bits, "\t\twas programmed with the parameter\t\t",register_info);
+//}
+
 //bool MAX31856::checkForFaults() {
 //    
 //}