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@7:2e45068189b1, 2017-07-31 (annotated)

Committer:
DevinAlexander
Date:
Mon Jul 31 18:46:49 2017 +0000
Revision:
7:2e45068189b1
Parent:
6:e1200ae7d6a3
Child:
8:8723d0006097
Cleaned up the code a significant amount and started restructuring the .h file significantly!

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 7:2e45068189b1 6 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 7 spi.format(8,3); //configure the correct SPI mode to beable to program the registers intially correctly
DevinAlexander 0:456e9e702d57 8 setThermocoupleType(_type);
DevinAlexander 0:456e9e702d57 9 setEmiFilterFreq(_fltr);
DevinAlexander 1:b58719a76fc3 10 setNumSamplesAvg(_samples);
DevinAlexander 1:b58719a76fc3 11 setConversionMode(_conversion_mode);
DevinAlexander 0:456e9e702d57 12 }
DevinAlexander 0:456e9e702d57 13
DevinAlexander 7:2e45068189b1 14
DevinAlexander 7:2e45068189b1 15 //*****************************************************************************
DevinAlexander 0:456e9e702d57 16 float MAX31856::readTC()
DevinAlexander 0:456e9e702d57 17 {
DevinAlexander 0:456e9e702d57 18 int32_t temp;
DevinAlexander 1:b58719a76fc3 19 uint8_t buf_read[3], buf_write[3]={ADDRESS_LTCBH_READ,ADDRESS_LTCBM_READ,ADDRESS_LTCBL_READ};
DevinAlexander 1:b58719a76fc3 20
DevinAlexander 1:b58719a76fc3 21 // uint32_t time = us_ticker_read();
DevinAlexander 1:b58719a76fc3 22 // uint32_t duration = time - lastReadTime;
DevinAlexander 1:b58719a76fc3 23 // if (duration > 200000) { // more than 250ms
DevinAlexander 2:296485923589 24 for(int i=0; i<3; i++) {
DevinAlexander 1:b58719a76fc3 25 spiEnable();
DevinAlexander 1:b58719a76fc3 26 buf_read[i]=spi.write(buf_write[i]);
DevinAlexander 1:b58719a76fc3 27 buf_read[i]=spi.write(buf_write[i]);
DevinAlexander 1:b58719a76fc3 28 spiDisable();
DevinAlexander 1:b58719a76fc3 29 }
DevinAlexander 1:b58719a76fc3 30
DevinAlexander 1:b58719a76fc3 31 //Convert the registers contents into the correct value
DevinAlexander 1:b58719a76fc3 32 temp =((buf_read[0] & 0xFF) << 11); //Shift Byte 2 into place
DevinAlexander 1:b58719a76fc3 33 temp|=((buf_read[1] & 0xFF) << 3); //Shift Byte 1 into place
DevinAlexander 1:b58719a76fc3 34 temp|=((buf_read[2] & 0xFF) >> 5); //Shift Byte 0 into place
DevinAlexander 7:2e45068189b1 35 float val=(temp/128.0f); //Divide the binary string by 2 to the 7th power
DevinAlexander 1:b58719a76fc3 36 return val;
DevinAlexander 1:b58719a76fc3 37 // }
DevinAlexander 0:456e9e702d57 38 }
DevinAlexander 0:456e9e702d57 39
DevinAlexander 7:2e45068189b1 40
DevinAlexander 7:2e45068189b1 41 //*****************************************************************************
DevinAlexander 0:456e9e702d57 42 float MAX31856::readCJ()
DevinAlexander 0:456e9e702d57 43 {
DevinAlexander 0:456e9e702d57 44 int32_t temp;
DevinAlexander 1:b58719a76fc3 45 uint8_t buf_read[3], buf_write=ADDRESS_CJTH_READ;
DevinAlexander 0:456e9e702d57 46
DevinAlexander 0:456e9e702d57 47 spiEnable();
DevinAlexander 0:456e9e702d57 48 for(int i=0; i<3; i++)
DevinAlexander 0:456e9e702d57 49 {
DevinAlexander 0:456e9e702d57 50 buf_read[i]=spi.write(buf_write);
DevinAlexander 0:456e9e702d57 51 }
DevinAlexander 0:456e9e702d57 52 spiDisable();
DevinAlexander 0:456e9e702d57 53
DevinAlexander 0:456e9e702d57 54 //Convert the registers contents into the correct value
DevinAlexander 0:456e9e702d57 55 temp =((int32_t)(buf_read[1] << 6)); //Shift the MSB into place
DevinAlexander 0:456e9e702d57 56 temp|=((int32_t)(buf_read[2] >> 2)); //Shift the LSB into place
DevinAlexander 0:456e9e702d57 57 float val=((float)(temp/64.0)); //Divide the binary string by 2 to the 6th power
DevinAlexander 0:456e9e702d57 58
DevinAlexander 0:456e9e702d57 59 return val;
DevinAlexander 0:456e9e702d57 60 }
DevinAlexander 0:456e9e702d57 61
DevinAlexander 7:2e45068189b1 62
DevinAlexander 1:b58719a76fc3 63 //Register:CR0 Bits: 7
DevinAlexander 7:2e45068189b1 64 //*****************************************************************************
DevinAlexander 7:2e45068189b1 65 bool MAX31856::setConversionMode(uint8_t val)
DevinAlexander 7:2e45068189b1 66 {
DevinAlexander 1:b58719a76fc3 67 if (val==CR0_CONV_MODE_NORMALLY_OFF) {
DevinAlexander 1:b58719a76fc3 68 return_val=registerReadWriteByte(ADDRESS_CR0_READ, ADDRESS_CR0_WRITE, CR0_CLEAR_BITS_7, val);
DevinAlexander 1:b58719a76fc3 69 conversion_mode=0;
DevinAlexander 3:a99a4367c909 70 LOG("Register containing\t\tsetConversionMode\t\twas programmed with the parameter\t\tCR0_CONV_MODE_NORMALLY_OFF\r\n");
DevinAlexander 1:b58719a76fc3 71 }
DevinAlexander 1:b58719a76fc3 72 else if (val==CR0_CONV_MODE_NORMALLY_ON) {
DevinAlexander 1:b58719a76fc3 73 return_val=registerReadWriteByte(ADDRESS_CR0_READ, ADDRESS_CR0_WRITE, CR0_CLEAR_BITS_7, val);
DevinAlexander 1:b58719a76fc3 74 conversion_mode=1;
DevinAlexander 3:a99a4367c909 75 LOG("Register containing\t\tsetConversionMode\t\twas programmed with the parameter\t\tCR0_CONV_MODE_NORMALLY_ON\r\n");
DevinAlexander 1:b58719a76fc3 76 }
DevinAlexander 1:b58719a76fc3 77 else {
DevinAlexander 1:b58719a76fc3 78 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 79 return_val=0; //returns a 0 to flag that the parameter wasn't programmed due to wrong parameter in function call
DevinAlexander 1:b58719a76fc3 80 }
DevinAlexander 1:b58719a76fc3 81 return return_val;
DevinAlexander 1:b58719a76fc3 82 }
DevinAlexander 1:b58719a76fc3 83
DevinAlexander 7:2e45068189b1 84
DevinAlexander 1:b58719a76fc3 85 //Register:CR0 Bits: 6
DevinAlexander 7:2e45068189b1 86 //*****************************************************************************
DevinAlexander 7:2e45068189b1 87 bool MAX31856::setOneShotMode(uint8_t val)
DevinAlexander 7:2e45068189b1 88 {
DevinAlexander 2:296485923589 89 if (val==CR0_1_SHOT_MODE_NO_CONVERSION) {
DevinAlexander 1:b58719a76fc3 90 return_val=registerReadWriteByte(ADDRESS_CR0_READ, ADDRESS_CR0_WRITE, CR0_CLEAR_BITS_6, val);
DevinAlexander 3:a99a4367c909 91 LOG("Register containing\t\tsetOneShotMode\t\twas programmed with the parameter\t\tCR0_1_SHOT_MODE_NO_CONVERSIONS\r\n");
DevinAlexander 2:296485923589 92 }
DevinAlexander 2:296485923589 93 else if (val==CR0_1_SHOT_MODE_ONE_CONVERSION) {
DevinAlexander 2:296485923589 94 return_val=registerReadWriteByte(ADDRESS_CR0_READ, ADDRESS_CR0_WRITE, CR0_CLEAR_BITS_6, val);
DevinAlexander 3:a99a4367c909 95 LOG("Register containing\t\tsetOneShotMode\t\twas programmed with the parameter\t\tCR0_1_SHOT_MODE_NO_CONVERSIONS\r\n");
DevinAlexander 2:296485923589 96 }
DevinAlexander 1:b58719a76fc3 97 else {
DevinAlexander 1:b58719a76fc3 98 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 99 return_val=0; //returns a 0 to flag that the parameter wasn't programmed due to wrong parameter in function call
DevinAlexander 1:b58719a76fc3 100 }
DevinAlexander 1:b58719a76fc3 101 return return_val;
DevinAlexander 1:b58719a76fc3 102 }
DevinAlexander 1:b58719a76fc3 103
DevinAlexander 7:2e45068189b1 104
DevinAlexander 1:b58719a76fc3 105 //Register:CR0 Bits: 5:4
DevinAlexander 7:2e45068189b1 106 //*****************************************************************************
DevinAlexander 7:2e45068189b1 107 bool MAX31856::setOpenCircuitFaultDetection(uint8_t val)
DevinAlexander 7:2e45068189b1 108 {
DevinAlexander 2:296485923589 109 if (val==CR0_OC_DETECT_DISABLED) {
DevinAlexander 2:296485923589 110 return_val=registerReadWriteByte(ADDRESS_CR0_READ, ADDRESS_CR0_WRITE, CR0_CLEAR_BITS_5_4, val);
DevinAlexander 3:a99a4367c909 111 LOG("Register containing\t\tsetOpenCircuitFaultDetection\t\twas programmed with the parameter\t\tCR0_OC_DETECT_DISABLED\r\n");
DevinAlexander 2:296485923589 112 }
DevinAlexander 2:296485923589 113 else if (val==CR0_OC_DETECT_ENABLED_R_LESS_5k) {
DevinAlexander 1:b58719a76fc3 114 return_val=registerReadWriteByte(ADDRESS_CR0_READ, ADDRESS_CR0_WRITE, CR0_CLEAR_BITS_5_4, val);
DevinAlexander 3:a99a4367c909 115 LOG("Register containing\t\tsetOpenCircuitFaultDetection\t\twas programmed with the parameter\t\tCR0_OC_DETECT_ENABLED_R_LESS_5k\r\n");
DevinAlexander 2:296485923589 116 }
DevinAlexander 2:296485923589 117 else if (val==CR0_OC_DETECT_ENABLED_TC_LESS_2ms) {
DevinAlexander 2:296485923589 118 return_val=registerReadWriteByte(ADDRESS_CR0_READ, ADDRESS_CR0_WRITE, CR0_CLEAR_BITS_5_4, val);
DevinAlexander 3:a99a4367c909 119 LOG("Register containing\t\tsetOpenCircuitFaultDetection\t\twas programmed with the parameter\t\tCR0_OC_DETECT_ENABLED_TC_LESS_2ms\r\n");
DevinAlexander 2:296485923589 120 }
DevinAlexander 2:296485923589 121 else if (val==CR0_OC_DETECT_ENABLED_TC_MORE_2ms) {
DevinAlexander 2:296485923589 122 return_val=registerReadWriteByte(ADDRESS_CR0_READ, ADDRESS_CR0_WRITE, CR0_CLEAR_BITS_5_4, val);
DevinAlexander 3:a99a4367c909 123 LOG("Register containing\t\tsetOpenCircuitFaultDetection\t\twas programmed with the parameter\t\tCR0_OC_DETECT_ENABLED_TC_MORE_2ms\r\n");
DevinAlexander 2:296485923589 124 }
DevinAlexander 1:b58719a76fc3 125 else {
DevinAlexander 1:b58719a76fc3 126 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 127 return_val=0; //returns a 0 to flag that the parameter wasn't programmed due to wrong parameter in function call
DevinAlexander 1:b58719a76fc3 128 }
DevinAlexander 1:b58719a76fc3 129 return return_val;
DevinAlexander 1:b58719a76fc3 130 }
DevinAlexander 1:b58719a76fc3 131
DevinAlexander 7:2e45068189b1 132
DevinAlexander 1:b58719a76fc3 133 //Register:CR0 Bits: 3
DevinAlexander 7:2e45068189b1 134 //*****************************************************************************
DevinAlexander 7:2e45068189b1 135 bool MAX31856::setColdJunctionDisable(uint8_t val)
DevinAlexander 7:2e45068189b1 136 {
DevinAlexander 1:b58719a76fc3 137 if (val==CR0_COLD_JUNC_ENABLE) {
DevinAlexander 1:b58719a76fc3 138 return_val=registerReadWriteByte(ADDRESS_CR0_READ, ADDRESS_CR0_WRITE, CR0_CLEAR_BITS_3, val);
DevinAlexander 1:b58719a76fc3 139 cold_junction_enabled=1;
DevinAlexander 3:a99a4367c909 140 LOG("Register containing\t\tsetColdJunctionDisable\t\twas programmed with the parameter\t\tCR0_COLD_JUNC_ENABLE\r\n");
DevinAlexander 1:b58719a76fc3 141 }
DevinAlexander 1:b58719a76fc3 142 else if (val==CR0_COLD_JUNC_DISABLE) {
DevinAlexander 1:b58719a76fc3 143 return_val=registerReadWriteByte(ADDRESS_CR0_READ, ADDRESS_CR0_WRITE, CR0_CLEAR_BITS_3, val);
DevinAlexander 1:b58719a76fc3 144 cold_junction_enabled=0;
DevinAlexander 3:a99a4367c909 145 LOG("Register containing\t\tsetColdJunctionDisable\t\twas programmed with the parameter\t\tCR0_COLD_JUNC_DISABLE\r\n");
DevinAlexander 1:b58719a76fc3 146 }
DevinAlexander 1:b58719a76fc3 147 else {
DevinAlexander 1:b58719a76fc3 148 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 149 return_val=0; //returns a 0 to flag that the parameter wasn't programmed due to wrong parameter in function call
DevinAlexander 1:b58719a76fc3 150 }
DevinAlexander 1:b58719a76fc3 151 return return_val;
DevinAlexander 1:b58719a76fc3 152 }
DevinAlexander 1:b58719a76fc3 153
DevinAlexander 7:2e45068189b1 154
DevinAlexander 1:b58719a76fc3 155 //Register:CR0 Bits: 2
DevinAlexander 7:2e45068189b1 156 //*****************************************************************************
DevinAlexander 7:2e45068189b1 157 bool MAX31856::setFaultMode(uint8_t val)
DevinAlexander 7:2e45068189b1 158 {
DevinAlexander 2:296485923589 159 if (val==CR0_FAULT_MODE_COMPARATOR) {
DevinAlexander 1:b58719a76fc3 160 return_val=registerReadWriteByte(ADDRESS_CR0_READ, ADDRESS_CR0_WRITE, CR0_CLEAR_BITS_2, val);
DevinAlexander 3:a99a4367c909 161 LOG("Register containing\t\tsetFaultMode\t\twas programmed with the parameter\t\tCR0_FAULT_MODE_COMPARATOR\r\n");
DevinAlexander 2:296485923589 162 }
DevinAlexander 2:296485923589 163 else if (val==CR0_FAULT_MODE_INTERUPT) {
DevinAlexander 2:296485923589 164 return_val=registerReadWriteByte(ADDRESS_CR0_READ, ADDRESS_CR0_WRITE, CR0_CLEAR_BITS_2, val);
DevinAlexander 3:a99a4367c909 165 LOG("Register containing\t\tsetFaultMode\t\twas programmed with the parameter\t\tCR0_FAULT_MODE_INTERUPT\r\n");
DevinAlexander 2:296485923589 166 }
DevinAlexander 1:b58719a76fc3 167 else {
DevinAlexander 1:b58719a76fc3 168 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 169 return_val=0; //returns a 0 to flag that the parameter wasn't programmed due to wrong parameter in function call
DevinAlexander 1:b58719a76fc3 170 }
DevinAlexander 1:b58719a76fc3 171 return return_val;
DevinAlexander 1:b58719a76fc3 172 }
DevinAlexander 1:b58719a76fc3 173
DevinAlexander 7:2e45068189b1 174
DevinAlexander 1:b58719a76fc3 175 //Register:CR0 Bits: 1
DevinAlexander 7:2e45068189b1 176 //*****************************************************************************
DevinAlexander 7:2e45068189b1 177 bool MAX31856::setFaultStatusClear(uint8_t val)
DevinAlexander 7:2e45068189b1 178 {
DevinAlexander 2:296485923589 179 if (val==CR0_FAULTCLR_DEFAULT_VAL) {
DevinAlexander 1:b58719a76fc3 180 return_val=registerReadWriteByte(ADDRESS_CR0_READ, ADDRESS_CR0_WRITE, CR0_CLEAR_BITS_1, val);
DevinAlexander 3:a99a4367c909 181 LOG("Register containing\t\tsetFaultStatusClear\t\twas programmed with the parameter\t\tCR0_FAULTCLR_DEFAULT_VAL\r\n");
DevinAlexander 2:296485923589 182 }
DevinAlexander 2:296485923589 183 else if (val==CR0_FAULTCLR_RETURN_FAULTS_TO_ZERO) {
DevinAlexander 2:296485923589 184 return_val=registerReadWriteByte(ADDRESS_CR0_READ, ADDRESS_CR0_WRITE, CR0_CLEAR_BITS_1, val);
DevinAlexander 3:a99a4367c909 185 LOG("Register containing\t\tsetFaultStatusClear\t\twas programmed with the parameter\t\tCR0_FAULTCLR_RETURN_FAULTS_TO_ZERO\r\n");
DevinAlexander 2:296485923589 186 }
DevinAlexander 1:b58719a76fc3 187 else {
DevinAlexander 1:b58719a76fc3 188 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 189 return_val=0; //returns a 0 to flag that the parameter wasn't programmed due to wrong parameter in function call
DevinAlexander 1:b58719a76fc3 190 }
DevinAlexander 1:b58719a76fc3 191 return return_val;
DevinAlexander 1:b58719a76fc3 192 }
DevinAlexander 1:b58719a76fc3 193
DevinAlexander 7:2e45068189b1 194
DevinAlexander 1:b58719a76fc3 195 //Register:CR0 Bits: 0
DevinAlexander 7:2e45068189b1 196 //*****************************************************************************
DevinAlexander 7:2e45068189b1 197 bool MAX31856::setEmiFilterFreq(uint8_t val)
DevinAlexander 7:2e45068189b1 198 {
DevinAlexander 1:b58719a76fc3 199 if (val==CR0_FILTER_OUT_60Hz) {
DevinAlexander 1:b58719a76fc3 200 return_val=registerReadWriteByte(ADDRESS_CR0_READ, ADDRESS_CR0_WRITE, CR0_CLEAR_BITS_0, val);
DevinAlexander 1:b58719a76fc3 201 filter_mode=0;
DevinAlexander 3:a99a4367c909 202 LOG("Register containing\t\tsetEmiFilterFreq\t\twas programmed with the parameter\t\tCR0_FILTER_OUT_60Hz\r\n");
DevinAlexander 1:b58719a76fc3 203 }
DevinAlexander 1:b58719a76fc3 204 else if (val==CR0_FILTER_OUT_50Hz) {
DevinAlexander 1:b58719a76fc3 205 return_val=registerReadWriteByte(ADDRESS_CR0_READ, ADDRESS_CR0_WRITE, CR0_CLEAR_BITS_0, val);
DevinAlexander 1:b58719a76fc3 206 filter_mode=1;
DevinAlexander 3:a99a4367c909 207 LOG("Register containing\t\tsetEmiFilterFreq\t\twas programmed with the parameter\t\tCR0_FILTER_OUT_50Hz\r\n");
DevinAlexander 0:456e9e702d57 208 }
DevinAlexander 1:b58719a76fc3 209 else {
DevinAlexander 1:b58719a76fc3 210 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 211 return_val=0; //returns a 0 to flag that the parameter wasn't programmed due to wrong parameter in function call
DevinAlexander 1:b58719a76fc3 212 }
DevinAlexander 1:b58719a76fc3 213 return return_val;
DevinAlexander 1:b58719a76fc3 214 }
DevinAlexander 1:b58719a76fc3 215
DevinAlexander 7:2e45068189b1 216
DevinAlexander 1:b58719a76fc3 217 //Register:CR1 Bits: 6:4
DevinAlexander 7:2e45068189b1 218 //*****************************************************************************
DevinAlexander 7:2e45068189b1 219 bool MAX31856::setNumSamplesAvg(uint8_t val)
DevinAlexander 7:2e45068189b1 220 {
DevinAlexander 1:b58719a76fc3 221 if (val==CR1_AVG_TC_SAMPLES_1) {
DevinAlexander 1:b58719a76fc3 222 return_val=registerReadWriteByte(ADDRESS_CR1_READ, ADDRESS_CR1_WRITE, CR1_CLEAR_BITS_6_4, val);
DevinAlexander 1:b58719a76fc3 223 samples=1;
DevinAlexander 3:a99a4367c909 224 LOG("Register containing\t\tsetNumSamplesAvg\t\twas programmed with the parameter\t\tCR1_AVG_TC_SAMPLES_1\r\n");
DevinAlexander 1:b58719a76fc3 225 }
DevinAlexander 1:b58719a76fc3 226 else if (val==CR1_AVG_TC_SAMPLES_2) {
DevinAlexander 1:b58719a76fc3 227 return_val=registerReadWriteByte(ADDRESS_CR1_READ, ADDRESS_CR1_WRITE, CR1_CLEAR_BITS_6_4, val);
DevinAlexander 1:b58719a76fc3 228 samples=2;
DevinAlexander 3:a99a4367c909 229 LOG("Register containing\t\tsetNumSamplesAvg\t\twas programmed with the parameter\t\tCR1_AVG_TC_SAMPLES_2\r\n");
DevinAlexander 1:b58719a76fc3 230 }
DevinAlexander 1:b58719a76fc3 231 else if (val==CR1_AVG_TC_SAMPLES_4) {
DevinAlexander 1:b58719a76fc3 232 return_val=registerReadWriteByte(ADDRESS_CR1_READ, ADDRESS_CR1_WRITE, CR1_CLEAR_BITS_6_4, val);
DevinAlexander 1:b58719a76fc3 233 samples=4;
DevinAlexander 3:a99a4367c909 234 LOG("Register containing\t\tsetNumSamplesAvg\t\twas programmed with the parameter\t\tCR1_AVG_TC_SAMPLES_4\r\n");
DevinAlexander 1:b58719a76fc3 235 }
DevinAlexander 1:b58719a76fc3 236 else if (val==CR1_AVG_TC_SAMPLES_8) {
DevinAlexander 1:b58719a76fc3 237 return_val=registerReadWriteByte(ADDRESS_CR1_READ, ADDRESS_CR1_WRITE, CR1_CLEAR_BITS_6_4, val);
DevinAlexander 1:b58719a76fc3 238 samples=8;
DevinAlexander 3:a99a4367c909 239 LOG("Register containing\t\tsetNumSamplesAvg\t\twas programmed with the parameter\t\tCR1_AVG_TC_SAMPLES_8\r\n");
DevinAlexander 1:b58719a76fc3 240 }
DevinAlexander 1:b58719a76fc3 241 else if (val==CR1_AVG_TC_SAMPLES_16) {
DevinAlexander 1:b58719a76fc3 242 return_val=registerReadWriteByte(ADDRESS_CR1_READ, ADDRESS_CR1_WRITE, CR1_CLEAR_BITS_6_4, val);
DevinAlexander 1:b58719a76fc3 243 samples=16;
DevinAlexander 3:a99a4367c909 244 LOG("Register containing\t\tsetNumSamplesAvg\t\twas programmed with the parameter\t\tCR1_AVG_TC_SAMPLES_16\r\n");
DevinAlexander 1:b58719a76fc3 245 }
DevinAlexander 1:b58719a76fc3 246 else {
DevinAlexander 0:456e9e702d57 247 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 248 return_val=0; //returns a 0 to flag that the parameter wasn't programmed due to wrong parameter in function call
DevinAlexander 0:456e9e702d57 249 }
DevinAlexander 0:456e9e702d57 250 return return_val;
DevinAlexander 0:456e9e702d57 251 }
DevinAlexander 0:456e9e702d57 252
DevinAlexander 7:2e45068189b1 253
DevinAlexander 1:b58719a76fc3 254 //Register:CR1 Bits: 3:0
DevinAlexander 7:2e45068189b1 255 //*****************************************************************************
DevinAlexander 7:2e45068189b1 256 bool MAX31856::setThermocoupleType(uint8_t val)
DevinAlexander 7:2e45068189b1 257 {
DevinAlexander 2:296485923589 258 if (val==CR1_TC_TYPE_B) {
DevinAlexander 2:296485923589 259 return_val=registerReadWriteByte(ADDRESS_CR1_READ, ADDRESS_CR1_WRITE, CR1_CLEAR_BITS_3_0, val);
DevinAlexander 2:296485923589 260 voltage_mode=false;
DevinAlexander 3:a99a4367c909 261 LOG("Register containing\t\tsetThermocoupleType\t\twas programmed with the parameter\t\tCR1_TC_TYPE_B\r\n");
DevinAlexander 2:296485923589 262 }
DevinAlexander 2:296485923589 263 else if (val==CR1_TC_TYPE_E) {
DevinAlexander 2:296485923589 264 return_val=registerReadWriteByte(ADDRESS_CR1_READ, ADDRESS_CR1_WRITE, CR1_CLEAR_BITS_3_0, val);
DevinAlexander 2:296485923589 265 voltage_mode=false;
DevinAlexander 3:a99a4367c909 266 LOG("Register containing\t\tsetThermocoupleType\t\twas programmed with the parameter\t\tCR1_TC_TYPE_E\r\n");
DevinAlexander 2:296485923589 267 }
DevinAlexander 2:296485923589 268 else if (val==CR1_TC_TYPE_J) {
DevinAlexander 2:296485923589 269 return_val=registerReadWriteByte(ADDRESS_CR1_READ, ADDRESS_CR1_WRITE, CR1_CLEAR_BITS_3_0, val);
DevinAlexander 2:296485923589 270 voltage_mode=false;
DevinAlexander 3:a99a4367c909 271 LOG("Register containing\t\tsetThermocoupleType\t\twas programmed with the parameter\t\tCR1_TC_TYPE_J\r\n");
DevinAlexander 2:296485923589 272 }
DevinAlexander 2:296485923589 273 else if (val==CR1_TC_TYPE_K) {
DevinAlexander 2:296485923589 274 return_val=registerReadWriteByte(ADDRESS_CR1_READ, ADDRESS_CR1_WRITE, CR1_CLEAR_BITS_3_0, val);
DevinAlexander 2:296485923589 275 voltage_mode=false;
DevinAlexander 3:a99a4367c909 276 LOG("Register containing\t\tsetThermocoupleType\t\twas programmed with the parameter\t\tCR1_TC_TYPE_K\r\n");
DevinAlexander 2:296485923589 277 }
DevinAlexander 2:296485923589 278 else if (val==CR1_TC_TYPE_N) {
DevinAlexander 1:b58719a76fc3 279 return_val=registerReadWriteByte(ADDRESS_CR1_READ, ADDRESS_CR1_WRITE, CR1_CLEAR_BITS_3_0, val);
DevinAlexander 1:b58719a76fc3 280 voltage_mode=false;
DevinAlexander 3:a99a4367c909 281 LOG("Register containing\t\tsetThermocoupleType\t\twas programmed with the parameter\t\tCR1_TC_TYPE_N\r\n");
DevinAlexander 1:b58719a76fc3 282 }
DevinAlexander 2:296485923589 283 else if (val==CR1_TC_TYPE_R) {
DevinAlexander 2:296485923589 284 return_val=registerReadWriteByte(ADDRESS_CR1_READ, ADDRESS_CR1_WRITE, CR1_CLEAR_BITS_3_0, val);
DevinAlexander 2:296485923589 285 voltage_mode=false;
DevinAlexander 3:a99a4367c909 286 LOG("Register containing\t\tsetThermocoupleType\t\twas programmed with the parameter\t\tCR1_TC_TYPE_R\r\n");
DevinAlexander 2:296485923589 287 }
DevinAlexander 2:296485923589 288 else if (val==CR1_TC_TYPE_S) {
DevinAlexander 2:296485923589 289 return_val=registerReadWriteByte(ADDRESS_CR1_READ, ADDRESS_CR1_WRITE, CR1_CLEAR_BITS_3_0, val);
DevinAlexander 2:296485923589 290 voltage_mode=false;
DevinAlexander 3:a99a4367c909 291 LOG("Register containing\t\tsetThermocoupleType\t\twas programmed with the parameter\t\tCR1_TC_TYPE_S\r\n");
DevinAlexander 2:296485923589 292 }
DevinAlexander 2:296485923589 293 else if (val==CR1_TC_TYPE_T) {
DevinAlexander 2:296485923589 294 return_val=registerReadWriteByte(ADDRESS_CR1_READ, ADDRESS_CR1_WRITE, CR1_CLEAR_BITS_3_0, val);
DevinAlexander 2:296485923589 295 voltage_mode=false;
DevinAlexander 3:a99a4367c909 296 LOG("Register containing\t\tsetThermocoupleType\t\twas programmed with the parameter\t\tCR1_TC_TYPE_T\r\n");
DevinAlexander 2:296485923589 297 }
DevinAlexander 2:296485923589 298 else if (val==CR1_TC_TYPE_VOLT_MODE_GAIN_8) {
DevinAlexander 1:b58719a76fc3 299 return_val=registerReadWriteByte(ADDRESS_CR1_READ, ADDRESS_CR1_WRITE, CR1_CLEAR_BITS_3_0, val);
DevinAlexander 1:b58719a76fc3 300 voltage_mode=true;
DevinAlexander 3:a99a4367c909 301 LOG("Register containing\t\tsetThermocoupleType\t\twas programmed with the parameter\t\tCR1_TC_TYPE_VOLT_MODE_GAIN_8\r\n");
DevinAlexander 2:296485923589 302 }
DevinAlexander 2:296485923589 303 else if (val==CR1_TC_TYPE_VOLT_MODE_GAIN_32) {
DevinAlexander 2:296485923589 304 return_val=registerReadWriteByte(ADDRESS_CR1_READ, ADDRESS_CR1_WRITE, CR1_CLEAR_BITS_3_0, val);
DevinAlexander 2:296485923589 305 voltage_mode=true;
DevinAlexander 3:a99a4367c909 306 LOG("Register containing\t\tsetThermocoupleType\t\twas programmed with the parameter\t\tCR1_TC_TYPE_VOLT_MODE_GAIN_32\r\n");
DevinAlexander 1:b58719a76fc3 307 }
DevinAlexander 1:b58719a76fc3 308 else {
DevinAlexander 1:b58719a76fc3 309 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 310 return_val=0; //returns a 0 to flag that the parameter wasn't programmed due to wrong parameter in function call
DevinAlexander 1:b58719a76fc3 311 }
DevinAlexander 1:b58719a76fc3 312 return return_val;
DevinAlexander 1:b58719a76fc3 313 }
DevinAlexander 1:b58719a76fc3 314
DevinAlexander 7:2e45068189b1 315
DevinAlexander 1:b58719a76fc3 316 //Register:MASK Bits: 5:0
DevinAlexander 7:2e45068189b1 317 //*****************************************************************************
DevinAlexander 7:2e45068189b1 318 bool MAX31856::setFaultMasks(uint8_t val, bool enable)
DevinAlexander 7:2e45068189b1 319 {
DevinAlexander 1:b58719a76fc3 320 if(enable)
DevinAlexander 6:e1200ae7d6a3 321 val=0;
DevinAlexander 6:e1200ae7d6a3 322 ;
DevinAlexander 2:296485923589 323 if (val==MASK_CJ_FAULT_THRESHOLD_HIGH) { //Cold Junction High Threshold Fault Mask
DevinAlexander 6:e1200ae7d6a3 324 return_val=registerReadWriteByte(ADDRESS_MASK_READ, ADDRESS_MASK_WRITE, MASK_CLEAR_BITS_5, val);
DevinAlexander 3:a99a4367c909 325 LOG("Register containing\t\tsetFaultMasks\t\twas programmed with the parameter\t\tMASK_CJ_FAULT_THRESHOLD_HIGH\r\n");
DevinAlexander 2:296485923589 326 }
DevinAlexander 2:296485923589 327 else if (val==MASK_CJ_FAULT_THRESHOLD_LOW) { //Cold Junction Low Threshold Fault Mask
DevinAlexander 6:e1200ae7d6a3 328 return_val=registerReadWriteByte(ADDRESS_MASK_READ, ADDRESS_MASK_WRITE, MASK_CLEAR_BITS_4, val);
DevinAlexander 3:a99a4367c909 329 LOG("Register containing\t\tsetFaultMasks\t\twas programmed with the parameter\t\tMASK_CJ_FAULT_THRESHOLD_LOW\r\n");
DevinAlexander 2:296485923589 330 }
DevinAlexander 2:296485923589 331 else if (val==MASK_TC_FAULT_THRESHOLD_HIGH) { //Thermocouple High Threshold Fault Mask
DevinAlexander 6:e1200ae7d6a3 332 return_val=registerReadWriteByte(ADDRESS_MASK_READ, ADDRESS_MASK_WRITE, MASK_CLEAR_BITS_3, val);
DevinAlexander 3:a99a4367c909 333 LOG("Register containing\t\tsetFaultMasks\t\twas programmed with the parameter\t\tMASK_TC_FAULT_THRESHOLD_HIGH\r\n");
DevinAlexander 2:296485923589 334 }
DevinAlexander 2:296485923589 335 else if (val==MASK_TC_FAULT_THRESHOLD_LOW) { //Thermocouple Low Threshold Fault Mask
DevinAlexander 6:e1200ae7d6a3 336 return_val=registerReadWriteByte(ADDRESS_MASK_READ, ADDRESS_MASK_WRITE, MASK_CLEAR_BITS_2, val);
DevinAlexander 3:a99a4367c909 337 LOG("Register containing\t\tsetFaultMasks\t\twas programmed with the parameter\t\tMASK_TC_FAULT_THRESHOLD_LOW\r\n");
DevinAlexander 2:296485923589 338 }
DevinAlexander 2:296485923589 339 else if (val==MASK_OVER_UNDER_VOLT_FAULT) { //Over-Voltage/Under-Voltage Input Fault Mask
DevinAlexander 6:e1200ae7d6a3 340 return_val=registerReadWriteByte(ADDRESS_MASK_READ, ADDRESS_MASK_WRITE, MASK_CLEAR_BITS_1, val);
DevinAlexander 3:a99a4367c909 341 LOG("Register containing\t\tsetFaultMasks\t\twas programmed with the parameter\t\tMASK_OVER_UNDER_VOLT_FAULT\r\n");
DevinAlexander 2:296485923589 342 }
DevinAlexander 2:296485923589 343 else if (val==MASK_OPEN_CIRCUIT_FAULT) { //Thermocouple Open-Circuit Fault Mask
DevinAlexander 6:e1200ae7d6a3 344 return_val=registerReadWriteByte(ADDRESS_MASK_READ, ADDRESS_MASK_WRITE, MASK_CLEAR_BITS_0, val);
DevinAlexander 3:a99a4367c909 345 LOG("Register containing\t\tsetFaultMasks\t\twas programmed with the parameter\t\tMASK_OPEN_CIRCUIT_FAULT\r\n");
DevinAlexander 2:296485923589 346 }
DevinAlexander 1:b58719a76fc3 347 else {
DevinAlexander 3:a99a4367c909 348 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 349 return_val=0; //returns a 0 to flag that the parameter wasn't programmed due to wrong parameter in function call
DevinAlexander 1:b58719a76fc3 350 }
DevinAlexander 1:b58719a76fc3 351 return return_val;
DevinAlexander 1:b58719a76fc3 352 }
DevinAlexander 1:b58719a76fc3 353
DevinAlexander 7:2e45068189b1 354
DevinAlexander 1:b58719a76fc3 355 //Register:MASK Bits: 5:0
DevinAlexander 7:2e45068189b1 356 //******************************************************************************
DevinAlexander 7:2e45068189b1 357 float MAX31856::setFaultThresholds(uint8_t val, bool enable_mask, float temperature)
DevinAlexander 7:2e45068189b1 358 {
DevinAlexander 7:2e45068189b1 359 float return_val;
DevinAlexander 1:b58719a76fc3 360 uint8_t temp_val;
DevinAlexander 1:b58719a76fc3 361 if(enable_mask) {
DevinAlexander 1:b58719a76fc3 362 temp_val=0;
DevinAlexander 1:b58719a76fc3 363 }
DevinAlexander 1:b58719a76fc3 364 else {
DevinAlexander 1:b58719a76fc3 365 temp_val=val;
DevinAlexander 1:b58719a76fc3 366 }
DevinAlexander 1:b58719a76fc3 367 if (val==MASK_CJ_FAULT_THRESHOLD_HIGH) { //Cold Junction High Threshold Fault Mask
DevinAlexander 1:b58719a76fc3 368 return_val=registerReadWriteByte(ADDRESS_MASK_READ, ADDRESS_MASK_WRITE, MASK_CLEAR_BITS_5, temp_val);
DevinAlexander 1:b58719a76fc3 369
DevinAlexander 1:b58719a76fc3 370 int8_t temperature_byte=temperature;
DevinAlexander 1:b58719a76fc3 371
DevinAlexander 1:b58719a76fc3 372 if (temperature_byte>CJ_MAX_VAL_FAULT)
DevinAlexander 1:b58719a76fc3 373 temperature_byte=CJ_MAX_VAL_FAULT;
DevinAlexander 1:b58719a76fc3 374 else if (temperature_byte<=0 || temperature_byte>=CJ_MIN_VAL_FAULT)
DevinAlexander 1:b58719a76fc3 375 temperature_byte=twosComplimentToSigned8(temperature_byte); //Convert the 2's compliment int into a signed value
DevinAlexander 1:b58719a76fc3 376 else if (temperature_byte<CJ_MIN_VAL_FAULT)
DevinAlexander 1:b58719a76fc3 377 temperature_byte=twosComplimentToSigned8(CJ_MIN_VAL_FAULT); //Convert the 2's compliment int into a signed value
DevinAlexander 1:b58719a76fc3 378 //else the data is within range, no more manipulation of data is needed
DevinAlexander 1:b58719a76fc3 379 return_val=registerWriteByte(ADDRESS_CJHF_WRITE, temperature_byte);
DevinAlexander 1:b58719a76fc3 380 }
DevinAlexander 1:b58719a76fc3 381 else if (val==MASK_CJ_FAULT_THRESHOLD_LOW) { //Cold Junction Low Threshold Fault Mask
DevinAlexander 1:b58719a76fc3 382 return_val=registerReadWriteByte(ADDRESS_MASK_READ, ADDRESS_MASK_WRITE, MASK_CLEAR_BITS_4, temp_val);
DevinAlexander 1:b58719a76fc3 383
DevinAlexander 1:b58719a76fc3 384 int8_t temperature_byte=temperature;
DevinAlexander 1:b58719a76fc3 385
DevinAlexander 1:b58719a76fc3 386 if (temperature_byte>CJ_MAX_VAL_FAULT)
DevinAlexander 1:b58719a76fc3 387 temperature_byte=CJ_MAX_VAL_FAULT;
DevinAlexander 1:b58719a76fc3 388 else if (temperature_byte<=0 || temperature_byte>=CJ_MIN_VAL_FAULT)
DevinAlexander 1:b58719a76fc3 389 temperature_byte=twosComplimentToSigned8(temperature_byte); //Convert the 2's compliment int into a signed value
DevinAlexander 1:b58719a76fc3 390 else if (temperature_byte<CJ_MIN_VAL_FAULT)
DevinAlexander 1:b58719a76fc3 391 temperature_byte=twosComplimentToSigned8(CJ_MIN_VAL_FAULT); //Convert the 2's compliment int into a signed value
DevinAlexander 1:b58719a76fc3 392 //else the data is within range, no more manipulation of data is needed
DevinAlexander 1:b58719a76fc3 393
DevinAlexander 1:b58719a76fc3 394 return_val=registerWriteByte(ADDRESS_CJLF_WRITE, temperature_byte);
DevinAlexander 1:b58719a76fc3 395 }
DevinAlexander 1:b58719a76fc3 396 else if (val==MASK_TC_FAULT_THRESHOLD_HIGH) { //Thermocouple High Threshold Fault Mask
DevinAlexander 1:b58719a76fc3 397 return_val=registerReadWriteByte(ADDRESS_MASK_READ, ADDRESS_MASK_WRITE, MASK_CLEAR_BITS_3, temp_val);
DevinAlexander 1:b58719a76fc3 398
DevinAlexander 1:b58719a76fc3 399 if (temperature) {
DevinAlexander 1:b58719a76fc3 400 int8_t temperature_byte[2];
DevinAlexander 1:b58719a76fc3 401 int16_t temperature_multi_byte =(int16_t)(temperature*4.0);
DevinAlexander 1:b58719a76fc3 402 if (temperature_multi_byte>(TC_MAX_VAL_FAULT*4.0f))
DevinAlexander 1:b58719a76fc3 403 temperature_multi_byte=TC_MAX_VAL_FAULT*4.0f;
DevinAlexander 1:b58719a76fc3 404 else if (temperature_multi_byte<=0 || temperature_multi_byte>=(TC_MIN_VAL_FAULT*4.0f))
DevinAlexander 1:b58719a76fc3 405 temperature_multi_byte=twosComplimentToSigned16(temperature_multi_byte); //Convert the 2's compliment int into a signed value
DevinAlexander 1:b58719a76fc3 406 else if (temperature_multi_byte<(TC_MIN_VAL_FAULT*4.0f))
DevinAlexander 1:b58719a76fc3 407 temperature_multi_byte=twosComplimentToSigned16(TC_MIN_VAL_FAULT*4.0f); //Convert the 2's compliment int into a signed value
DevinAlexander 1:b58719a76fc3 408
DevinAlexander 1:b58719a76fc3 409 //now split up the 32bit int into two bytes to program the registers with
DevinAlexander 1:b58719a76fc3 410 temperature_byte[0]=((uint8_t)((temperature_multi_byte)&(0xFF00) >> 8));
DevinAlexander 1:b58719a76fc3 411 temperature_byte[1]=((uint8_t)((temperature_multi_byte)&(0x00FF)));
DevinAlexander 1:b58719a76fc3 412
DevinAlexander 1:b58719a76fc3 413 return_val=registerWriteByte(ADDRESS_LTHFTH_WRITE, temperature_byte[0]);
DevinAlexander 1:b58719a76fc3 414 return_val=registerWriteByte(ADDRESS_LTHFTL_WRITE, temperature_byte[1]);
DevinAlexander 1:b58719a76fc3 415
DevinAlexander 1:b58719a76fc3 416 return_val=temperature;
DevinAlexander 0:456e9e702d57 417 }
DevinAlexander 1:b58719a76fc3 418 // else {
DevinAlexander 1:b58719a76fc3 419 // /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////return_val="WHATEVER IS IN THE REGISTERS WHEN YOU SET THE FLAG JUST INCASE YOU NEED TO SEE WHAT IS INSISIDE THE REGISTER";
DevinAlexander 1:b58719a76fc3 420 // }
DevinAlexander 0:456e9e702d57 421 }
DevinAlexander 1:b58719a76fc3 422 else if (val==MASK_TC_FAULT_THRESHOLD_LOW) //Thermocouple Low Threshold Fault Mask
DevinAlexander 1:b58719a76fc3 423 return_val=registerReadWriteByte(ADDRESS_MASK_READ, ADDRESS_MASK_WRITE, MASK_CLEAR_BITS_2, temp_val);
DevinAlexander 1:b58719a76fc3 424 else if (val==MASK_OVER_UNDER_VOLT_FAULT) //Over-Voltage/Under-Voltage Input Fault Mask
DevinAlexander 1:b58719a76fc3 425 return_val=registerReadWriteByte(ADDRESS_MASK_READ, ADDRESS_MASK_WRITE, MASK_CLEAR_BITS_1, temp_val);
DevinAlexander 1:b58719a76fc3 426 else if (val==MASK_OPEN_CIRCUIT_FAULT) //Thermocouple Open-Circuit Fault Mask
DevinAlexander 1:b58719a76fc3 427 return_val=registerReadWriteByte(ADDRESS_MASK_READ, ADDRESS_MASK_WRITE, MASK_CLEAR_BITS_0, temp_val);
DevinAlexander 1:b58719a76fc3 428 else {
DevinAlexander 1:b58719a76fc3 429 LOG("Incorrect parameter selected for MASK Register. Default value not changed.\r\nPlease see MAX31856.h for list of valid parameters. \r\n");
DevinAlexander 0:456e9e702d57 430 return_val=0; //returns a 0 to flag that the parameter wasn't programmed due to wrong parameter in function call
DevinAlexander 0:456e9e702d57 431 }
DevinAlexander 0:456e9e702d57 432 return return_val;
DevinAlexander 0:456e9e702d57 433 }
DevinAlexander 0:456e9e702d57 434
DevinAlexander 0:456e9e702d57 435
DevinAlexander 1:b58719a76fc3 436
DevinAlexander 1:b58719a76fc3 437
DevinAlexander 1:b58719a76fc3 438
DevinAlexander 1:b58719a76fc3 439
DevinAlexander 1:b58719a76fc3 440 //The following functions are for internal library use only
DevinAlexander 7:2e45068189b1 441 //******************************************************************************
DevinAlexander 7:2e45068189b1 442 void MAX31856::spiEnable()
DevinAlexander 7:2e45068189b1 443 {
DevinAlexander 7:2e45068189b1 444 ncs=0; //Set CS low to start transmission (interrupts conversion)
DevinAlexander 1:b58719a76fc3 445 return;
DevinAlexander 1:b58719a76fc3 446 }
DevinAlexander 1:b58719a76fc3 447
DevinAlexander 7:2e45068189b1 448
DevinAlexander 7:2e45068189b1 449 //******************************************************************************
DevinAlexander 7:2e45068189b1 450 void MAX31856::spiDisable()
DevinAlexander 7:2e45068189b1 451 {
DevinAlexander 7:2e45068189b1 452 ncs=1; //Set CS high to stop transmission (restarts conversion)
DevinAlexander 7:2e45068189b1 453 return;
DevinAlexander 7:2e45068189b1 454 }
DevinAlexander 7:2e45068189b1 455
DevinAlexander 7:2e45068189b1 456
DevinAlexander 7:2e45068189b1 457 //******************************************************************************
DevinAlexander 7:2e45068189b1 458 bool MAX31856::registerReadWriteByte(uint8_t read_address, uint8_t write_address, uint8_t clear_bits, uint8_t val)
DevinAlexander 7:2e45068189b1 459 {
DevinAlexander 1:b58719a76fc3 460 uint8_t buf_read[2];
DevinAlexander 1:b58719a76fc3 461
DevinAlexander 0:456e9e702d57 462 //Read the current contents of a register
DevinAlexander 0:456e9e702d57 463 spiEnable();
DevinAlexander 1:b58719a76fc3 464 for(int i=0; i<2; i++) {
DevinAlexander 1:b58719a76fc3 465 buf_read[i]=spi.write(read_address);
DevinAlexander 0:456e9e702d57 466 }
DevinAlexander 0:456e9e702d57 467 spiDisable();
DevinAlexander 1:b58719a76fc3 468
DevinAlexander 1:b58719a76fc3 469 //Modify contents pulled from the register
DevinAlexander 1:b58719a76fc3 470 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 471 buf_read[1]|=val; //Bitwise OR the input parameter with cleaned buf_read[1] to create new byte
DevinAlexander 0:456e9e702d57 472 val=buf_read[1];
DevinAlexander 1:b58719a76fc3 473
DevinAlexander 0:456e9e702d57 474 //Write the updated byte to the register
DevinAlexander 0:456e9e702d57 475 spiEnable();
DevinAlexander 1:b58719a76fc3 476 buf_read[0]=spi.write(write_address);
DevinAlexander 1:b58719a76fc3 477 buf_read[1]=spi.write(val);
DevinAlexander 1:b58719a76fc3 478 spiDisable();
DevinAlexander 1:b58719a76fc3 479 return true;
DevinAlexander 1:b58719a76fc3 480 }
DevinAlexander 1:b58719a76fc3 481
DevinAlexander 7:2e45068189b1 482
DevinAlexander 7:2e45068189b1 483 //******************************************************************************
DevinAlexander 7:2e45068189b1 484 bool MAX31856::registerWriteByte(uint8_t write_address, uint8_t val)
DevinAlexander 7:2e45068189b1 485 {
DevinAlexander 1:b58719a76fc3 486 //Write the updated byte to the register
DevinAlexander 1:b58719a76fc3 487 spiEnable();
DevinAlexander 3:a99a4367c909 488 spi.write(write_address);
DevinAlexander 3:a99a4367c909 489 spi.write(val);
DevinAlexander 0:456e9e702d57 490 spiDisable();
DevinAlexander 0:456e9e702d57 491 return true;
DevinAlexander 0:456e9e702d57 492 }
DevinAlexander 0:456e9e702d57 493
DevinAlexander 7:2e45068189b1 494
DevinAlexander 7:2e45068189b1 495 //******************************************************************************
DevinAlexander 7:2e45068189b1 496 int8_t MAX31856::twosComplimentToSigned8(int8_t temp)
DevinAlexander 7:2e45068189b1 497 {
DevinAlexander 1:b58719a76fc3 498 temp=(~(temp)+1); //Take two's complement of the negative number
DevinAlexander 1:b58719a76fc3 499 temp|=(int8_t)(0x80UL); //And convert it into 7-bit val with msb as sign bit
DevinAlexander 1:b58719a76fc3 500 return temp;
DevinAlexander 1:b58719a76fc3 501 }
DevinAlexander 7:2e45068189b1 502
DevinAlexander 7:2e45068189b1 503 //******************************************************************************
DevinAlexander 7:2e45068189b1 504 int16_t MAX31856::twosComplimentToSigned16(int16_t temp)
DevinAlexander 7:2e45068189b1 505 {
DevinAlexander 1:b58719a76fc3 506 temp=(~(temp)+1); //Take two's complement of the negative number
DevinAlexander 1:b58719a76fc3 507 temp|=(int16_t)(0x8000UL); //And convert it into 15-bit val with msb as sign bit
DevinAlexander 1:b58719a76fc3 508 return temp;
DevinAlexander 1:b58719a76fc3 509 }
DevinAlexander 1:b58719a76fc3 510
DevinAlexander 7:2e45068189b1 511
DevinAlexander 7:2e45068189b1 512 //******************************************************************************
DevinAlexander 7:2e45068189b1 513 MAX31856::~MAX31856(void)
DevinAlexander 7:2e45068189b1 514 {
DevinAlexander 7:2e45068189b1 515 //empty block
DevinAlexander 7:2e45068189b1 516 }
DevinAlexander 7:2e45068189b1 517
DevinAlexander 2:296485923589 518
DevinAlexander 1:b58719a76fc3 519 //bool MAX31856::checkForFaults() {
DevinAlexander 1:b58719a76fc3 520 //
DevinAlexander 1:b58719a76fc3 521 //}
DevinAlexander 1:b58719a76fc3 522
DevinAlexander 1:b58719a76fc3 523
DevinAlexander 0:456e9e702d57 524
DevinAlexander 0:456e9e702d57 525
DevinAlexander 1:b58719a76fc3 526 ///Define parameters for control register one (CR1)
DevinAlexander 1:b58719a76fc3 527 /** Adding Samples increases the conversion time and reduces noise.
DevinAlexander 1:b58719a76fc3 528 Typical conversion times:
DevinAlexander 1:b58719a76fc3 529 1-shot or first conversion in Auto mode:
DevinAlexander 1:b58719a76fc3 530 = t_Conversion + (samples-1)*33.33mS (60Hz rejection)
DevinAlexander 1:b58719a76fc3 531 = t_Conversion + (samples-1)*40.00mS (50Hz rejection)
DevinAlexander 1:b58719a76fc3 532 2 thru n conversions in Auto mode:
DevinAlexander 1:b58719a76fc3 533 = t_Conversion + (samples-1)*16.67mS (60Hz rejection)
DevinAlexander 1:b58719a76fc3 534 = t_Conversion + (samples-1)*20.00mS (50Hz rejection)
DevinAlexander 1:b58719a76fc3 535 */
DevinAlexander 1:b58719a76fc3 536
DevinAlexander 0:456e9e702d57 537
DevinAlexander 0:456e9e702d57 538
DevinAlexander 1:b58719a76fc3 539 //uint32_t MAX31856::calculateDelayTime() {
DevinAlexander 1:b58719a76fc3 540 // uint32_t delayTime;
DevinAlexander 1:b58719a76fc3 541 //
DevinAlexander 1:b58719a76fc3 542 // if (auto_convert_mode==1 && samples==1) { //single conversion
DevinAlexander 1:b58719a76fc3 543 // if (filter_mode==0) //60Hz
DevinAlexander 1:b58719a76fc3 544 // delayTime=82+(samples-1)*33.33f;
DevinAlexander 1:b58719a76fc3 545 // if (filter_mode==1) //50Hz
DevinAlexander 1:b58719a76fc3 546 // delayTime=98+(samples-1)*40.00f;
DevinAlexander 1:b58719a76fc3 547 // }
DevinAlexander 1:b58719a76fc3 548 // else if (auto_convert_mode==1 && samples>1) { //single conversion
DevinAlexander 1:b58719a76fc3 549 // if (filter_mode==0) //60Hz
DevinAlexander 1:b58719a76fc3 550 // delayTime=82+(samples-1)*33.33f;
DevinAlexander 1:b58719a76fc3 551 // if (filter_mode==1) //50Hz
DevinAlexander 1:b58719a76fc3 552 // delayTime=98+(samples-1)*40.00f;
DevinAlexander 1:b58719a76fc3 553 // }
DevinAlexander 1:b58719a76fc3 554 //
DevinAlexander 1:b58719a76fc3 555 //
DevinAlexander 1:b58719a76fc3 556 //
DevinAlexander 1:b58719a76fc3 557 //
DevinAlexander 1:b58719a76fc3 558 //auto 50 169
DevinAlexander 1:b58719a76fc3 559 //auto 60 143
DevinAlexander 1:b58719a76fc3 560 //1shot 50 98
DevinAlexander 1:b58719a76fc3 561 //1shot 60 82