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

Committer:
DevinAlexander
Date:
Wed Jul 26 18:46:23 2017 +0000
Revision:
2:296485923589
Parent:
1:b58719a76fc3
Child:
3:a99a4367c909
before fixing the LOGs

Who changed what in which revision?

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