A code for the spindling of bots.
Dependencies: MX12 ServoRingBuffer mbed-src
Fork of SpindleBot by
AD7730/AD7730.cpp@9:f26a91863e3a, 2015-05-12 (annotated)
- Committer:
- labmrd
- Date:
- Tue May 12 17:04:31 2015 +0000
- Revision:
- 9:f26a91863e3a
- Parent:
- 8:cef07a8bdc42
Rod and Trevor don't need John anymore. We are strong independent women who can code by ourselves. (We fixed calibration completely, added a CALIBRATE_TIME_NOW mode, calculate first touch of tissue to trigger end of grasp, and some other minor stuff)
Who changed what in which revision?
User | Revision | Line number | New contents of line |
---|---|---|---|
labmrd | 4:e44ac08027bd | 1 | #include "AD7730.h" |
labmrd | 4:e44ac08027bd | 2 | |
labmrd | 4:e44ac08027bd | 3 | /************************************************************************************************************************/ |
labmrd | 4:e44ac08027bd | 4 | //default constructor requires pin names for spi and ready pin |
labmrd | 4:e44ac08027bd | 5 | /************************************************************************************************************************/ |
labmrd | 4:e44ac08027bd | 6 | AD7730::AD7730(PinName mosi, PinName miso, PinName sclk, PinName ready, PinName cs) : _spi(mosi, miso, sclk), _cs(cs), _readyDig(ready), _LED3(LED3){ |
labmrd | 4:e44ac08027bd | 7 | |
labmrd | 4:e44ac08027bd | 8 | _readyPin = ready; |
labmrd | 4:e44ac08027bd | 9 | |
labmrd | 4:e44ac08027bd | 10 | //setup default parameters for spi |
labmrd | 4:e44ac08027bd | 11 | //_spi.format(8, 1); //8bits with polarity 0 (clock idle low), phase 1 (write on falling edge, read on rising edge) |
labmrd | 4:e44ac08027bd | 12 | //_spi.frequency(2000000); //2Mhz |
labmrd | 4:e44ac08027bd | 13 | |
labmrd | 4:e44ac08027bd | 14 | //set default setup |
labmrd | 4:e44ac08027bd | 15 | _minWeight = 1; |
labmrd | 4:e44ac08027bd | 16 | _maxWeight = 5; |
labmrd | 4:e44ac08027bd | 17 | _fullScaleWeight = 11.023; //5kgs |
labmrd | 4:e44ac08027bd | 18 | |
labmrd | 4:e44ac08027bd | 19 | //reset the device |
labmrd | 9:f26a91863e3a | 20 | reset(true); |
labmrd | 4:e44ac08027bd | 21 | |
labmrd | 4:e44ac08027bd | 22 | //get default registry values |
labmrd | 4:e44ac08027bd | 23 | _mode = readRegistry(MODE_REG); |
labmrd | 4:e44ac08027bd | 24 | _filter = readRegistry(FILTER_REG); |
labmrd | 4:e44ac08027bd | 25 | _dac = readRegistry(DAC_REG); |
labmrd | 4:e44ac08027bd | 26 | _offset = readRegistry(OFFSET_REG); |
labmrd | 4:e44ac08027bd | 27 | _gain = readRegistry(GAIN_REG); |
labmrd | 4:e44ac08027bd | 28 | |
labmrd | 4:e44ac08027bd | 29 | //set chip select high |
labmrd | 4:e44ac08027bd | 30 | _cs = 1; |
labmrd | 4:e44ac08027bd | 31 | |
labmrd | 4:e44ac08027bd | 32 | //run internal calibration |
labmrd | 9:f26a91863e3a | 33 | internalFullCal(); |
labmrd | 9:f26a91863e3a | 34 | internalZeroCal(); |
labmrd | 4:e44ac08027bd | 35 | |
labmrd | 4:e44ac08027bd | 36 | //turn off LED3 |
labmrd | 4:e44ac08027bd | 37 | _LED3 = false; |
labmrd | 4:e44ac08027bd | 38 | |
labmrd | 4:e44ac08027bd | 39 | |
labmrd | 4:e44ac08027bd | 40 | _continous = false; |
labmrd | 4:e44ac08027bd | 41 | |
labmrd | 4:e44ac08027bd | 42 | } |
labmrd | 4:e44ac08027bd | 43 | |
labmrd | 4:e44ac08027bd | 44 | /************************************************************************************************************************/ |
labmrd | 4:e44ac08027bd | 45 | // default destructor |
labmrd | 4:e44ac08027bd | 46 | /************************************************************************************************************************/ |
labmrd | 4:e44ac08027bd | 47 | AD7730::~AD7730(void){} |
labmrd | 4:e44ac08027bd | 48 | |
labmrd | 4:e44ac08027bd | 49 | void AD7730::dump(void){ |
labmrd | 4:e44ac08027bd | 50 | |
labmrd | 4:e44ac08027bd | 51 | //get default registry values |
labmrd | 4:e44ac08027bd | 52 | _mode = readRegistry(MODE_REG); |
labmrd | 4:e44ac08027bd | 53 | _filter = readRegistry(FILTER_REG); |
labmrd | 4:e44ac08027bd | 54 | _dac = readRegistry(DAC_REG); |
labmrd | 4:e44ac08027bd | 55 | _offset = readRegistry(OFFSET_REG); |
labmrd | 4:e44ac08027bd | 56 | _gain = readRegistry(GAIN_REG); |
labmrd | 4:e44ac08027bd | 57 | _status = readRegistry(STATUS_REG); |
labmrd | 4:e44ac08027bd | 58 | |
labmrd | 4:e44ac08027bd | 59 | printf("_mode=0x%04x\n",_mode); |
labmrd | 4:e44ac08027bd | 60 | printf("_filter=0x%06x\n",_filter); |
labmrd | 4:e44ac08027bd | 61 | printf("_dac=0x%02x\n",_dac); |
labmrd | 4:e44ac08027bd | 62 | printf("_offset=0x%06x\n",_offset); |
labmrd | 4:e44ac08027bd | 63 | printf("_gain=0x%06x\n",_gain); |
labmrd | 4:e44ac08027bd | 64 | printf("_status=0x%02x\n",_status); |
labmrd | 4:e44ac08027bd | 65 | } |
labmrd | 4:e44ac08027bd | 66 | |
labmrd | 4:e44ac08027bd | 67 | |
labmrd | 4:e44ac08027bd | 68 | /************************************************************************************************************************/ |
labmrd | 4:e44ac08027bd | 69 | //function to read the specified registry value |
labmrd | 4:e44ac08027bd | 70 | /************************************************************************************************************************/ |
labmrd | 4:e44ac08027bd | 71 | int AD7730::readRegistry(int registry){ |
labmrd | 4:e44ac08027bd | 72 | |
labmrd | 4:e44ac08027bd | 73 | int readReg = 0; |
labmrd | 4:e44ac08027bd | 74 | int bytes = 0; |
labmrd | 4:e44ac08027bd | 75 | |
labmrd | 4:e44ac08027bd | 76 | switch(registry){ |
labmrd | 4:e44ac08027bd | 77 | |
labmrd | 4:e44ac08027bd | 78 | case STATUS_REG: //status registry |
labmrd | 4:e44ac08027bd | 79 | { |
labmrd | 4:e44ac08027bd | 80 | readReg = 0x10; |
labmrd | 4:e44ac08027bd | 81 | bytes = 1; |
labmrd | 4:e44ac08027bd | 82 | break; |
labmrd | 4:e44ac08027bd | 83 | } |
labmrd | 4:e44ac08027bd | 84 | case DATA_REG: //data registry |
labmrd | 4:e44ac08027bd | 85 | { |
labmrd | 4:e44ac08027bd | 86 | _LED3 = _readyDig ? true : false; |
labmrd | 4:e44ac08027bd | 87 | readReg = 0x11; |
labmrd | 4:e44ac08027bd | 88 | bytes = 3; |
labmrd | 4:e44ac08027bd | 89 | break; |
labmrd | 4:e44ac08027bd | 90 | } |
labmrd | 4:e44ac08027bd | 91 | case MODE_REG: //mode registry |
labmrd | 4:e44ac08027bd | 92 | { |
labmrd | 4:e44ac08027bd | 93 | readReg = 0x12; |
labmrd | 4:e44ac08027bd | 94 | bytes = 2; |
labmrd | 4:e44ac08027bd | 95 | break; |
labmrd | 4:e44ac08027bd | 96 | } |
labmrd | 4:e44ac08027bd | 97 | case FILTER_REG: //filter registry |
labmrd | 4:e44ac08027bd | 98 | { |
labmrd | 4:e44ac08027bd | 99 | readReg = 0x13; |
labmrd | 4:e44ac08027bd | 100 | bytes = 3; |
labmrd | 4:e44ac08027bd | 101 | break; |
labmrd | 4:e44ac08027bd | 102 | } |
labmrd | 4:e44ac08027bd | 103 | case DAC_REG: //dac registry |
labmrd | 4:e44ac08027bd | 104 | { |
labmrd | 4:e44ac08027bd | 105 | readReg = 0x14; |
labmrd | 4:e44ac08027bd | 106 | bytes = 1; |
labmrd | 4:e44ac08027bd | 107 | break; |
labmrd | 4:e44ac08027bd | 108 | } |
labmrd | 4:e44ac08027bd | 109 | case OFFSET_REG: //offset registry |
labmrd | 4:e44ac08027bd | 110 | { |
labmrd | 4:e44ac08027bd | 111 | readReg = 0x15; |
labmrd | 4:e44ac08027bd | 112 | bytes = 3; |
labmrd | 4:e44ac08027bd | 113 | break; |
labmrd | 4:e44ac08027bd | 114 | } |
labmrd | 4:e44ac08027bd | 115 | case GAIN_REG: //gain registry |
labmrd | 4:e44ac08027bd | 116 | { |
labmrd | 4:e44ac08027bd | 117 | readReg = 0x16; |
labmrd | 4:e44ac08027bd | 118 | bytes = 3; |
labmrd | 4:e44ac08027bd | 119 | break; |
labmrd | 4:e44ac08027bd | 120 | } |
labmrd | 4:e44ac08027bd | 121 | case TEST_REG: //test registry |
labmrd | 4:e44ac08027bd | 122 | { |
labmrd | 4:e44ac08027bd | 123 | readReg = 0x17; |
labmrd | 4:e44ac08027bd | 124 | bytes = 3; |
labmrd | 4:e44ac08027bd | 125 | break; |
labmrd | 4:e44ac08027bd | 126 | } |
labmrd | 4:e44ac08027bd | 127 | default: //default to status registry |
labmrd | 4:e44ac08027bd | 128 | { |
labmrd | 4:e44ac08027bd | 129 | readReg = 0x10; |
labmrd | 4:e44ac08027bd | 130 | bytes = 1; |
labmrd | 4:e44ac08027bd | 131 | break; |
labmrd | 4:e44ac08027bd | 132 | } |
labmrd | 4:e44ac08027bd | 133 | } // end of switch statement |
labmrd | 4:e44ac08027bd | 134 | |
labmrd | 4:e44ac08027bd | 135 | //send command to read the registry |
labmrd | 4:e44ac08027bd | 136 | _cs = 0; |
labmrd | 4:e44ac08027bd | 137 | wait_us(5); |
labmrd | 4:e44ac08027bd | 138 | _spi.write(readReg); |
labmrd | 4:e44ac08027bd | 139 | |
labmrd | 4:e44ac08027bd | 140 | int value = 0; |
labmrd | 4:e44ac08027bd | 141 | //loop through bytes of returned data |
labmrd | 4:e44ac08027bd | 142 | for(int i=0; i<bytes; i++){ |
labmrd | 4:e44ac08027bd | 143 | value = (value << 8) | _spi.write(EMPTY_SPI); //shift previous return value up by 8 bits to make room for new data |
labmrd | 4:e44ac08027bd | 144 | } |
labmrd | 4:e44ac08027bd | 145 | wait_us(5); |
labmrd | 4:e44ac08027bd | 146 | _cs = 1; |
labmrd | 4:e44ac08027bd | 147 | |
labmrd | 4:e44ac08027bd | 148 | return value; |
labmrd | 4:e44ac08027bd | 149 | } |
labmrd | 4:e44ac08027bd | 150 | |
labmrd | 4:e44ac08027bd | 151 | /************************************************************************************************************************/ |
labmrd | 4:e44ac08027bd | 152 | //function to write to the specified registry |
labmrd | 4:e44ac08027bd | 153 | /************************************************************************************************************************/ |
labmrd | 4:e44ac08027bd | 154 | int AD7730::writeRegistry(int registry, int value){ |
labmrd | 4:e44ac08027bd | 155 | |
labmrd | 4:e44ac08027bd | 156 | int writeReg = 0; |
labmrd | 4:e44ac08027bd | 157 | int bytes = 0; |
labmrd | 4:e44ac08027bd | 158 | |
labmrd | 4:e44ac08027bd | 159 | switch(registry){ |
labmrd | 4:e44ac08027bd | 160 | |
labmrd | 4:e44ac08027bd | 161 | case MODE_REG: //mode registry |
labmrd | 4:e44ac08027bd | 162 | { |
labmrd | 4:e44ac08027bd | 163 | writeReg = 0x02; |
labmrd | 4:e44ac08027bd | 164 | bytes = 2; |
labmrd | 4:e44ac08027bd | 165 | _mode = value; |
labmrd | 4:e44ac08027bd | 166 | //check if continous converstion is being stopped or started |
labmrd | 4:e44ac08027bd | 167 | _continous = ((value & 0x2000) > 0)? true : false; |
labmrd | 4:e44ac08027bd | 168 | break; |
labmrd | 4:e44ac08027bd | 169 | } |
labmrd | 4:e44ac08027bd | 170 | case FILTER_REG: //filter registry |
labmrd | 4:e44ac08027bd | 171 | { |
labmrd | 4:e44ac08027bd | 172 | writeReg = 0x03; |
labmrd | 4:e44ac08027bd | 173 | bytes = 3; |
labmrd | 4:e44ac08027bd | 174 | _filter = value; |
labmrd | 4:e44ac08027bd | 175 | break; |
labmrd | 4:e44ac08027bd | 176 | } |
labmrd | 4:e44ac08027bd | 177 | case DAC_REG: //dac registry |
labmrd | 4:e44ac08027bd | 178 | { |
labmrd | 4:e44ac08027bd | 179 | writeReg = 0x04; |
labmrd | 4:e44ac08027bd | 180 | bytes = 1; |
labmrd | 4:e44ac08027bd | 181 | _dac = value; |
labmrd | 4:e44ac08027bd | 182 | break; |
labmrd | 4:e44ac08027bd | 183 | } |
labmrd | 4:e44ac08027bd | 184 | case OFFSET_REG: //offset registry |
labmrd | 4:e44ac08027bd | 185 | { |
labmrd | 4:e44ac08027bd | 186 | writeReg = 0x05; |
labmrd | 4:e44ac08027bd | 187 | bytes = 3; |
labmrd | 4:e44ac08027bd | 188 | _offset = value; |
labmrd | 4:e44ac08027bd | 189 | break; |
labmrd | 4:e44ac08027bd | 190 | } |
labmrd | 4:e44ac08027bd | 191 | case GAIN_REG: //gain registry |
labmrd | 4:e44ac08027bd | 192 | { |
labmrd | 4:e44ac08027bd | 193 | writeReg = 0x06; |
labmrd | 4:e44ac08027bd | 194 | bytes = 3; |
labmrd | 4:e44ac08027bd | 195 | _gain = value; |
labmrd | 4:e44ac08027bd | 196 | break; |
labmrd | 4:e44ac08027bd | 197 | } |
labmrd | 4:e44ac08027bd | 198 | default: //default to communications register |
labmrd | 4:e44ac08027bd | 199 | { |
labmrd | 4:e44ac08027bd | 200 | writeReg = 0x00; |
labmrd | 4:e44ac08027bd | 201 | bytes = 0; |
labmrd | 4:e44ac08027bd | 202 | break; |
labmrd | 4:e44ac08027bd | 203 | } |
labmrd | 4:e44ac08027bd | 204 | } // end of switch statement |
labmrd | 4:e44ac08027bd | 205 | |
labmrd | 4:e44ac08027bd | 206 | //send command to write to a the registry |
labmrd | 4:e44ac08027bd | 207 | _cs = 0; |
labmrd | 4:e44ac08027bd | 208 | wait_us(5); |
labmrd | 4:e44ac08027bd | 209 | _spi.write(writeReg); |
labmrd | 4:e44ac08027bd | 210 | |
labmrd | 4:e44ac08027bd | 211 | //send data |
labmrd | 4:e44ac08027bd | 212 | switch(bytes) |
labmrd | 4:e44ac08027bd | 213 | { |
labmrd | 4:e44ac08027bd | 214 | case 3: |
labmrd | 4:e44ac08027bd | 215 | _spi.write(((value >> 16) & 255)); |
labmrd | 4:e44ac08027bd | 216 | case 2: |
labmrd | 4:e44ac08027bd | 217 | _spi.write(((value >> 8) & 255)); |
labmrd | 4:e44ac08027bd | 218 | case 1: |
labmrd | 4:e44ac08027bd | 219 | _spi.write((value & 255)); |
labmrd | 4:e44ac08027bd | 220 | break; |
labmrd | 4:e44ac08027bd | 221 | default: |
labmrd | 4:e44ac08027bd | 222 | break; |
labmrd | 4:e44ac08027bd | 223 | } |
labmrd | 4:e44ac08027bd | 224 | wait_us(5); |
labmrd | 4:e44ac08027bd | 225 | _cs = 1; |
labmrd | 4:e44ac08027bd | 226 | |
labmrd | 4:e44ac08027bd | 227 | return value; |
labmrd | 4:e44ac08027bd | 228 | } |
labmrd | 4:e44ac08027bd | 229 | |
labmrd | 4:e44ac08027bd | 230 | |
labmrd | 4:e44ac08027bd | 231 | /************************************************************************************************************************/ |
labmrd | 4:e44ac08027bd | 232 | //function to initiate an internal full-scale calibration |
labmrd | 4:e44ac08027bd | 233 | /************************************************************************************************************************/ |
labmrd | 4:e44ac08027bd | 234 | int AD7730::internalFullCal(void){ |
labmrd | 4:e44ac08027bd | 235 | |
labmrd | 4:e44ac08027bd | 236 | //reset execution timer |
labmrd | 4:e44ac08027bd | 237 | _exeTmr.reset(); |
labmrd | 4:e44ac08027bd | 238 | |
labmrd | 4:e44ac08027bd | 239 | //1011000100110000 (0xB130) Internal Full-Scale Calibration, unipolar, long data, low reference, 0-80mv, channel 0 |
labmrd | 4:e44ac08027bd | 240 | writeRegistry(MODE_REG, 0xB130); |
labmrd | 4:e44ac08027bd | 241 | wait_us(1); //give time for ready line to go high |
labmrd | 4:e44ac08027bd | 242 | |
labmrd | 4:e44ac08027bd | 243 | //wait for ready pin to go low indicating calibration complete with timeout of 2000ms |
labmrd | 4:e44ac08027bd | 244 | int time = 0; |
labmrd | 4:e44ac08027bd | 245 | while(_readyDig && time < 2000){ |
labmrd | 4:e44ac08027bd | 246 | wait_ms(2); |
labmrd | 4:e44ac08027bd | 247 | time += 2; |
labmrd | 4:e44ac08027bd | 248 | } |
labmrd | 4:e44ac08027bd | 249 | |
labmrd | 4:e44ac08027bd | 250 | //update execution time |
labmrd | 4:e44ac08027bd | 251 | _exeTime = _exeTmr.read_us(); |
labmrd | 4:e44ac08027bd | 252 | |
labmrd | 4:e44ac08027bd | 253 | //check if timeout occurred |
labmrd | 4:e44ac08027bd | 254 | if(time >= 2000){ |
labmrd | 4:e44ac08027bd | 255 | _exeError = 56; |
labmrd | 4:e44ac08027bd | 256 | return 1; |
labmrd | 4:e44ac08027bd | 257 | } |
labmrd | 4:e44ac08027bd | 258 | else { |
labmrd | 4:e44ac08027bd | 259 | _exeError = 0; |
labmrd | 4:e44ac08027bd | 260 | return 0; |
labmrd | 4:e44ac08027bd | 261 | } |
labmrd | 4:e44ac08027bd | 262 | } |
labmrd | 4:e44ac08027bd | 263 | |
labmrd | 4:e44ac08027bd | 264 | |
labmrd | 4:e44ac08027bd | 265 | /************************************************************************************************************************/ |
labmrd | 4:e44ac08027bd | 266 | //function to initiate an internal zero-scale calibration |
labmrd | 4:e44ac08027bd | 267 | /************************************************************************************************************************/ |
labmrd | 4:e44ac08027bd | 268 | int AD7730::internalZeroCal(void){ |
labmrd | 4:e44ac08027bd | 269 | |
labmrd | 4:e44ac08027bd | 270 | //reset execution timer |
labmrd | 4:e44ac08027bd | 271 | _exeTmr.reset(); |
labmrd | 4:e44ac08027bd | 272 | |
labmrd | 4:e44ac08027bd | 273 | //1001000100110000 (0x9100) Internal Zero-Scale Calibration, unipolar, long data, low reference, 0-10mv, channel 0 |
labmrd | 4:e44ac08027bd | 274 | writeRegistry(MODE_REG, 0x9100); |
labmrd | 4:e44ac08027bd | 275 | wait_us(1); //give time for ready line to go high |
labmrd | 4:e44ac08027bd | 276 | |
labmrd | 4:e44ac08027bd | 277 | //wait for ready pin to go low indicating calibration complete with timeout of 2000ms |
labmrd | 4:e44ac08027bd | 278 | int time = 0; |
labmrd | 4:e44ac08027bd | 279 | while(_readyDig && time < 2000){ |
labmrd | 4:e44ac08027bd | 280 | wait_ms(2); |
labmrd | 4:e44ac08027bd | 281 | time += 2; |
labmrd | 4:e44ac08027bd | 282 | } |
labmrd | 4:e44ac08027bd | 283 | |
labmrd | 4:e44ac08027bd | 284 | //update execution time |
labmrd | 4:e44ac08027bd | 285 | _exeTime = _exeTmr.read_us(); |
labmrd | 4:e44ac08027bd | 286 | |
labmrd | 4:e44ac08027bd | 287 | //check if timeout occurred |
labmrd | 4:e44ac08027bd | 288 | if(time >= 2000){ |
labmrd | 4:e44ac08027bd | 289 | _exeError = 56; |
labmrd | 4:e44ac08027bd | 290 | return 1; |
labmrd | 4:e44ac08027bd | 291 | } |
labmrd | 4:e44ac08027bd | 292 | else { |
labmrd | 4:e44ac08027bd | 293 | _exeError = 0; |
labmrd | 4:e44ac08027bd | 294 | return 0; |
labmrd | 4:e44ac08027bd | 295 | } |
labmrd | 4:e44ac08027bd | 296 | } |
labmrd | 4:e44ac08027bd | 297 | |
labmrd | 4:e44ac08027bd | 298 | |
labmrd | 4:e44ac08027bd | 299 | |
labmrd | 4:e44ac08027bd | 300 | /************************************************************************************************************************/ |
labmrd | 4:e44ac08027bd | 301 | //function to initialize the chip settings to default values after power up and to run internal calibration |
labmrd | 4:e44ac08027bd | 302 | /************************************************************************************************************************/ |
labmrd | 4:e44ac08027bd | 303 | int AD7730::initialize(void){ |
labmrd | 4:e44ac08027bd | 304 | |
labmrd | 4:e44ac08027bd | 305 | //reset device |
labmrd | 4:e44ac08027bd | 306 | reset(true); //initate a full reset |
labmrd | 4:e44ac08027bd | 307 | |
labmrd | 4:e44ac08027bd | 308 | systemLowCal(_minWeight); |
labmrd | 4:e44ac08027bd | 309 | |
labmrd | 4:e44ac08027bd | 310 | //set the Offset |
labmrd | 4:e44ac08027bd | 311 | writeRegistry(OFFSET_REG, _offset); |
labmrd | 4:e44ac08027bd | 312 | |
labmrd | 4:e44ac08027bd | 313 | //set the Gain |
labmrd | 4:e44ac08027bd | 314 | writeRegistry(GAIN_REG, _gain); |
labmrd | 4:e44ac08027bd | 315 | |
labmrd | 4:e44ac08027bd | 316 | //set the DAC |
labmrd | 4:e44ac08027bd | 317 | writeRegistry(DAC_REG, _dac); |
labmrd | 4:e44ac08027bd | 318 | |
labmrd | 4:e44ac08027bd | 319 | return 0; |
labmrd | 4:e44ac08027bd | 320 | |
labmrd | 4:e44ac08027bd | 321 | } |
labmrd | 4:e44ac08027bd | 322 | |
labmrd | 4:e44ac08027bd | 323 | |
labmrd | 4:e44ac08027bd | 324 | /************************************************************************************************************************/ |
labmrd | 4:e44ac08027bd | 325 | //function to initiate a system zero-scale calibration |
labmrd | 4:e44ac08027bd | 326 | /************************************************************************************************************************/ |
labmrd | 4:e44ac08027bd | 327 | int AD7730::systemLowCal(double wgt){ |
labmrd | 4:e44ac08027bd | 328 | |
labmrd | 4:e44ac08027bd | 329 | //set minimum weight for low calibration |
labmrd | 4:e44ac08027bd | 330 | _minWeight = wgt; |
labmrd | 4:e44ac08027bd | 331 | |
labmrd | 4:e44ac08027bd | 332 | |
labmrd | 4:e44ac08027bd | 333 | //1101000100000000 (0xD100) System Zero-Scale Calibration, unipolar, long data, low reference, 0-10mv, channel 0 |
labmrd | 4:e44ac08027bd | 334 | int mode = 0xD100; |
labmrd | 4:e44ac08027bd | 335 | |
labmrd | 4:e44ac08027bd | 336 | writeRegistry(MODE_REG, mode); |
labmrd | 4:e44ac08027bd | 337 | |
labmrd | 4:e44ac08027bd | 338 | wait_us(1); //give time for ready pin to go high |
labmrd | 4:e44ac08027bd | 339 | int time = 0; |
labmrd | 4:e44ac08027bd | 340 | while(_readyDig && time < 2000){ |
labmrd | 4:e44ac08027bd | 341 | time += 2; |
labmrd | 4:e44ac08027bd | 342 | wait_ms(2); |
labmrd | 4:e44ac08027bd | 343 | }//wait for ready pin to go low |
labmrd | 4:e44ac08027bd | 344 | |
labmrd | 4:e44ac08027bd | 345 | if(_readyDig){ |
labmrd | 4:e44ac08027bd | 346 | //printf("External Zero Failed\r\n"); |
labmrd | 4:e44ac08027bd | 347 | } |
labmrd | 4:e44ac08027bd | 348 | |
labmrd | 4:e44ac08027bd | 349 | return (time >= 2000) ? 1 : 0; |
labmrd | 4:e44ac08027bd | 350 | |
labmrd | 4:e44ac08027bd | 351 | } |
labmrd | 4:e44ac08027bd | 352 | |
labmrd | 4:e44ac08027bd | 353 | |
labmrd | 4:e44ac08027bd | 354 | /************************************************************************************************************************/ |
labmrd | 4:e44ac08027bd | 355 | //function to initiate a system high calibration |
labmrd | 4:e44ac08027bd | 356 | /************************************************************************************************************************/ |
labmrd | 4:e44ac08027bd | 357 | int AD7730::systemHighCal(double max, double fullScale){ |
labmrd | 4:e44ac08027bd | 358 | |
labmrd | 4:e44ac08027bd | 359 | //get the current offset value |
labmrd | 4:e44ac08027bd | 360 | int offset = readRegistry(OFFSET_REG); |
labmrd | 4:e44ac08027bd | 361 | int fullScaleAdjust = ((double)offset - 8388608) + 16777215; |
labmrd | 4:e44ac08027bd | 362 | fullScaleAdjust /= 2; |
labmrd | 4:e44ac08027bd | 363 | //double calFactor = fullScale / (fullScaleAdjust / 2); //dual load cells splits the weight in half |
labmrd | 4:e44ac08027bd | 364 | |
labmrd | 4:e44ac08027bd | 365 | //set maximum weight for high calibration |
labmrd | 4:e44ac08027bd | 366 | _maxWeight = max; |
labmrd | 4:e44ac08027bd | 367 | //calculate the expected value for the maximum weight based on the full scale of the load cell |
labmrd | 4:e44ac08027bd | 368 | double expected = ((fullScaleAdjust * max) / fullScale); |
labmrd | 4:e44ac08027bd | 369 | |
labmrd | 4:e44ac08027bd | 370 | //take some samples |
labmrd | 4:e44ac08027bd | 371 | double avg = 0; |
labmrd | 4:e44ac08027bd | 372 | double value = 0; |
labmrd | 4:e44ac08027bd | 373 | for(int i=0; i<20; i++){ |
labmrd | 4:e44ac08027bd | 374 | value = (double)read(); |
labmrd | 4:e44ac08027bd | 375 | avg += value; |
labmrd | 4:e44ac08027bd | 376 | } |
labmrd | 4:e44ac08027bd | 377 | |
labmrd | 4:e44ac08027bd | 378 | avg = avg / 20; |
labmrd | 4:e44ac08027bd | 379 | |
labmrd | 4:e44ac08027bd | 380 | //get current gain setting |
labmrd | 4:e44ac08027bd | 381 | double gain = (double)readRegistry(GAIN_REG); |
labmrd | 4:e44ac08027bd | 382 | |
labmrd | 4:e44ac08027bd | 383 | //calculate new gain value |
labmrd | 4:e44ac08027bd | 384 | double adjustedGain = gain * (expected / avg); |
labmrd | 4:e44ac08027bd | 385 | |
labmrd | 4:e44ac08027bd | 386 | printf("Expected: %.3f\r\nActual: %.3f\r\n", expected, avg); |
labmrd | 4:e44ac08027bd | 387 | |
labmrd | 4:e44ac08027bd | 388 | int err = 0; |
labmrd | 4:e44ac08027bd | 389 | if(adjustedGain > 16777215){ |
labmrd | 4:e44ac08027bd | 390 | //printf("Exceeded Maximum Gain Value\r\n"); |
labmrd | 4:e44ac08027bd | 391 | err = 1; |
labmrd | 4:e44ac08027bd | 392 | } |
labmrd | 4:e44ac08027bd | 393 | |
labmrd | 4:e44ac08027bd | 394 | //update gain registry |
labmrd | 4:e44ac08027bd | 395 | writeRegistry(GAIN_REG, (int)adjustedGain); |
labmrd | 4:e44ac08027bd | 396 | |
labmrd | 4:e44ac08027bd | 397 | return err; |
labmrd | 4:e44ac08027bd | 398 | } |
labmrd | 4:e44ac08027bd | 399 | |
labmrd | 4:e44ac08027bd | 400 | |
labmrd | 4:e44ac08027bd | 401 | |
labmrd | 4:e44ac08027bd | 402 | /************************************************************************************************************************/ |
labmrd | 4:e44ac08027bd | 403 | //function to initiate the conversion of a sample |
labmrd | 4:e44ac08027bd | 404 | /************************************************************************************************************************/ |
labmrd | 4:e44ac08027bd | 405 | int AD7730::startConversion(bool wait){ |
labmrd | 4:e44ac08027bd | 406 | |
labmrd | 4:e44ac08027bd | 407 | //set the mode to do a single conversion |
labmrd | 4:e44ac08027bd | 408 | //5432109876543210 |
labmrd | 4:e44ac08027bd | 409 | //0100000100000000 (0x4100) Single Conversion, bipolar, short data, low reference, 0-10mv, channel 0 |
labmrd | 4:e44ac08027bd | 410 | int mode = 0x4100; |
labmrd | 4:e44ac08027bd | 411 | |
labmrd | 4:e44ac08027bd | 412 | writeRegistry(MODE_REG, mode); |
labmrd | 4:e44ac08027bd | 413 | |
labmrd | 4:e44ac08027bd | 414 | if(wait){ |
labmrd | 4:e44ac08027bd | 415 | //wait for conversion to complete |
labmrd | 4:e44ac08027bd | 416 | |
labmrd | 4:e44ac08027bd | 417 | wait_us(1); //give time for ready to go high*/ |
labmrd | 4:e44ac08027bd | 418 | |
labmrd | 4:e44ac08027bd | 419 | int time = 0; |
labmrd | 4:e44ac08027bd | 420 | while(_readyDig && time < 2000000){ |
labmrd | 4:e44ac08027bd | 421 | time += 2; |
labmrd | 4:e44ac08027bd | 422 | wait_us(2); |
labmrd | 4:e44ac08027bd | 423 | }//wait for ready pin to go low.*/ |
labmrd | 4:e44ac08027bd | 424 | |
labmrd | 4:e44ac08027bd | 425 | if(time >= 2000000){ |
labmrd | 4:e44ac08027bd | 426 | printf("Convert Timeout\r\n"); |
labmrd | 4:e44ac08027bd | 427 | _exeError = 56; |
labmrd | 4:e44ac08027bd | 428 | return 1; |
labmrd | 4:e44ac08027bd | 429 | } |
labmrd | 4:e44ac08027bd | 430 | } |
labmrd | 4:e44ac08027bd | 431 | |
labmrd | 4:e44ac08027bd | 432 | return 0; |
labmrd | 4:e44ac08027bd | 433 | } |
labmrd | 4:e44ac08027bd | 434 | |
labmrd | 4:e44ac08027bd | 435 | /************************************************************************************************************************/ |
labmrd | 4:e44ac08027bd | 436 | //function to do a single read with conversion |
labmrd | 4:e44ac08027bd | 437 | /************************************************************************************************************************/ |
labmrd | 4:e44ac08027bd | 438 | int AD7730::read(){ |
labmrd | 4:e44ac08027bd | 439 | |
labmrd | 4:e44ac08027bd | 440 | if(_continous){ |
labmrd | 4:e44ac08027bd | 441 | //chip is running in continous conversion mode |
labmrd | 4:e44ac08027bd | 442 | return _lastValue; |
labmrd | 4:e44ac08027bd | 443 | } |
labmrd | 4:e44ac08027bd | 444 | else { |
labmrd | 4:e44ac08027bd | 445 | //a new conversion must be started |
labmrd | 4:e44ac08027bd | 446 | if(startConversion(true)==1){ |
labmrd | 4:e44ac08027bd | 447 | return 0; |
labmrd | 4:e44ac08027bd | 448 | } |
labmrd | 4:e44ac08027bd | 449 | return readRegistry(DATA_REG); |
labmrd | 4:e44ac08027bd | 450 | } |
labmrd | 4:e44ac08027bd | 451 | } |
labmrd | 4:e44ac08027bd | 452 | |
labmrd | 4:e44ac08027bd | 453 | |
labmrd | 4:e44ac08027bd | 454 | /************************************************************************************************************************/ |
labmrd | 4:e44ac08027bd | 455 | //function to set the filter settings |
labmrd | 4:e44ac08027bd | 456 | /************************************************************************************************************************/ |
labmrd | 4:e44ac08027bd | 457 | void AD7730::setFilter(int SF, bool chop, int filter2){ |
labmrd | 4:e44ac08027bd | 458 | |
labmrd | 4:e44ac08027bd | 459 | SF = SF << 12; //slide SF settings up 12 bits |
labmrd | 4:e44ac08027bd | 460 | |
labmrd | 4:e44ac08027bd | 461 | switch(filter2){ |
labmrd | 4:e44ac08027bd | 462 | case 2: |
labmrd | 4:e44ac08027bd | 463 | SF = SF | 512; //turn on bit 10 for skip mode |
labmrd | 4:e44ac08027bd | 464 | break; |
labmrd | 4:e44ac08027bd | 465 | case 1: |
labmrd | 4:e44ac08027bd | 466 | SF = SF | 256; //turn on bit 09 for fast mode |
labmrd | 4:e44ac08027bd | 467 | break; |
labmrd | 4:e44ac08027bd | 468 | default: |
labmrd | 4:e44ac08027bd | 469 | break; //leave bits 9 & 10 off so secondary filter is fully enabled |
labmrd | 4:e44ac08027bd | 470 | } |
labmrd | 4:e44ac08027bd | 471 | |
labmrd | 4:e44ac08027bd | 472 | if(chop){ |
labmrd | 4:e44ac08027bd | 473 | SF = SF | 16; //turn on bit 5 to enable chop mode |
labmrd | 4:e44ac08027bd | 474 | } |
labmrd | 4:e44ac08027bd | 475 | |
labmrd | 4:e44ac08027bd | 476 | writeRegistry(FILTER_REG,SF); |
labmrd | 4:e44ac08027bd | 477 | |
labmrd | 4:e44ac08027bd | 478 | } |
labmrd | 4:e44ac08027bd | 479 | |
labmrd | 4:e44ac08027bd | 480 | /************************************************************************************************************************/ |
labmrd | 4:e44ac08027bd | 481 | //function to reset the chip |
labmrd | 4:e44ac08027bd | 482 | /************************************************************************************************************************/ |
labmrd | 4:e44ac08027bd | 483 | void AD7730::reset(bool fullReset){ |
labmrd | 4:e44ac08027bd | 484 | |
labmrd | 4:e44ac08027bd | 485 | _cs = 0; |
labmrd | 4:e44ac08027bd | 486 | wait_us(5); |
labmrd | 4:e44ac08027bd | 487 | _spi.write(0xFF); |
labmrd | 4:e44ac08027bd | 488 | _spi.write(0xFF); |
labmrd | 4:e44ac08027bd | 489 | _spi.write(0xFF); |
labmrd | 4:e44ac08027bd | 490 | _spi.write(0xFF); |
labmrd | 4:e44ac08027bd | 491 | _spi.write(0xFF); |
labmrd | 4:e44ac08027bd | 492 | wait_us(5); |
labmrd | 4:e44ac08027bd | 493 | _cs = 1; |
labmrd | 4:e44ac08027bd | 494 | |
labmrd | 4:e44ac08027bd | 495 | //if not a full reset, then reload registry settings |
labmrd | 4:e44ac08027bd | 496 | if(!fullReset){ |
labmrd | 4:e44ac08027bd | 497 | writeRegistry(MODE_REG, _mode); |
labmrd | 4:e44ac08027bd | 498 | writeRegistry(FILTER_REG, _filter); |
labmrd | 4:e44ac08027bd | 499 | writeRegistry(DAC_REG, _dac); |
labmrd | 4:e44ac08027bd | 500 | writeRegistry(OFFSET_REG, _offset); |
labmrd | 4:e44ac08027bd | 501 | writeRegistry(GAIN_REG, _gain); |
labmrd | 4:e44ac08027bd | 502 | } |
labmrd | 4:e44ac08027bd | 503 | else { |
labmrd | 4:e44ac08027bd | 504 | //reinitiate internal calibration |
labmrd | 4:e44ac08027bd | 505 | internalFullCal(); |
labmrd | 4:e44ac08027bd | 506 | wait_ms(100); |
labmrd | 4:e44ac08027bd | 507 | internalZeroCal(); |
labmrd | 4:e44ac08027bd | 508 | wait_ms(100); |
labmrd | 4:e44ac08027bd | 509 | } |
labmrd | 4:e44ac08027bd | 510 | } |
labmrd | 4:e44ac08027bd | 511 | |
labmrd | 4:e44ac08027bd | 512 | /************************************************************************************************************************/ |
labmrd | 4:e44ac08027bd | 513 | //function to adjust the DAC |
labmrd | 4:e44ac08027bd | 514 | /************************************************************************************************************************/ |
labmrd | 4:e44ac08027bd | 515 | int AD7730::adjustDAC(int direction){ |
labmrd | 4:e44ac08027bd | 516 | |
labmrd | 4:e44ac08027bd | 517 | int DAC = readRegistry(DAC_REG); |
labmrd | 4:e44ac08027bd | 518 | int sign = DAC & 32; //get the sign bit |
labmrd | 4:e44ac08027bd | 519 | DAC &= 31; //remove sign bit |
labmrd | 4:e44ac08027bd | 520 | |
labmrd | 4:e44ac08027bd | 521 | |
labmrd | 4:e44ac08027bd | 522 | if(direction > 0){ |
labmrd | 4:e44ac08027bd | 523 | //increment DAC |
labmrd | 4:e44ac08027bd | 524 | if((sign > 0) && (DAC == 1)){ //sign bit is set and DAC is already at 1 change to 0; |
labmrd | 4:e44ac08027bd | 525 | DAC = 0; |
labmrd | 4:e44ac08027bd | 526 | sign = 0; |
labmrd | 4:e44ac08027bd | 527 | } |
labmrd | 4:e44ac08027bd | 528 | else if((sign == 0) && (DAC >= 0)){ //sign bit is not set increment DAC |
labmrd | 4:e44ac08027bd | 529 | DAC++; |
labmrd | 4:e44ac08027bd | 530 | } |
labmrd | 4:e44ac08027bd | 531 | else if ((sign > 0) && (DAC > 0)){ //sign bit is set decrement DAC because it is negative |
labmrd | 4:e44ac08027bd | 532 | DAC--; |
labmrd | 4:e44ac08027bd | 533 | } |
labmrd | 4:e44ac08027bd | 534 | |
labmrd | 4:e44ac08027bd | 535 | } |
labmrd | 4:e44ac08027bd | 536 | |
labmrd | 4:e44ac08027bd | 537 | else if(direction < 0){ |
labmrd | 4:e44ac08027bd | 538 | //decrement DAC |
labmrd | 4:e44ac08027bd | 539 | if((sign == 0) && (DAC == 0)){ //sign bit is not set and DAC is already at 0 |
labmrd | 4:e44ac08027bd | 540 | DAC = 1; |
labmrd | 4:e44ac08027bd | 541 | sign = 1; |
labmrd | 4:e44ac08027bd | 542 | } |
labmrd | 4:e44ac08027bd | 543 | else if((sign == 0) && (DAC > 0)){ //sign bit is not set increment DAC |
labmrd | 4:e44ac08027bd | 544 | DAC--; |
labmrd | 4:e44ac08027bd | 545 | } |
labmrd | 4:e44ac08027bd | 546 | else if ((sign > 0) && (DAC >= 0)){ //sign bit is set decrement DAC because it is negative |
labmrd | 4:e44ac08027bd | 547 | DAC++; |
labmrd | 4:e44ac08027bd | 548 | } |
labmrd | 4:e44ac08027bd | 549 | |
labmrd | 4:e44ac08027bd | 550 | } |
labmrd | 4:e44ac08027bd | 551 | |
labmrd | 4:e44ac08027bd | 552 | else{ |
labmrd | 4:e44ac08027bd | 553 | //no change in direction |
labmrd | 4:e44ac08027bd | 554 | //do nothing |
labmrd | 4:e44ac08027bd | 555 | return DAC; |
labmrd | 4:e44ac08027bd | 556 | } |
labmrd | 4:e44ac08027bd | 557 | |
labmrd | 4:e44ac08027bd | 558 | if(DAC > 31){ |
labmrd | 4:e44ac08027bd | 559 | DAC = 31; //limit DAC to maximum value of 31 (5 bits) |
labmrd | 4:e44ac08027bd | 560 | } |
labmrd | 4:e44ac08027bd | 561 | |
labmrd | 4:e44ac08027bd | 562 | if(sign > 0){ |
labmrd | 4:e44ac08027bd | 563 | DAC |= 32; //set the sign bit of DAC |
labmrd | 4:e44ac08027bd | 564 | } |
labmrd | 4:e44ac08027bd | 565 | |
labmrd | 4:e44ac08027bd | 566 | //update DAC |
labmrd | 4:e44ac08027bd | 567 | writeRegistry(DAC_REG, DAC); |
labmrd | 4:e44ac08027bd | 568 | |
labmrd | 4:e44ac08027bd | 569 | return DAC; |
labmrd | 4:e44ac08027bd | 570 | } |
labmrd | 4:e44ac08027bd | 571 | |
labmrd | 4:e44ac08027bd | 572 | /************************************************************************************************************************/ |
labmrd | 4:e44ac08027bd | 573 | //function to set the filtering SF setting |
labmrd | 4:e44ac08027bd | 574 | /************************************************************************************************************************/ |
labmrd | 4:e44ac08027bd | 575 | void AD7730::setFilterSF(int sf){ |
labmrd | 4:e44ac08027bd | 576 | |
labmrd | 4:e44ac08027bd | 577 | //get current filter setting |
labmrd | 4:e44ac08027bd | 578 | int filter = readRegistry(FILTER_REG); |
labmrd | 4:e44ac08027bd | 579 | |
labmrd | 4:e44ac08027bd | 580 | //clear sf bits |
labmrd | 4:e44ac08027bd | 581 | filter &= 0xFFF; |
labmrd | 4:e44ac08027bd | 582 | |
labmrd | 4:e44ac08027bd | 583 | //bitshift sf up by 12 bits |
labmrd | 4:e44ac08027bd | 584 | sf = sf << 12; |
labmrd | 4:e44ac08027bd | 585 | |
labmrd | 4:e44ac08027bd | 586 | //or sf bits with filter bits |
labmrd | 4:e44ac08027bd | 587 | filter = filter | sf; |
labmrd | 4:e44ac08027bd | 588 | |
labmrd | 4:e44ac08027bd | 589 | //apply new filter setting |
labmrd | 4:e44ac08027bd | 590 | writeRegistry(FILTER_REG, filter); |
labmrd | 4:e44ac08027bd | 591 | } |
labmrd | 4:e44ac08027bd | 592 | |
labmrd | 4:e44ac08027bd | 593 | /************************************************************************************************************************/ |
labmrd | 4:e44ac08027bd | 594 | //function to set the filtering chop mode |
labmrd | 4:e44ac08027bd | 595 | /************************************************************************************************************************/ |
labmrd | 4:e44ac08027bd | 596 | void AD7730::setFilterChop(int enabled){ |
labmrd | 4:e44ac08027bd | 597 | |
labmrd | 4:e44ac08027bd | 598 | //get current filter setting |
labmrd | 4:e44ac08027bd | 599 | int filter = readRegistry(FILTER_REG); |
labmrd | 4:e44ac08027bd | 600 | |
labmrd | 4:e44ac08027bd | 601 | //clear bit 5 |
labmrd | 4:e44ac08027bd | 602 | filter &= ~0x10; |
labmrd | 4:e44ac08027bd | 603 | |
labmrd | 4:e44ac08027bd | 604 | //apply chop setting |
labmrd | 4:e44ac08027bd | 605 | if(enabled) |
labmrd | 4:e44ac08027bd | 606 | filter |= 0x10; |
labmrd | 4:e44ac08027bd | 607 | |
labmrd | 4:e44ac08027bd | 608 | //apply new filter setting |
labmrd | 4:e44ac08027bd | 609 | writeRegistry(FILTER_REG, filter); |
labmrd | 4:e44ac08027bd | 610 | } |
labmrd | 4:e44ac08027bd | 611 | |
labmrd | 4:e44ac08027bd | 612 | /************************************************************************************************************************/ |
labmrd | 4:e44ac08027bd | 613 | //function to set the mode of the second filter |
labmrd | 4:e44ac08027bd | 614 | /************************************************************************************************************************/ |
labmrd | 4:e44ac08027bd | 615 | void AD7730::setFilterMode(int mode){ |
labmrd | 4:e44ac08027bd | 616 | |
labmrd | 4:e44ac08027bd | 617 | //get current filter setting |
labmrd | 4:e44ac08027bd | 618 | int filter = readRegistry(FILTER_REG); |
labmrd | 4:e44ac08027bd | 619 | |
labmrd | 4:e44ac08027bd | 620 | //clear bits 9 & 10 |
labmrd | 4:e44ac08027bd | 621 | filter &= ~0x300; |
labmrd | 4:e44ac08027bd | 622 | |
labmrd | 4:e44ac08027bd | 623 | //apply mode setting |
labmrd | 4:e44ac08027bd | 624 | if(mode == 1){ |
labmrd | 4:e44ac08027bd | 625 | filter |= 0x100; //apply fast mode |
labmrd | 4:e44ac08027bd | 626 | } |
labmrd | 4:e44ac08027bd | 627 | else if(mode == 2){ |
labmrd | 4:e44ac08027bd | 628 | filter |= 0x200; //apply skip mode |
labmrd | 4:e44ac08027bd | 629 | } |
labmrd | 4:e44ac08027bd | 630 | else { |
labmrd | 4:e44ac08027bd | 631 | //leave both bits unset |
labmrd | 4:e44ac08027bd | 632 | } |
labmrd | 4:e44ac08027bd | 633 | |
labmrd | 4:e44ac08027bd | 634 | |
labmrd | 4:e44ac08027bd | 635 | //apply new filter setting |
labmrd | 4:e44ac08027bd | 636 | writeRegistry(FILTER_REG, filter); |
labmrd | 4:e44ac08027bd | 637 | } |
labmrd | 4:e44ac08027bd | 638 | |
labmrd | 4:e44ac08027bd | 639 | /************************************************************************************************************************/ |
labmrd | 4:e44ac08027bd | 640 | //function to set the chip to continous conversion |
labmrd | 4:e44ac08027bd | 641 | /************************************************************************************************************************/ |
labmrd | 4:e44ac08027bd | 642 | void AD7730::start(void){ |
labmrd | 4:e44ac08027bd | 643 | |
labmrd | 4:e44ac08027bd | 644 | writeRegistry(MODE_REG, 0x2100); //set to continous conversion mode |
labmrd | 4:e44ac08027bd | 645 | //_interruptReady = new InterruptIn(_readyPin); |
labmrd | 4:e44ac08027bd | 646 | //_interruptReady->fall(this, &AD7730::interruptRead); |
labmrd | 4:e44ac08027bd | 647 | _continous = true; //set flag indicating that chip is running in continous mode |
labmrd | 4:e44ac08027bd | 648 | } |
labmrd | 4:e44ac08027bd | 649 | |
labmrd | 4:e44ac08027bd | 650 | /************************************************************************************************************************/ |
labmrd | 4:e44ac08027bd | 651 | //function to stop the chip running in continous conversion mode |
labmrd | 4:e44ac08027bd | 652 | /************************************************************************************************************************/ |
labmrd | 4:e44ac08027bd | 653 | void AD7730::stop(void){ |
labmrd | 4:e44ac08027bd | 654 | |
labmrd | 4:e44ac08027bd | 655 | writeRegistry(MODE_REG, 0x1100); //set to idle mode |
labmrd | 4:e44ac08027bd | 656 | |
labmrd | 4:e44ac08027bd | 657 | _interruptReady = NULL; |
labmrd | 4:e44ac08027bd | 658 | |
labmrd | 4:e44ac08027bd | 659 | } |
labmrd | 4:e44ac08027bd | 660 | |
labmrd | 4:e44ac08027bd | 661 | /************************************************************************************************************************/ |
labmrd | 4:e44ac08027bd | 662 | //function to check if the ready digital line is low |
labmrd | 4:e44ac08027bd | 663 | /************************************************************************************************************************/ |
labmrd | 4:e44ac08027bd | 664 | bool AD7730::isReady(void){ |
labmrd | 4:e44ac08027bd | 665 | |
labmrd | 4:e44ac08027bd | 666 | //if digital line is high, return not ready |
labmrd | 4:e44ac08027bd | 667 | return (_readyDig)? false : true; |
labmrd | 4:e44ac08027bd | 668 | |
labmrd | 4:e44ac08027bd | 669 | } |
labmrd | 4:e44ac08027bd | 670 | |
labmrd | 4:e44ac08027bd | 671 | /************************************************************************************************************************/ |
labmrd | 4:e44ac08027bd | 672 | //function to read data on falling edge of ready pin when running in continous conversion mode |
labmrd | 4:e44ac08027bd | 673 | /************************************************************************************************************************/ |
labmrd | 4:e44ac08027bd | 674 | void AD7730::interruptRead(void){ |
labmrd | 4:e44ac08027bd | 675 | |
labmrd | 4:e44ac08027bd | 676 | |
labmrd | 4:e44ac08027bd | 677 | _lastValue = readRegistry(DATA_REG); |
labmrd | 4:e44ac08027bd | 678 | |
labmrd | 4:e44ac08027bd | 679 | } |