Maxim Integrated / Mbed 2 deprecated MAX31856_example_program

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

Dependencies:   MAX31856 mbed

Fork of MAX31856_example_program by Central Applications - Mbed Code repo

MAX31856.cpp@8:8723d0006097, 2017-08-01 (annotated)

Committer:
DevinAlexander
Date:
Tue Aug 01 03:29:15 2017 +0000
Revision:
8:8723d0006097
Parent:
7:2e45068189b1
Child:
9:2d284cc2f65c
One function left to finalize which is setting thresholds;

Who changed what in which revision?

UserRevisionLine numberNew contents of line
DevinAlexander 0:456e9e702d57 1 #include <mbed.h>
DevinAlexander 0:456e9e702d57 2 #include "MAX31856.h"
DevinAlexander 0:456e9e702d57 3
DevinAlexander 0:456e9e702d57 4 #define LOG(args...) printf(args)
DevinAlexander 0:456e9e702d57 5
DevinAlexander 8:8723d0006097 6 //*****************************************************************************
DevinAlexander 7:2e45068189b1 7 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) {
DevinAlexander 7:2e45068189b1 8 spi.format(8,3); //configure the correct SPI mode to beable to program the registers intially correctly
DevinAlexander 0:456e9e702d57 9 setThermocoupleType(_type);
DevinAlexander 0:456e9e702d57 10 setEmiFilterFreq(_fltr);
DevinAlexander 1:b58719a76fc3 11 setNumSamplesAvg(_samples);
DevinAlexander 1:b58719a76fc3 12 setConversionMode(_conversion_mode);
DevinAlexander 0:456e9e702d57 13 }
DevinAlexander 0:456e9e702d57 14
DevinAlexander 7:2e45068189b1 15
DevinAlexander 7:2e45068189b1 16 //*****************************************************************************
DevinAlexander 0:456e9e702d57 17 float MAX31856::readTC()
DevinAlexander 8:8723d0006097 18 {
DevinAlexander 8:8723d0006097 19 //Check and see if the MAX31856 is set to conversion mode ALWAYS ON
DevinAlexander 8:8723d0006097 20 if (conversion_mode==0) { //means that the conversion mode is normally off
DevinAlexander 8:8723d0006097 21 setOneShotMode(CR0_1_SHOT_MODE_ONE_CONVERSION); // turn on the one shot mode for singular conversion
DevinAlexander 8:8723d0006097 22 thermocouple_conversion_count=0; //reset the conversion count back to zero to make sure minimum conversion time reflects one shot mode requirements
DevinAlexander 8:8723d0006097 23 }
DevinAlexander 8:8723d0006097 24
DevinAlexander 8:8723d0006097 25 //calculate minimum wait time for conversions
DevinAlexander 8:8723d0006097 26 calculateDelayTime();
DevinAlexander 8:8723d0006097 27
DevinAlexander 8:8723d0006097 28 //initialize other info for the read functionality
DevinAlexander 0:456e9e702d57 29 int32_t temp;
DevinAlexander 1:b58719a76fc3 30 uint8_t buf_read[3], buf_write[3]={ADDRESS_LTCBH_READ,ADDRESS_LTCBM_READ,ADDRESS_LTCBL_READ};
DevinAlexander 1:b58719a76fc3 31
DevinAlexander 8:8723d0006097 32 bool read_thermocouple_temp=checkFaultsThermocoupleConnection(); //check and see if there are any faults that prohibit a normal read of the register
DevinAlexander 8:8723d0006097 33
DevinAlexander 8:8723d0006097 34 if(read_thermocouple_temp){ //no faults with connection are present so continue on with normal read of temperature
DevinAlexander 8:8723d0006097 35 uint32_t time = us_ticker_read();
DevinAlexander 8:8723d0006097 36 uint32_t duration = time - lastReadTime;
DevinAlexander 8:8723d0006097 37 if (duration > conversion_time) { // more than current conversion time
DevinAlexander 8:8723d0006097 38 for(int i=0; i<3; i++) {
DevinAlexander 8:8723d0006097 39 spiEnable();
DevinAlexander 8:8723d0006097 40 buf_read[i]=spi.write(buf_write[i]);
DevinAlexander 8:8723d0006097 41 buf_read[i]=spi.write(buf_write[i]);
DevinAlexander 8:8723d0006097 42 spiDisable();
DevinAlexander 8:8723d0006097 43 }
DevinAlexander 8:8723d0006097 44
DevinAlexander 8:8723d0006097 45 //Convert the registers contents into the correct value
DevinAlexander 8:8723d0006097 46 temp =((buf_read[0] & 0xFF) << 11); //Shift Byte 2 into place
DevinAlexander 8:8723d0006097 47 temp|=((buf_read[1] & 0xFF) << 3); //Shift Byte 1 into place
DevinAlexander 8:8723d0006097 48 temp|=((buf_read[2] & 0xFF) >> 5); //Shift Byte 0 into place
DevinAlexander 8:8723d0006097 49 float val=(temp/128.0f); //Divide the binary string by 2 to the 7th power
DevinAlexander 8:8723d0006097 50 return val;
DevinAlexander 8:8723d0006097 51 }
DevinAlexander 8:8723d0006097 52 }
DevinAlexander 8:8723d0006097 53 checkFaultsThermocoupleThresholds(); //print any faults to the terminal
DevinAlexander 8:8723d0006097 54
DevinAlexander 8:8723d0006097 55 thermocouple_conversion_count++; //iterate the conversion count to speed up time in between future converions in always on mode
DevinAlexander 0:456e9e702d57 56 }
DevinAlexander 0:456e9e702d57 57
DevinAlexander 7:2e45068189b1 58
DevinAlexander 7:2e45068189b1 59 //*****************************************************************************
DevinAlexander 0:456e9e702d57 60 float MAX31856::readCJ()
DevinAlexander 0:456e9e702d57 61 {
DevinAlexander 0:456e9e702d57 62 int32_t temp;
DevinAlexander 1:b58719a76fc3 63 uint8_t buf_read[3], buf_write=ADDRESS_CJTH_READ;
DevinAlexander 0:456e9e702d57 64
DevinAlexander 0:456e9e702d57 65 spiEnable();
DevinAlexander 0:456e9e702d57 66 for(int i=0; i<3; i++)
DevinAlexander 0:456e9e702d57 67 {
DevinAlexander 0:456e9e702d57 68 buf_read[i]=spi.write(buf_write);
DevinAlexander 0:456e9e702d57 69 }
DevinAlexander 0:456e9e702d57 70 spiDisable();
DevinAlexander 0:456e9e702d57 71
DevinAlexander 0:456e9e702d57 72 //Convert the registers contents into the correct value
DevinAlexander 0:456e9e702d57 73 temp =((int32_t)(buf_read[1] << 6)); //Shift the MSB into place
DevinAlexander 0:456e9e702d57 74 temp|=((int32_t)(buf_read[2] >> 2)); //Shift the LSB into place
DevinAlexander 0:456e9e702d57 75 float val=((float)(temp/64.0)); //Divide the binary string by 2 to the 6th power
DevinAlexander 0:456e9e702d57 76
DevinAlexander 8:8723d0006097 77 checkFaultsColdJunctionThresholds(); //print any faults to the terminal
DevinAlexander 8:8723d0006097 78
DevinAlexander 0:456e9e702d57 79 return val;
DevinAlexander 0:456e9e702d57 80 }
DevinAlexander 0:456e9e702d57 81
DevinAlexander 8:8723d0006097 82 //*****************************************************************************
DevinAlexander 8:8723d0006097 83 uint8_t MAX31856::checkFaultsThermocoupleThresholds()
DevinAlexander 8:8723d0006097 84 {
DevinAlexander 8:8723d0006097 85 uint8_t fault_byte=registerReadByte(ADDRESS_SR_READ); //Read contents of fault status register
DevinAlexander 8:8723d0006097 86 uint8_t temp[2], return_int;
DevinAlexander 8:8723d0006097 87 for(int i=0; i<2; i++)
DevinAlexander 8:8723d0006097 88 temp[i]=fault_byte;
DevinAlexander 8:8723d0006097 89
DevinAlexander 8:8723d0006097 90 //Check if any of the faults for thermocouple connection are triggered
DevinAlexander 8:8723d0006097 91 if ((fault_byte&0x4C)==0) //means no fault is detected for thermocouple thresholds
DevinAlexander 8:8723d0006097 92 return_int=0;
DevinAlexander 8:8723d0006097 93 else {
DevinAlexander 8:8723d0006097 94 if ((fault_byte&0x40)==0) { //check if normal operation of thermocouple is true
DevinAlexander 8:8723d0006097 95 if (temp[0]&0x08) {
DevinAlexander 8:8723d0006097 96 LOG("FAULT! Thermocouple temp is higher than the threshold that is set!\r\n");
DevinAlexander 8:8723d0006097 97 return_int=1;
DevinAlexander 8:8723d0006097 98 }
DevinAlexander 8:8723d0006097 99 else if (temp[1]&0x04) {
DevinAlexander 8:8723d0006097 100 LOG("FAULT! Thermocouple temp is lower than the threshold that is set!\r\n");
DevinAlexander 8:8723d0006097 101 return_int=2;
DevinAlexander 8:8723d0006097 102 }
DevinAlexander 8:8723d0006097 103 }
DevinAlexander 8:8723d0006097 104 else { //Thermocouples is operating outside of normal range
DevinAlexander 8:8723d0006097 105 LOG("FAULT! Thermocouple temperature is out of range for specific type of thermocouple!\r\n");
DevinAlexander 8:8723d0006097 106 if (temp[0]&0x08) {
DevinAlexander 8:8723d0006097 107 LOG("FAULT! Thermocouple temp is higher than the threshold that is set!\r\n");
DevinAlexander 8:8723d0006097 108 return_int=4;
DevinAlexander 8:8723d0006097 109 }
DevinAlexander 8:8723d0006097 110 else if (temp[1]&0x04) {
DevinAlexander 8:8723d0006097 111 LOG("FAULT! Thermocouple temp is lower than the threshold that is set!\r\n");
DevinAlexander 8:8723d0006097 112 return_int=5;
DevinAlexander 8:8723d0006097 113 }
DevinAlexander 8:8723d0006097 114 else //no other faults are flagged besides unnatural operation
DevinAlexander 8:8723d0006097 115 return_int=3;
DevinAlexander 8:8723d0006097 116 }
DevinAlexander 8:8723d0006097 117 }
DevinAlexander 8:8723d0006097 118 return return_int;
DevinAlexander 8:8723d0006097 119 }
DevinAlexander 8:8723d0006097 120
DevinAlexander 8:8723d0006097 121 //*****************************************************************************
DevinAlexander 8:8723d0006097 122 uint8_t MAX31856::checkFaultsColdJunctionThresholds()
DevinAlexander 8:8723d0006097 123 {
DevinAlexander 8:8723d0006097 124 uint8_t fault_byte=registerReadByte(ADDRESS_SR_READ); //Read contents of fault status register
DevinAlexander 8:8723d0006097 125 uint8_t temp[2], return_int;
DevinAlexander 8:8723d0006097 126 for(int i=0; i<2; i++)
DevinAlexander 8:8723d0006097 127 temp[i]=fault_byte;
DevinAlexander 8:8723d0006097 128
DevinAlexander 8:8723d0006097 129 //Check if any of the faults for thermocouple connection are triggered
DevinAlexander 8:8723d0006097 130 if ((fault_byte&0xB0)==0) //means no fault is detected for cold junction thresholds
DevinAlexander 8:8723d0006097 131 return_int=0;
DevinAlexander 8:8723d0006097 132 else {
DevinAlexander 8:8723d0006097 133 if ((fault_byte&0x80)==0) { //check if normal operation of cold junction is true
DevinAlexander 8:8723d0006097 134 if (temp[0]&0x20) {
DevinAlexander 8:8723d0006097 135 LOG("FAULT! Cold Junction temp is higher than the threshold that is set!\r\n");
DevinAlexander 8:8723d0006097 136 return_int=1;
DevinAlexander 8:8723d0006097 137 }
DevinAlexander 8:8723d0006097 138 else if (temp[1]&0x10) {
DevinAlexander 8:8723d0006097 139 LOG("FAULT! Cold Junction temp is lower than the threshold that is set!\r\n");
DevinAlexander 8:8723d0006097 140 return_int=2;
DevinAlexander 8:8723d0006097 141 }
DevinAlexander 8:8723d0006097 142 }
DevinAlexander 8:8723d0006097 143 else { //Cold Junction is operating outside of normal range
DevinAlexander 8:8723d0006097 144 LOG("FAULT! Cold Junction temperature is out of range for specific type of thermocouple!\r\n");
DevinAlexander 8:8723d0006097 145 if (temp[0]&0x20) {
DevinAlexander 8:8723d0006097 146 LOG("FAULT! Cold Junction temp is higher than the threshold that is set!\r\n");
DevinAlexander 8:8723d0006097 147 return_int=4;
DevinAlexander 8:8723d0006097 148 }
DevinAlexander 8:8723d0006097 149 else if (temp[1]&0x10) {
DevinAlexander 8:8723d0006097 150 LOG("FAULT! Cold Junction temp is lower than the threshold that is set!\r\n");
DevinAlexander 8:8723d0006097 151 return_int=5;
DevinAlexander 8:8723d0006097 152 }
DevinAlexander 8:8723d0006097 153 else //no other faults are flagged besides unnatural operation
DevinAlexander 8:8723d0006097 154 return_int=3;
DevinAlexander 8:8723d0006097 155 }
DevinAlexander 8:8723d0006097 156 }
DevinAlexander 8:8723d0006097 157 return return_int;
DevinAlexander 8:8723d0006097 158 }
DevinAlexander 8:8723d0006097 159
DevinAlexander 8:8723d0006097 160 //*****************************************************************************
DevinAlexander 8:8723d0006097 161 bool MAX31856::checkFaultsThermocoupleConnection()
DevinAlexander 8:8723d0006097 162 {
DevinAlexander 8:8723d0006097 163 uint8_t fault_byte=registerReadByte(ADDRESS_SR_READ); //Read contents of fault status register
DevinAlexander 8:8723d0006097 164 uint8_t temp[2];
DevinAlexander 8:8723d0006097 165 for(int i=0; i<2; i++)
DevinAlexander 8:8723d0006097 166 temp[i]=fault_byte;
DevinAlexander 8:8723d0006097 167
DevinAlexander 8:8723d0006097 168 //Check if any of the faults for thermocouple connection are triggered
DevinAlexander 8:8723d0006097 169 if (fault_byte==0) //means no fault is detected
DevinAlexander 8:8723d0006097 170 return_val=1;
DevinAlexander 8:8723d0006097 171 else{
DevinAlexander 8:8723d0006097 172 if (temp[0]&0x02) {
DevinAlexander 8:8723d0006097 173 LOG("Overvotage/Undervoltage Fault triggered! Input voltage is negative or the voltage is greater than Vdd! Please check thermocouple connection!\r\n");
DevinAlexander 8:8723d0006097 174 return_val=0;
DevinAlexander 8:8723d0006097 175 }
DevinAlexander 8:8723d0006097 176 if (temp[1]&0x01) {
DevinAlexander 8:8723d0006097 177 LOG("Open circuit fault detected! Please check thermocouple connection!\r\n");
DevinAlexander 8:8723d0006097 178 return_val=0;
DevinAlexander 8:8723d0006097 179 }
DevinAlexander 8:8723d0006097 180 }
DevinAlexander 8:8723d0006097 181 return return_val;
DevinAlexander 8:8723d0006097 182 }
DevinAlexander 8:8723d0006097 183
DevinAlexander 7:2e45068189b1 184
DevinAlexander 1:b58719a76fc3 185 //Register:CR0 Bits: 7
DevinAlexander 7:2e45068189b1 186 //*****************************************************************************
DevinAlexander 7:2e45068189b1 187 bool MAX31856::setConversionMode(uint8_t val)
DevinAlexander 7:2e45068189b1 188 {
DevinAlexander 1:b58719a76fc3 189 if (val==CR0_CONV_MODE_NORMALLY_OFF) {
DevinAlexander 1:b58719a76fc3 190 return_val=registerReadWriteByte(ADDRESS_CR0_READ, ADDRESS_CR0_WRITE, CR0_CLEAR_BITS_7, val);
DevinAlexander 1:b58719a76fc3 191 conversion_mode=0;
DevinAlexander 3:a99a4367c909 192 LOG("Register containing\t\tsetConversionMode\t\twas programmed with the parameter\t\tCR0_CONV_MODE_NORMALLY_OFF\r\n");
DevinAlexander 1:b58719a76fc3 193 }
DevinAlexander 1:b58719a76fc3 194 else if (val==CR0_CONV_MODE_NORMALLY_ON) {
DevinAlexander 1:b58719a76fc3 195 return_val=registerReadWriteByte(ADDRESS_CR0_READ, ADDRESS_CR0_WRITE, CR0_CLEAR_BITS_7, val);
DevinAlexander 1:b58719a76fc3 196 conversion_mode=1;
DevinAlexander 3:a99a4367c909 197 LOG("Register containing\t\tsetConversionMode\t\twas programmed with the parameter\t\tCR0_CONV_MODE_NORMALLY_ON\r\n");
DevinAlexander 1:b58719a76fc3 198 }
DevinAlexander 1:b58719a76fc3 199 else {
DevinAlexander 1:b58719a76fc3 200 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");
DevinAlexander 1:b58719a76fc3 201 return_val=0; //returns a 0 to flag that the parameter wasn't programmed due to wrong parameter in function call
DevinAlexander 1:b58719a76fc3 202 }
DevinAlexander 1:b58719a76fc3 203 return return_val;
DevinAlexander 1:b58719a76fc3 204 }
DevinAlexander 1:b58719a76fc3 205
DevinAlexander 7:2e45068189b1 206
DevinAlexander 1:b58719a76fc3 207 //Register:CR0 Bits: 6
DevinAlexander 7:2e45068189b1 208 //*****************************************************************************
DevinAlexander 7:2e45068189b1 209 bool MAX31856::setOneShotMode(uint8_t val)
DevinAlexander 7:2e45068189b1 210 {
DevinAlexander 2:296485923589 211 if (val==CR0_1_SHOT_MODE_NO_CONVERSION) {
DevinAlexander 1:b58719a76fc3 212 return_val=registerReadWriteByte(ADDRESS_CR0_READ, ADDRESS_CR0_WRITE, CR0_CLEAR_BITS_6, val);
DevinAlexander 3:a99a4367c909 213 LOG("Register containing\t\tsetOneShotMode\t\twas programmed with the parameter\t\tCR0_1_SHOT_MODE_NO_CONVERSIONS\r\n");
DevinAlexander 2:296485923589 214 }
DevinAlexander 2:296485923589 215 else if (val==CR0_1_SHOT_MODE_ONE_CONVERSION) {
DevinAlexander 2:296485923589 216 return_val=registerReadWriteByte(ADDRESS_CR0_READ, ADDRESS_CR0_WRITE, CR0_CLEAR_BITS_6, val);
DevinAlexander 3:a99a4367c909 217 LOG("Register containing\t\tsetOneShotMode\t\twas programmed with the parameter\t\tCR0_1_SHOT_MODE_NO_CONVERSIONS\r\n");
DevinAlexander 2:296485923589 218 }
DevinAlexander 1:b58719a76fc3 219 else {
DevinAlexander 1:b58719a76fc3 220 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");
DevinAlexander 1:b58719a76fc3 221 return_val=0; //returns a 0 to flag that the parameter wasn't programmed due to wrong parameter in function call
DevinAlexander 1:b58719a76fc3 222 }
DevinAlexander 1:b58719a76fc3 223 return return_val;
DevinAlexander 1:b58719a76fc3 224 }
DevinAlexander 1:b58719a76fc3 225
DevinAlexander 7:2e45068189b1 226
DevinAlexander 1:b58719a76fc3 227 //Register:CR0 Bits: 5:4
DevinAlexander 7:2e45068189b1 228 //*****************************************************************************
DevinAlexander 7:2e45068189b1 229 bool MAX31856::setOpenCircuitFaultDetection(uint8_t val)
DevinAlexander 7:2e45068189b1 230 {
DevinAlexander 2:296485923589 231 if (val==CR0_OC_DETECT_DISABLED) {
DevinAlexander 2:296485923589 232 return_val=registerReadWriteByte(ADDRESS_CR0_READ, ADDRESS_CR0_WRITE, CR0_CLEAR_BITS_5_4, val);
DevinAlexander 3:a99a4367c909 233 LOG("Register containing\t\tsetOpenCircuitFaultDetection\t\twas programmed with the parameter\t\tCR0_OC_DETECT_DISABLED\r\n");
DevinAlexander 2:296485923589 234 }
DevinAlexander 2:296485923589 235 else if (val==CR0_OC_DETECT_ENABLED_R_LESS_5k) {
DevinAlexander 1:b58719a76fc3 236 return_val=registerReadWriteByte(ADDRESS_CR0_READ, ADDRESS_CR0_WRITE, CR0_CLEAR_BITS_5_4, val);
DevinAlexander 3:a99a4367c909 237 LOG("Register containing\t\tsetOpenCircuitFaultDetection\t\twas programmed with the parameter\t\tCR0_OC_DETECT_ENABLED_R_LESS_5k\r\n");
DevinAlexander 2:296485923589 238 }
DevinAlexander 2:296485923589 239 else if (val==CR0_OC_DETECT_ENABLED_TC_LESS_2ms) {
DevinAlexander 2:296485923589 240 return_val=registerReadWriteByte(ADDRESS_CR0_READ, ADDRESS_CR0_WRITE, CR0_CLEAR_BITS_5_4, val);
DevinAlexander 3:a99a4367c909 241 LOG("Register containing\t\tsetOpenCircuitFaultDetection\t\twas programmed with the parameter\t\tCR0_OC_DETECT_ENABLED_TC_LESS_2ms\r\n");
DevinAlexander 2:296485923589 242 }
DevinAlexander 2:296485923589 243 else if (val==CR0_OC_DETECT_ENABLED_TC_MORE_2ms) {
DevinAlexander 2:296485923589 244 return_val=registerReadWriteByte(ADDRESS_CR0_READ, ADDRESS_CR0_WRITE, CR0_CLEAR_BITS_5_4, val);
DevinAlexander 3:a99a4367c909 245 LOG("Register containing\t\tsetOpenCircuitFaultDetection\t\twas programmed with the parameter\t\tCR0_OC_DETECT_ENABLED_TC_MORE_2ms\r\n");
DevinAlexander 2:296485923589 246 }
DevinAlexander 1:b58719a76fc3 247 else {
DevinAlexander 1:b58719a76fc3 248 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");
DevinAlexander 1:b58719a76fc3 249 return_val=0; //returns a 0 to flag that the parameter wasn't programmed due to wrong parameter in function call
DevinAlexander 1:b58719a76fc3 250 }
DevinAlexander 1:b58719a76fc3 251 return return_val;
DevinAlexander 1:b58719a76fc3 252 }
DevinAlexander 1:b58719a76fc3 253
DevinAlexander 7:2e45068189b1 254
DevinAlexander 1:b58719a76fc3 255 //Register:CR0 Bits: 3
DevinAlexander 7:2e45068189b1 256 //*****************************************************************************
DevinAlexander 7:2e45068189b1 257 bool MAX31856::setColdJunctionDisable(uint8_t val)
DevinAlexander 7:2e45068189b1 258 {
DevinAlexander 1:b58719a76fc3 259 if (val==CR0_COLD_JUNC_ENABLE) {
DevinAlexander 1:b58719a76fc3 260 return_val=registerReadWriteByte(ADDRESS_CR0_READ, ADDRESS_CR0_WRITE, CR0_CLEAR_BITS_3, val);
DevinAlexander 1:b58719a76fc3 261 cold_junction_enabled=1;
DevinAlexander 3:a99a4367c909 262 LOG("Register containing\t\tsetColdJunctionDisable\t\twas programmed with the parameter\t\tCR0_COLD_JUNC_ENABLE\r\n");
DevinAlexander 1:b58719a76fc3 263 }
DevinAlexander 1:b58719a76fc3 264 else if (val==CR0_COLD_JUNC_DISABLE) {
DevinAlexander 1:b58719a76fc3 265 return_val=registerReadWriteByte(ADDRESS_CR0_READ, ADDRESS_CR0_WRITE, CR0_CLEAR_BITS_3, val);
DevinAlexander 1:b58719a76fc3 266 cold_junction_enabled=0;
DevinAlexander 3:a99a4367c909 267 LOG("Register containing\t\tsetColdJunctionDisable\t\twas programmed with the parameter\t\tCR0_COLD_JUNC_DISABLE\r\n");
DevinAlexander 1:b58719a76fc3 268 }
DevinAlexander 1:b58719a76fc3 269 else {
DevinAlexander 1:b58719a76fc3 270 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");
DevinAlexander 1:b58719a76fc3 271 return_val=0; //returns a 0 to flag that the parameter wasn't programmed due to wrong parameter in function call
DevinAlexander 1:b58719a76fc3 272 }
DevinAlexander 1:b58719a76fc3 273 return return_val;
DevinAlexander 1:b58719a76fc3 274 }
DevinAlexander 1:b58719a76fc3 275
DevinAlexander 7:2e45068189b1 276
DevinAlexander 1:b58719a76fc3 277 //Register:CR0 Bits: 2
DevinAlexander 7:2e45068189b1 278 //*****************************************************************************
DevinAlexander 7:2e45068189b1 279 bool MAX31856::setFaultMode(uint8_t val)
DevinAlexander 7:2e45068189b1 280 {
DevinAlexander 2:296485923589 281 if (val==CR0_FAULT_MODE_COMPARATOR) {
DevinAlexander 1:b58719a76fc3 282 return_val=registerReadWriteByte(ADDRESS_CR0_READ, ADDRESS_CR0_WRITE, CR0_CLEAR_BITS_2, val);
DevinAlexander 3:a99a4367c909 283 LOG("Register containing\t\tsetFaultMode\t\twas programmed with the parameter\t\tCR0_FAULT_MODE_COMPARATOR\r\n");
DevinAlexander 2:296485923589 284 }
DevinAlexander 2:296485923589 285 else if (val==CR0_FAULT_MODE_INTERUPT) {
DevinAlexander 2:296485923589 286 return_val=registerReadWriteByte(ADDRESS_CR0_READ, ADDRESS_CR0_WRITE, CR0_CLEAR_BITS_2, val);
DevinAlexander 3:a99a4367c909 287 LOG("Register containing\t\tsetFaultMode\t\twas programmed with the parameter\t\tCR0_FAULT_MODE_INTERUPT\r\n");
DevinAlexander 2:296485923589 288 }
DevinAlexander 1:b58719a76fc3 289 else {
DevinAlexander 1:b58719a76fc3 290 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");
DevinAlexander 1:b58719a76fc3 291 return_val=0; //returns a 0 to flag that the parameter wasn't programmed due to wrong parameter in function call
DevinAlexander 1:b58719a76fc3 292 }
DevinAlexander 1:b58719a76fc3 293 return return_val;
DevinAlexander 1:b58719a76fc3 294 }
DevinAlexander 1:b58719a76fc3 295
DevinAlexander 7:2e45068189b1 296
DevinAlexander 1:b58719a76fc3 297 //Register:CR0 Bits: 1
DevinAlexander 7:2e45068189b1 298 //*****************************************************************************
DevinAlexander 7:2e45068189b1 299 bool MAX31856::setFaultStatusClear(uint8_t val)
DevinAlexander 7:2e45068189b1 300 {
DevinAlexander 2:296485923589 301 if (val==CR0_FAULTCLR_DEFAULT_VAL) {
DevinAlexander 1:b58719a76fc3 302 return_val=registerReadWriteByte(ADDRESS_CR0_READ, ADDRESS_CR0_WRITE, CR0_CLEAR_BITS_1, val);
DevinAlexander 3:a99a4367c909 303 LOG("Register containing\t\tsetFaultStatusClear\t\twas programmed with the parameter\t\tCR0_FAULTCLR_DEFAULT_VAL\r\n");
DevinAlexander 2:296485923589 304 }
DevinAlexander 2:296485923589 305 else if (val==CR0_FAULTCLR_RETURN_FAULTS_TO_ZERO) {
DevinAlexander 2:296485923589 306 return_val=registerReadWriteByte(ADDRESS_CR0_READ, ADDRESS_CR0_WRITE, CR0_CLEAR_BITS_1, val);
DevinAlexander 3:a99a4367c909 307 LOG("Register containing\t\tsetFaultStatusClear\t\twas programmed with the parameter\t\tCR0_FAULTCLR_RETURN_FAULTS_TO_ZERO\r\n");
DevinAlexander 2:296485923589 308 }
DevinAlexander 1:b58719a76fc3 309 else {
DevinAlexander 1:b58719a76fc3 310 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");
DevinAlexander 1:b58719a76fc3 311 return_val=0; //returns a 0 to flag that the parameter wasn't programmed due to wrong parameter in function call
DevinAlexander 1:b58719a76fc3 312 }
DevinAlexander 1:b58719a76fc3 313 return return_val;
DevinAlexander 1:b58719a76fc3 314 }
DevinAlexander 1:b58719a76fc3 315
DevinAlexander 7:2e45068189b1 316
DevinAlexander 1:b58719a76fc3 317 //Register:CR0 Bits: 0
DevinAlexander 7:2e45068189b1 318 //*****************************************************************************
DevinAlexander 7:2e45068189b1 319 bool MAX31856::setEmiFilterFreq(uint8_t val)
DevinAlexander 7:2e45068189b1 320 {
DevinAlexander 1:b58719a76fc3 321 if (val==CR0_FILTER_OUT_60Hz) {
DevinAlexander 1:b58719a76fc3 322 return_val=registerReadWriteByte(ADDRESS_CR0_READ, ADDRESS_CR0_WRITE, CR0_CLEAR_BITS_0, val);
DevinAlexander 1:b58719a76fc3 323 filter_mode=0;
DevinAlexander 3:a99a4367c909 324 LOG("Register containing\t\tsetEmiFilterFreq\t\twas programmed with the parameter\t\tCR0_FILTER_OUT_60Hz\r\n");
DevinAlexander 1:b58719a76fc3 325 }
DevinAlexander 1:b58719a76fc3 326 else if (val==CR0_FILTER_OUT_50Hz) {
DevinAlexander 1:b58719a76fc3 327 return_val=registerReadWriteByte(ADDRESS_CR0_READ, ADDRESS_CR0_WRITE, CR0_CLEAR_BITS_0, val);
DevinAlexander 1:b58719a76fc3 328 filter_mode=1;
DevinAlexander 3:a99a4367c909 329 LOG("Register containing\t\tsetEmiFilterFreq\t\twas programmed with the parameter\t\tCR0_FILTER_OUT_50Hz\r\n");
DevinAlexander 0:456e9e702d57 330 }
DevinAlexander 1:b58719a76fc3 331 else {
DevinAlexander 1:b58719a76fc3 332 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");
DevinAlexander 1:b58719a76fc3 333 return_val=0; //returns a 0 to flag that the parameter wasn't programmed due to wrong parameter in function call
DevinAlexander 1:b58719a76fc3 334 }
DevinAlexander 1:b58719a76fc3 335 return return_val;
DevinAlexander 1:b58719a76fc3 336 }
DevinAlexander 1:b58719a76fc3 337
DevinAlexander 7:2e45068189b1 338
DevinAlexander 1:b58719a76fc3 339 //Register:CR1 Bits: 6:4
DevinAlexander 7:2e45068189b1 340 //*****************************************************************************
DevinAlexander 7:2e45068189b1 341 bool MAX31856::setNumSamplesAvg(uint8_t val)
DevinAlexander 7:2e45068189b1 342 {
DevinAlexander 1:b58719a76fc3 343 if (val==CR1_AVG_TC_SAMPLES_1) {
DevinAlexander 1:b58719a76fc3 344 return_val=registerReadWriteByte(ADDRESS_CR1_READ, ADDRESS_CR1_WRITE, CR1_CLEAR_BITS_6_4, val);
DevinAlexander 1:b58719a76fc3 345 samples=1;
DevinAlexander 3:a99a4367c909 346 LOG("Register containing\t\tsetNumSamplesAvg\t\twas programmed with the parameter\t\tCR1_AVG_TC_SAMPLES_1\r\n");
DevinAlexander 1:b58719a76fc3 347 }
DevinAlexander 1:b58719a76fc3 348 else if (val==CR1_AVG_TC_SAMPLES_2) {
DevinAlexander 1:b58719a76fc3 349 return_val=registerReadWriteByte(ADDRESS_CR1_READ, ADDRESS_CR1_WRITE, CR1_CLEAR_BITS_6_4, val);
DevinAlexander 1:b58719a76fc3 350 samples=2;
DevinAlexander 3:a99a4367c909 351 LOG("Register containing\t\tsetNumSamplesAvg\t\twas programmed with the parameter\t\tCR1_AVG_TC_SAMPLES_2\r\n");
DevinAlexander 1:b58719a76fc3 352 }
DevinAlexander 1:b58719a76fc3 353 else if (val==CR1_AVG_TC_SAMPLES_4) {
DevinAlexander 1:b58719a76fc3 354 return_val=registerReadWriteByte(ADDRESS_CR1_READ, ADDRESS_CR1_WRITE, CR1_CLEAR_BITS_6_4, val);
DevinAlexander 1:b58719a76fc3 355 samples=4;
DevinAlexander 3:a99a4367c909 356 LOG("Register containing\t\tsetNumSamplesAvg\t\twas programmed with the parameter\t\tCR1_AVG_TC_SAMPLES_4\r\n");
DevinAlexander 1:b58719a76fc3 357 }
DevinAlexander 1:b58719a76fc3 358 else if (val==CR1_AVG_TC_SAMPLES_8) {
DevinAlexander 1:b58719a76fc3 359 return_val=registerReadWriteByte(ADDRESS_CR1_READ, ADDRESS_CR1_WRITE, CR1_CLEAR_BITS_6_4, val);
DevinAlexander 1:b58719a76fc3 360 samples=8;
DevinAlexander 3:a99a4367c909 361 LOG("Register containing\t\tsetNumSamplesAvg\t\twas programmed with the parameter\t\tCR1_AVG_TC_SAMPLES_8\r\n");
DevinAlexander 1:b58719a76fc3 362 }
DevinAlexander 1:b58719a76fc3 363 else if (val==CR1_AVG_TC_SAMPLES_16) {
DevinAlexander 1:b58719a76fc3 364 return_val=registerReadWriteByte(ADDRESS_CR1_READ, ADDRESS_CR1_WRITE, CR1_CLEAR_BITS_6_4, val);
DevinAlexander 1:b58719a76fc3 365 samples=16;
DevinAlexander 3:a99a4367c909 366 LOG("Register containing\t\tsetNumSamplesAvg\t\twas programmed with the parameter\t\tCR1_AVG_TC_SAMPLES_16\r\n");
DevinAlexander 1:b58719a76fc3 367 }
DevinAlexander 1:b58719a76fc3 368 else {
DevinAlexander 0:456e9e702d57 369 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");
DevinAlexander 0:456e9e702d57 370 return_val=0; //returns a 0 to flag that the parameter wasn't programmed due to wrong parameter in function call
DevinAlexander 0:456e9e702d57 371 }
DevinAlexander 0:456e9e702d57 372 return return_val;
DevinAlexander 0:456e9e702d57 373 }
DevinAlexander 0:456e9e702d57 374
DevinAlexander 7:2e45068189b1 375
DevinAlexander 1:b58719a76fc3 376 //Register:CR1 Bits: 3:0
DevinAlexander 7:2e45068189b1 377 //*****************************************************************************
DevinAlexander 7:2e45068189b1 378 bool MAX31856::setThermocoupleType(uint8_t val)
DevinAlexander 7:2e45068189b1 379 {
DevinAlexander 2:296485923589 380 if (val==CR1_TC_TYPE_B) {
DevinAlexander 2:296485923589 381 return_val=registerReadWriteByte(ADDRESS_CR1_READ, ADDRESS_CR1_WRITE, CR1_CLEAR_BITS_3_0, val);
DevinAlexander 2:296485923589 382 voltage_mode=false;
DevinAlexander 3:a99a4367c909 383 LOG("Register containing\t\tsetThermocoupleType\t\twas programmed with the parameter\t\tCR1_TC_TYPE_B\r\n");
DevinAlexander 2:296485923589 384 }
DevinAlexander 2:296485923589 385 else if (val==CR1_TC_TYPE_E) {
DevinAlexander 2:296485923589 386 return_val=registerReadWriteByte(ADDRESS_CR1_READ, ADDRESS_CR1_WRITE, CR1_CLEAR_BITS_3_0, val);
DevinAlexander 2:296485923589 387 voltage_mode=false;
DevinAlexander 3:a99a4367c909 388 LOG("Register containing\t\tsetThermocoupleType\t\twas programmed with the parameter\t\tCR1_TC_TYPE_E\r\n");
DevinAlexander 2:296485923589 389 }
DevinAlexander 2:296485923589 390 else if (val==CR1_TC_TYPE_J) {
DevinAlexander 2:296485923589 391 return_val=registerReadWriteByte(ADDRESS_CR1_READ, ADDRESS_CR1_WRITE, CR1_CLEAR_BITS_3_0, val);
DevinAlexander 2:296485923589 392 voltage_mode=false;
DevinAlexander 3:a99a4367c909 393 LOG("Register containing\t\tsetThermocoupleType\t\twas programmed with the parameter\t\tCR1_TC_TYPE_J\r\n");
DevinAlexander 2:296485923589 394 }
DevinAlexander 2:296485923589 395 else if (val==CR1_TC_TYPE_K) {
DevinAlexander 2:296485923589 396 return_val=registerReadWriteByte(ADDRESS_CR1_READ, ADDRESS_CR1_WRITE, CR1_CLEAR_BITS_3_0, val);
DevinAlexander 2:296485923589 397 voltage_mode=false;
DevinAlexander 3:a99a4367c909 398 LOG("Register containing\t\tsetThermocoupleType\t\twas programmed with the parameter\t\tCR1_TC_TYPE_K\r\n");
DevinAlexander 2:296485923589 399 }
DevinAlexander 2:296485923589 400 else if (val==CR1_TC_TYPE_N) {
DevinAlexander 1:b58719a76fc3 401 return_val=registerReadWriteByte(ADDRESS_CR1_READ, ADDRESS_CR1_WRITE, CR1_CLEAR_BITS_3_0, val);
DevinAlexander 1:b58719a76fc3 402 voltage_mode=false;
DevinAlexander 3:a99a4367c909 403 LOG("Register containing\t\tsetThermocoupleType\t\twas programmed with the parameter\t\tCR1_TC_TYPE_N\r\n");
DevinAlexander 1:b58719a76fc3 404 }
DevinAlexander 2:296485923589 405 else if (val==CR1_TC_TYPE_R) {
DevinAlexander 2:296485923589 406 return_val=registerReadWriteByte(ADDRESS_CR1_READ, ADDRESS_CR1_WRITE, CR1_CLEAR_BITS_3_0, val);
DevinAlexander 2:296485923589 407 voltage_mode=false;
DevinAlexander 3:a99a4367c909 408 LOG("Register containing\t\tsetThermocoupleType\t\twas programmed with the parameter\t\tCR1_TC_TYPE_R\r\n");
DevinAlexander 2:296485923589 409 }
DevinAlexander 2:296485923589 410 else if (val==CR1_TC_TYPE_S) {
DevinAlexander 2:296485923589 411 return_val=registerReadWriteByte(ADDRESS_CR1_READ, ADDRESS_CR1_WRITE, CR1_CLEAR_BITS_3_0, val);
DevinAlexander 2:296485923589 412 voltage_mode=false;
DevinAlexander 3:a99a4367c909 413 LOG("Register containing\t\tsetThermocoupleType\t\twas programmed with the parameter\t\tCR1_TC_TYPE_S\r\n");
DevinAlexander 2:296485923589 414 }
DevinAlexander 2:296485923589 415 else if (val==CR1_TC_TYPE_T) {
DevinAlexander 2:296485923589 416 return_val=registerReadWriteByte(ADDRESS_CR1_READ, ADDRESS_CR1_WRITE, CR1_CLEAR_BITS_3_0, val);
DevinAlexander 2:296485923589 417 voltage_mode=false;
DevinAlexander 3:a99a4367c909 418 LOG("Register containing\t\tsetThermocoupleType\t\twas programmed with the parameter\t\tCR1_TC_TYPE_T\r\n");
DevinAlexander 2:296485923589 419 }
DevinAlexander 2:296485923589 420 else if (val==CR1_TC_TYPE_VOLT_MODE_GAIN_8) {
DevinAlexander 1:b58719a76fc3 421 return_val=registerReadWriteByte(ADDRESS_CR1_READ, ADDRESS_CR1_WRITE, CR1_CLEAR_BITS_3_0, val);
DevinAlexander 1:b58719a76fc3 422 voltage_mode=true;
DevinAlexander 3:a99a4367c909 423 LOG("Register containing\t\tsetThermocoupleType\t\twas programmed with the parameter\t\tCR1_TC_TYPE_VOLT_MODE_GAIN_8\r\n");
DevinAlexander 2:296485923589 424 }
DevinAlexander 2:296485923589 425 else if (val==CR1_TC_TYPE_VOLT_MODE_GAIN_32) {
DevinAlexander 2:296485923589 426 return_val=registerReadWriteByte(ADDRESS_CR1_READ, ADDRESS_CR1_WRITE, CR1_CLEAR_BITS_3_0, val);
DevinAlexander 2:296485923589 427 voltage_mode=true;
DevinAlexander 3:a99a4367c909 428 LOG("Register containing\t\tsetThermocoupleType\t\twas programmed with the parameter\t\tCR1_TC_TYPE_VOLT_MODE_GAIN_32\r\n");
DevinAlexander 1:b58719a76fc3 429 }
DevinAlexander 1:b58719a76fc3 430 else {
DevinAlexander 1:b58719a76fc3 431 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");
DevinAlexander 1:b58719a76fc3 432 return_val=0; //returns a 0 to flag that the parameter wasn't programmed due to wrong parameter in function call
DevinAlexander 1:b58719a76fc3 433 }
DevinAlexander 1:b58719a76fc3 434 return return_val;
DevinAlexander 1:b58719a76fc3 435 }
DevinAlexander 1:b58719a76fc3 436
DevinAlexander 7:2e45068189b1 437
DevinAlexander 1:b58719a76fc3 438 //Register:MASK Bits: 5:0
DevinAlexander 7:2e45068189b1 439 //*****************************************************************************
DevinAlexander 7:2e45068189b1 440 bool MAX31856::setFaultMasks(uint8_t val, bool enable)
DevinAlexander 7:2e45068189b1 441 {
DevinAlexander 1:b58719a76fc3 442 if(enable)
DevinAlexander 6:e1200ae7d6a3 443 val=0;
DevinAlexander 2:296485923589 444 if (val==MASK_CJ_FAULT_THRESHOLD_HIGH) { //Cold Junction High Threshold Fault Mask
DevinAlexander 6:e1200ae7d6a3 445 return_val=registerReadWriteByte(ADDRESS_MASK_READ, ADDRESS_MASK_WRITE, MASK_CLEAR_BITS_5, val);
DevinAlexander 3:a99a4367c909 446 LOG("Register containing\t\tsetFaultMasks\t\twas programmed with the parameter\t\tMASK_CJ_FAULT_THRESHOLD_HIGH\r\n");
DevinAlexander 2:296485923589 447 }
DevinAlexander 2:296485923589 448 else if (val==MASK_CJ_FAULT_THRESHOLD_LOW) { //Cold Junction Low Threshold Fault Mask
DevinAlexander 6:e1200ae7d6a3 449 return_val=registerReadWriteByte(ADDRESS_MASK_READ, ADDRESS_MASK_WRITE, MASK_CLEAR_BITS_4, val);
DevinAlexander 3:a99a4367c909 450 LOG("Register containing\t\tsetFaultMasks\t\twas programmed with the parameter\t\tMASK_CJ_FAULT_THRESHOLD_LOW\r\n");
DevinAlexander 2:296485923589 451 }
DevinAlexander 2:296485923589 452 else if (val==MASK_TC_FAULT_THRESHOLD_HIGH) { //Thermocouple High Threshold Fault Mask
DevinAlexander 6:e1200ae7d6a3 453 return_val=registerReadWriteByte(ADDRESS_MASK_READ, ADDRESS_MASK_WRITE, MASK_CLEAR_BITS_3, val);
DevinAlexander 3:a99a4367c909 454 LOG("Register containing\t\tsetFaultMasks\t\twas programmed with the parameter\t\tMASK_TC_FAULT_THRESHOLD_HIGH\r\n");
DevinAlexander 2:296485923589 455 }
DevinAlexander 2:296485923589 456 else if (val==MASK_TC_FAULT_THRESHOLD_LOW) { //Thermocouple Low Threshold Fault Mask
DevinAlexander 6:e1200ae7d6a3 457 return_val=registerReadWriteByte(ADDRESS_MASK_READ, ADDRESS_MASK_WRITE, MASK_CLEAR_BITS_2, val);
DevinAlexander 3:a99a4367c909 458 LOG("Register containing\t\tsetFaultMasks\t\twas programmed with the parameter\t\tMASK_TC_FAULT_THRESHOLD_LOW\r\n");
DevinAlexander 2:296485923589 459 }
DevinAlexander 2:296485923589 460 else if (val==MASK_OVER_UNDER_VOLT_FAULT) { //Over-Voltage/Under-Voltage Input Fault Mask
DevinAlexander 6:e1200ae7d6a3 461 return_val=registerReadWriteByte(ADDRESS_MASK_READ, ADDRESS_MASK_WRITE, MASK_CLEAR_BITS_1, val);
DevinAlexander 3:a99a4367c909 462 LOG("Register containing\t\tsetFaultMasks\t\twas programmed with the parameter\t\tMASK_OVER_UNDER_VOLT_FAULT\r\n");
DevinAlexander 2:296485923589 463 }
DevinAlexander 2:296485923589 464 else if (val==MASK_OPEN_CIRCUIT_FAULT) { //Thermocouple Open-Circuit Fault Mask
DevinAlexander 6:e1200ae7d6a3 465 return_val=registerReadWriteByte(ADDRESS_MASK_READ, ADDRESS_MASK_WRITE, MASK_CLEAR_BITS_0, val);
DevinAlexander 3:a99a4367c909 466 LOG("Register containing\t\tsetFaultMasks\t\twas programmed with the parameter\t\tMASK_OPEN_CIRCUIT_FAULT\r\n");
DevinAlexander 2:296485923589 467 }
DevinAlexander 1:b58719a76fc3 468 else {
DevinAlexander 3:a99a4367c909 469 LOG("Incorrect parameter selected for Mask Register bits 5:0. Default value not changed.\r\nPlease see MAX31856.h for list of valid parameters. \r\n");
DevinAlexander 1:b58719a76fc3 470 return_val=0; //returns a 0 to flag that the parameter wasn't programmed due to wrong parameter in function call
DevinAlexander 1:b58719a76fc3 471 }
DevinAlexander 1:b58719a76fc3 472 return return_val;
DevinAlexander 1:b58719a76fc3 473 }
DevinAlexander 1:b58719a76fc3 474
DevinAlexander 7:2e45068189b1 475
DevinAlexander 8:8723d0006097 476 ////Register:MASK Bits: 5:0
DevinAlexander 8:8723d0006097 477 ////******************************************************************************
DevinAlexander 8:8723d0006097 478 //float MAX31856::setFaultThresholds(uint8_t val, bool enable_mask, float temperature)
DevinAlexander 8:8723d0006097 479 //{
DevinAlexander 8:8723d0006097 480 // float return_val;
DevinAlexander 8:8723d0006097 481 // uint8_t temp_val;
DevinAlexander 8:8723d0006097 482 // if(enable_mask) {
DevinAlexander 8:8723d0006097 483 // temp_val=0;
DevinAlexander 8:8723d0006097 484 // }
DevinAlexander 8:8723d0006097 485 // else {
DevinAlexander 8:8723d0006097 486 // temp_val=val;
DevinAlexander 8:8723d0006097 487 // }
DevinAlexander 8:8723d0006097 488 // if (val==MASK_CJ_FAULT_THRESHOLD_HIGH) { //Cold Junction High Threshold Fault Mask
DevinAlexander 8:8723d0006097 489 // return_val=registerReadWriteByte(ADDRESS_MASK_READ, ADDRESS_MASK_WRITE, MASK_CLEAR_BITS_5, temp_val);
DevinAlexander 8:8723d0006097 490 //
DevinAlexander 8:8723d0006097 491 // int8_t temperature_byte=temperature;
DevinAlexander 8:8723d0006097 492 //
DevinAlexander 8:8723d0006097 493 // if (temperature_byte>CJ_MAX_VAL_FAULT)
DevinAlexander 8:8723d0006097 494 // temperature_byte=CJ_MAX_VAL_FAULT;
DevinAlexander 8:8723d0006097 495 // else if (temperature_byte<=0 || temperature_byte>=CJ_MIN_VAL_FAULT)
DevinAlexander 8:8723d0006097 496 // temperature_byte=twosComplimentToSigned8(temperature_byte); //Convert the 2's compliment int into a signed value
DevinAlexander 8:8723d0006097 497 // else if (temperature_byte<CJ_MIN_VAL_FAULT)
DevinAlexander 8:8723d0006097 498 // temperature_byte=twosComplimentToSigned8(CJ_MIN_VAL_FAULT); //Convert the 2's compliment int into a signed value
DevinAlexander 8:8723d0006097 499 // //else the data is within range, no more manipulation of data is needed
DevinAlexander 8:8723d0006097 500 // return_val=registerWriteByte(ADDRESS_CJHF_WRITE, temperature_byte);
DevinAlexander 8:8723d0006097 501 // }
DevinAlexander 8:8723d0006097 502 // else if (val==MASK_CJ_FAULT_THRESHOLD_LOW) { //Cold Junction Low Threshold Fault Mask
DevinAlexander 8:8723d0006097 503 // return_val=registerReadWriteByte(ADDRESS_MASK_READ, ADDRESS_MASK_WRITE, MASK_CLEAR_BITS_4, temp_val);
DevinAlexander 8:8723d0006097 504 //
DevinAlexander 8:8723d0006097 505 // int8_t temperature_byte=temperature;
DevinAlexander 8:8723d0006097 506 //
DevinAlexander 8:8723d0006097 507 // if (temperature_byte>CJ_MAX_VAL_FAULT)
DevinAlexander 8:8723d0006097 508 // temperature_byte=CJ_MAX_VAL_FAULT;
DevinAlexander 8:8723d0006097 509 // else if (temperature_byte<=0 || temperature_byte>=CJ_MIN_VAL_FAULT)
DevinAlexander 8:8723d0006097 510 // temperature_byte=twosComplimentToSigned8(temperature_byte); //Convert the 2's compliment int into a signed value
DevinAlexander 8:8723d0006097 511 // else if (temperature_byte<CJ_MIN_VAL_FAULT)
DevinAlexander 8:8723d0006097 512 // temperature_byte=twosComplimentToSigned8(CJ_MIN_VAL_FAULT); //Convert the 2's compliment int into a signed value
DevinAlexander 8:8723d0006097 513 // //else the data is within range, no more manipulation of data is needed
DevinAlexander 8:8723d0006097 514 //
DevinAlexander 8:8723d0006097 515 // return_val=registerWriteByte(ADDRESS_CJLF_WRITE, temperature_byte);
DevinAlexander 8:8723d0006097 516 // }
DevinAlexander 8:8723d0006097 517 // else if (val==MASK_TC_FAULT_THRESHOLD_HIGH) { //Thermocouple High Threshold Fault Mask
DevinAlexander 8:8723d0006097 518 // return_val=registerReadWriteByte(ADDRESS_MASK_READ, ADDRESS_MASK_WRITE, MASK_CLEAR_BITS_3, temp_val);
DevinAlexander 8:8723d0006097 519 //
DevinAlexander 8:8723d0006097 520 // if (temperature) {
DevinAlexander 8:8723d0006097 521 // int8_t temperature_byte[2];
DevinAlexander 8:8723d0006097 522 // int16_t temperature_multi_byte =(int16_t)(temperature*4.0);
DevinAlexander 8:8723d0006097 523 // if (temperature_multi_byte>(TC_MAX_VAL_FAULT*4.0f))
DevinAlexander 8:8723d0006097 524 // temperature_multi_byte=TC_MAX_VAL_FAULT*4.0f;
DevinAlexander 8:8723d0006097 525 // else if (temperature_multi_byte<=0 || temperature_multi_byte>=(TC_MIN_VAL_FAULT*4.0f))
DevinAlexander 8:8723d0006097 526 // temperature_multi_byte=twosComplimentToSigned16(temperature_multi_byte); //Convert the 2's compliment int into a signed value
DevinAlexander 8:8723d0006097 527 // else if (temperature_multi_byte<(TC_MIN_VAL_FAULT*4.0f))
DevinAlexander 8:8723d0006097 528 // temperature_multi_byte=twosComplimentToSigned16(TC_MIN_VAL_FAULT*4.0f); //Convert the 2's compliment int into a signed value
DevinAlexander 8:8723d0006097 529 //
DevinAlexander 8:8723d0006097 530 // //now split up the 32bit int into two bytes to program the registers with
DevinAlexander 8:8723d0006097 531 // temperature_byte[0]=((uint8_t)((temperature_multi_byte)&(0xFF00) >> 8));
DevinAlexander 8:8723d0006097 532 // temperature_byte[1]=((uint8_t)((temperature_multi_byte)&(0x00FF)));
DevinAlexander 8:8723d0006097 533 //
DevinAlexander 8:8723d0006097 534 // return_val=registerWriteByte(ADDRESS_LTHFTH_WRITE, temperature_byte[0]);
DevinAlexander 8:8723d0006097 535 // return_val=registerWriteByte(ADDRESS_LTHFTL_WRITE, temperature_byte[1]);
DevinAlexander 8:8723d0006097 536 //
DevinAlexander 8:8723d0006097 537 // return_val=temperature;
DevinAlexander 8:8723d0006097 538 // }
DevinAlexander 8:8723d0006097 539 //// else {
DevinAlexander 8:8723d0006097 540 //// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////return_val="WHATEVER IS IN THE REGISTERS WHEN YOU SET THE FLAG JUST INCASE YOU NEED TO SEE WHAT IS INSISIDE THE REGISTER";
DevinAlexander 8:8723d0006097 541 //// }
DevinAlexander 8:8723d0006097 542 // }
DevinAlexander 8:8723d0006097 543 // else if (val==MASK_TC_FAULT_THRESHOLD_LOW) //Thermocouple Low Threshold Fault Mask
DevinAlexander 8:8723d0006097 544 // return_val=registerReadWriteByte(ADDRESS_MASK_READ, ADDRESS_MASK_WRITE, MASK_CLEAR_BITS_2, temp_val);
DevinAlexander 8:8723d0006097 545 // else if (val==MASK_OVER_UNDER_VOLT_FAULT) //Over-Voltage/Under-Voltage Input Fault Mask
DevinAlexander 8:8723d0006097 546 // return_val=registerReadWriteByte(ADDRESS_MASK_READ, ADDRESS_MASK_WRITE, MASK_CLEAR_BITS_1, temp_val);
DevinAlexander 8:8723d0006097 547 // else if (val==MASK_OPEN_CIRCUIT_FAULT) //Thermocouple Open-Circuit Fault Mask
DevinAlexander 8:8723d0006097 548 // return_val=registerReadWriteByte(ADDRESS_MASK_READ, ADDRESS_MASK_WRITE, MASK_CLEAR_BITS_0, temp_val);
DevinAlexander 8:8723d0006097 549 // else {
DevinAlexander 8:8723d0006097 550 // LOG("Incorrect parameter selected for MASK Register. Default value not changed.\r\nPlease see MAX31856.h for list of valid parameters. \r\n");
DevinAlexander 8:8723d0006097 551 // return_val=0; //returns a 0 to flag that the parameter wasn't programmed due to wrong parameter in function call
DevinAlexander 8:8723d0006097 552 // }
DevinAlexander 8:8723d0006097 553 // return return_val;
DevinAlexander 8:8723d0006097 554 //}
DevinAlexander 8:8723d0006097 555
DevinAlexander 7:2e45068189b1 556 //******************************************************************************
DevinAlexander 8:8723d0006097 557 bool MAX31856::coldJunctionOffset(float temperature)
DevinAlexander 7:2e45068189b1 558 {
DevinAlexander 8:8723d0006097 559 if (temperature > 7.9375 || temperature < -8.0) {
DevinAlexander 8:8723d0006097 560 LOG("Input value to offest the cold junction point is non valid. enter in value in range -8 to +7.9375\r\n");
DevinAlexander 8:8723d0006097 561 return_val = 0;
DevinAlexander 1:b58719a76fc3 562 }
DevinAlexander 8:8723d0006097 563 int8_t temp_val=temperature*16.0f; //normalize the value to get rid of decimal and shorten it to size of register
DevinAlexander 8:8723d0006097 564 return_val=registerWriteByte(ADDRESS_CJTO_WRITE, temp_val); //write the byte to cold junction offset register
DevinAlexander 0:456e9e702d57 565 return return_val;
DevinAlexander 0:456e9e702d57 566 }
DevinAlexander 0:456e9e702d57 567
DevinAlexander 0:456e9e702d57 568
DevinAlexander 1:b58719a76fc3 569 //The following functions are for internal library use only
DevinAlexander 7:2e45068189b1 570 //******************************************************************************
DevinAlexander 7:2e45068189b1 571 void MAX31856::spiEnable()
DevinAlexander 7:2e45068189b1 572 {
DevinAlexander 7:2e45068189b1 573 ncs=0; //Set CS low to start transmission (interrupts conversion)
DevinAlexander 1:b58719a76fc3 574 return;
DevinAlexander 1:b58719a76fc3 575 }
DevinAlexander 1:b58719a76fc3 576
DevinAlexander 7:2e45068189b1 577
DevinAlexander 7:2e45068189b1 578 //******************************************************************************
DevinAlexander 7:2e45068189b1 579 void MAX31856::spiDisable()
DevinAlexander 7:2e45068189b1 580 {
DevinAlexander 7:2e45068189b1 581 ncs=1; //Set CS high to stop transmission (restarts conversion)
DevinAlexander 7:2e45068189b1 582 return;
DevinAlexander 7:2e45068189b1 583 }
DevinAlexander 7:2e45068189b1 584
DevinAlexander 7:2e45068189b1 585
DevinAlexander 7:2e45068189b1 586 //******************************************************************************
DevinAlexander 7:2e45068189b1 587 bool MAX31856::registerReadWriteByte(uint8_t read_address, uint8_t write_address, uint8_t clear_bits, uint8_t val)
DevinAlexander 7:2e45068189b1 588 {
DevinAlexander 1:b58719a76fc3 589 uint8_t buf_read[2];
DevinAlexander 1:b58719a76fc3 590
DevinAlexander 0:456e9e702d57 591 //Read the current contents of a register
DevinAlexander 0:456e9e702d57 592 spiEnable();
DevinAlexander 1:b58719a76fc3 593 for(int i=0; i<2; i++) {
DevinAlexander 1:b58719a76fc3 594 buf_read[i]=spi.write(read_address);
DevinAlexander 0:456e9e702d57 595 }
DevinAlexander 0:456e9e702d57 596 spiDisable();
DevinAlexander 1:b58719a76fc3 597
DevinAlexander 1:b58719a76fc3 598 //Modify contents pulled from the register
DevinAlexander 1:b58719a76fc3 599 buf_read[1]&=clear_bits; //Clear the contents of bits of parameter you are trying to clear for later or equal operation
DevinAlexander 1:b58719a76fc3 600 buf_read[1]|=val; //Bitwise OR the input parameter with cleaned buf_read[1] to create new byte
DevinAlexander 0:456e9e702d57 601 val=buf_read[1];
DevinAlexander 1:b58719a76fc3 602
DevinAlexander 0:456e9e702d57 603 //Write the updated byte to the register
DevinAlexander 0:456e9e702d57 604 spiEnable();
DevinAlexander 1:b58719a76fc3 605 buf_read[0]=spi.write(write_address);
DevinAlexander 1:b58719a76fc3 606 buf_read[1]=spi.write(val);
DevinAlexander 1:b58719a76fc3 607 spiDisable();
DevinAlexander 1:b58719a76fc3 608 return true;
DevinAlexander 1:b58719a76fc3 609 }
DevinAlexander 1:b58719a76fc3 610
DevinAlexander 7:2e45068189b1 611
DevinAlexander 7:2e45068189b1 612 //******************************************************************************
DevinAlexander 7:2e45068189b1 613 bool MAX31856::registerWriteByte(uint8_t write_address, uint8_t val)
DevinAlexander 7:2e45068189b1 614 {
DevinAlexander 1:b58719a76fc3 615 //Write the updated byte to the register
DevinAlexander 1:b58719a76fc3 616 spiEnable();
DevinAlexander 3:a99a4367c909 617 spi.write(write_address);
DevinAlexander 3:a99a4367c909 618 spi.write(val);
DevinAlexander 0:456e9e702d57 619 spiDisable();
DevinAlexander 0:456e9e702d57 620 return true;
DevinAlexander 0:456e9e702d57 621 }
DevinAlexander 0:456e9e702d57 622
DevinAlexander 7:2e45068189b1 623 //******************************************************************************
DevinAlexander 8:8723d0006097 624 uint8_t MAX31856::registerReadByte(uint8_t read_address)
DevinAlexander 7:2e45068189b1 625 {
DevinAlexander 8:8723d0006097 626 uint8_t buf_read, buf_write=read_address;
DevinAlexander 8:8723d0006097 627 spiEnable();
DevinAlexander 8:8723d0006097 628 buf_read=spi.write(buf_write);
DevinAlexander 8:8723d0006097 629 buf_read=spi.write(buf_write);
DevinAlexander 8:8723d0006097 630 spiDisable();
DevinAlexander 8:8723d0006097 631 return buf_read;
DevinAlexander 1:b58719a76fc3 632 }
DevinAlexander 1:b58719a76fc3 633
DevinAlexander 7:2e45068189b1 634
DevinAlexander 7:2e45068189b1 635
DevinAlexander 2:296485923589 636
DevinAlexander 8:8723d0006097 637
DevinAlexander 8:8723d0006097 638
DevinAlexander 1:b58719a76fc3 639
DevinAlexander 1:b58719a76fc3 640
DevinAlexander 0:456e9e702d57 641
DevinAlexander 0:456e9e702d57 642
DevinAlexander 1:b58719a76fc3 643 ///Define parameters for control register one (CR1)
DevinAlexander 1:b58719a76fc3 644 /** Adding Samples increases the conversion time and reduces noise.
DevinAlexander 1:b58719a76fc3 645 Typical conversion times:
DevinAlexander 1:b58719a76fc3 646 1-shot or first conversion in Auto mode:
DevinAlexander 1:b58719a76fc3 647 = t_Conversion + (samples-1)*33.33mS (60Hz rejection)
DevinAlexander 1:b58719a76fc3 648 = t_Conversion + (samples-1)*40.00mS (50Hz rejection)
DevinAlexander 1:b58719a76fc3 649 2 thru n conversions in Auto mode:
DevinAlexander 1:b58719a76fc3 650 = t_Conversion + (samples-1)*16.67mS (60Hz rejection)
DevinAlexander 1:b58719a76fc3 651 = t_Conversion + (samples-1)*20.00mS (50Hz rejection)
DevinAlexander 1:b58719a76fc3 652 */
DevinAlexander 1:b58719a76fc3 653
DevinAlexander 0:456e9e702d57 654
DevinAlexander 8:8723d0006097 655 //******************************************************************************
DevinAlexander 8:8723d0006097 656 void MAX31856::calculateDelayTime() {
DevinAlexander 8:8723d0006097 657 uint32_t temp_int;
DevinAlexander 8:8723d0006097 658
DevinAlexander 8:8723d0006097 659 if (conversion_mode==0 || thermocouple_conversion_count==0) {
DevinAlexander 8:8723d0006097 660 if (filter_mode==0) //60Hz
DevinAlexander 8:8723d0006097 661 temp_int=82+(samples-1)*33.33f;
DevinAlexander 8:8723d0006097 662 else //50Hz
DevinAlexander 8:8723d0006097 663 temp_int=98+(samples-1)*40.00f;
DevinAlexander 8:8723d0006097 664 }
DevinAlexander 8:8723d0006097 665 else {
DevinAlexander 8:8723d0006097 666 if (filter_mode==0) //60Hz
DevinAlexander 8:8723d0006097 667 temp_int=82+(samples-1)*16.67f;
DevinAlexander 8:8723d0006097 668 else //50Hz
DevinAlexander 8:8723d0006097 669 temp_int=98+(samples-1)*20.00f;
DevinAlexander 8:8723d0006097 670 }
DevinAlexander 8:8723d0006097 671
DevinAlexander 8:8723d0006097 672 if (cold_junction_enabled==0) //cold junction is disabled enabling 25 millisecond faster conversion times
DevinAlexander 8:8723d0006097 673 temp_int=temp_int-25;
DevinAlexander 8:8723d0006097 674 conversion_time=1000*temp_int; //set private member conversion time to calculated minimum wait time in microseconds
DevinAlexander 8:8723d0006097 675 return;
DevinAlexander 8:8723d0006097 676 }
DevinAlexander 0:456e9e702d57 677
DevinAlexander 8:8723d0006097 678 //*****************************************************************************
DevinAlexander 8:8723d0006097 679 MAX31856::~MAX31856(void)
DevinAlexander 8:8723d0006097 680 {
DevinAlexander 8:8723d0006097 681 //empty block
DevinAlexander 8:8723d0006097 682 }
DevinAlexander 8:8723d0006097 683
DevinAlexander 8:8723d0006097 684
DevinAlexander 1:b58719a76fc3 685 //
DevinAlexander 1:b58719a76fc3 686 //
DevinAlexander 1:b58719a76fc3 687 //
DevinAlexander 1:b58719a76fc3 688 //auto 50 169
DevinAlexander 1:b58719a76fc3 689 //auto 60 143
DevinAlexander 1:b58719a76fc3 690 //1shot 50 98
DevinAlexander 1:b58719a76fc3 691 //1shot 60 82
DevinAlexander 8:8723d0006097 692
DevinAlexander 8:8723d0006097 693
DevinAlexander 8:8723d0006097 694 //*****************************************************************************
DevinAlexander 8:8723d0006097 695 //EXTRA
DevinAlexander 8:8723d0006097 696 //*****************************************************************************
DevinAlexander 8:8723d0006097 697 //bool MAX31856::checkFaultsAll()
DevinAlexander 8:8723d0006097 698 //{
DevinAlexander 8:8723d0006097 699 // uint8_t temp[9];
DevinAlexander 8:8723d0006097 700 // uint8_t buf_read, buf_write=ADDRESS_SR_READ;
DevinAlexander 8:8723d0006097 701 //
DevinAlexander 8:8723d0006097 702 // spiEnable();
DevinAlexander 8:8723d0006097 703 // buf_read=spi.write(buf_write);
DevinAlexander 8:8723d0006097 704 // buf_read=spi.write(buf_write);
DevinAlexander 8:8723d0006097 705 // spiDisable();
DevinAlexander 8:8723d0006097 706 // for(int i=0; i<9; i++)
DevinAlexander 8:8723d0006097 707 // temp[i]=buf_read;
DevinAlexander 8:8723d0006097 708 //
DevinAlexander 8:8723d0006097 709 // //Check if any of the faults are triggered
DevinAlexander 8:8723d0006097 710 // if ((temp[0]&0xFF)==0) //means no fault is detected
DevinAlexander 8:8723d0006097 711 // return_val=1;
DevinAlexander 8:8723d0006097 712 // else{
DevinAlexander 8:8723d0006097 713 // if (temp[0]&0x80) {
DevinAlexander 8:8723d0006097 714 // LOG("Cold Junction out of range fault is triggered! ");
DevinAlexander 8:8723d0006097 715 // return_val=0;
DevinAlexander 8:8723d0006097 716 // }
DevinAlexander 8:8723d0006097 717 // if (temp[1]&0x40) {
DevinAlexander 8:8723d0006097 718 // LOG("Thermocouple out of range fault is triggered! ");
DevinAlexander 8:8723d0006097 719 // return_val=0;
DevinAlexander 8:8723d0006097 720 // }
DevinAlexander 8:8723d0006097 721 // if (temp[2]&0x20) {
DevinAlexander 8:8723d0006097 722 // LOG("Temperature is higher than the threshold that is set!\r\n");
DevinAlexander 8:8723d0006097 723 // return_val=0;
DevinAlexander 8:8723d0006097 724 // }
DevinAlexander 8:8723d0006097 725 // if (temp[3]&0x10) {
DevinAlexander 8:8723d0006097 726 // LOG("Temperature is lower than the threshold that is set!\r\n");
DevinAlexander 8:8723d0006097 727 // return_val=0;
DevinAlexander 8:8723d0006097 728 // }
DevinAlexander 8:8723d0006097 729 // if (temp[4]&0x08) {
DevinAlexander 8:8723d0006097 730 // LOG("Temperature is higher than the threshold that is set!\r\n");
DevinAlexander 8:8723d0006097 731 // return_val=0;
DevinAlexander 8:8723d0006097 732 // }
DevinAlexander 8:8723d0006097 733 // if (temp[5]&0x04) {
DevinAlexander 8:8723d0006097 734 // LOG("Temperature is lower than the threshold that is set!\r\n");
DevinAlexander 8:8723d0006097 735 // return_val=0;
DevinAlexander 8:8723d0006097 736 // }
DevinAlexander 8:8723d0006097 737 // if (temp[6]&0x02) {
DevinAlexander 8:8723d0006097 738 // LOG("Overvotage/Undervoltage Fault triggered! Input voltage is negative or the voltage is greater than Vdd! Please check thermocouple connection!\r\n");
DevinAlexander 8:8723d0006097 739 // return_val=0;
DevinAlexander 8:8723d0006097 740 // }
DevinAlexander 8:8723d0006097 741 // if (temp[7]&0x01) {
DevinAlexander 8:8723d0006097 742 // LOG("Open circuit fault detected! Please check thermocouple connection!\r\n");
DevinAlexander 8:8723d0006097 743 // return_val=0;
DevinAlexander 8:8723d0006097 744 // }
DevinAlexander 8:8723d0006097 745 // }
DevinAlexander 8:8723d0006097 746 // return return_val;
DevinAlexander 8:8723d0006097 747 //}
DevinAlexander 8:8723d0006097 748
DevinAlexander 8:8723d0006097 749
DevinAlexander 8:8723d0006097 750
DevinAlexander 8:8723d0006097 751 ////******************************************************************************
DevinAlexander 8:8723d0006097 752 //int8_t MAX31856::twosComplimentToSigned8(int8_t temp)
DevinAlexander 8:8723d0006097 753 //{
DevinAlexander 8:8723d0006097 754 // temp=(~(temp)+1); //Take two's complement of the negative number
DevinAlexander 8:8723d0006097 755 // temp|=(int8_t)(0x80UL); //And convert it into 7-bit val with msb as sign bit
DevinAlexander 8:8723d0006097 756 // return temp;
DevinAlexander 8:8723d0006097 757 //}
DevinAlexander 8:8723d0006097 758
DevinAlexander 8:8723d0006097 759
DevinAlexander 8:8723d0006097 760
DevinAlexander 8:8723d0006097 761 ////******************************************************************************
DevinAlexander 8:8723d0006097 762 //int16_t MAX31856::twosComplimentToSigned16(int16_t temp)
DevinAlexander 8:8723d0006097 763 //{
DevinAlexander 8:8723d0006097 764 // temp=(~(temp)+1); //Take two's complement of the negative number
DevinAlexander 8:8723d0006097 765 // temp|=(int16_t)(0x8000UL); //And convert it into 15-bit val with msb as sign bit
DevinAlexander 8:8723d0006097 766 // return temp;
DevinAlexander 8:8723d0006097 767 //}
DevinAlexander 8:8723d0006097 768