MRD Lab / SpindleBot_1_5b

A code for the spindling of bots.

Dependencies:   MX12 ServoRingBuffer mbed-src

Fork of SpindleBot by MRD Lab

AD7730/AD7730.cpp@14:7c5beaa9fb01, 2015-08-13 (annotated)

Committer:
labmrd
Date:
Thu Aug 13 17:55:40 2015 +0000
Revision:
14:7c5beaa9fb01
Parent:
9:f26a91863e3a 
This revision marks Mark's mark of resignation from the labmrd mbed account.

Who changed what in which revision?

UserRevisionLine numberNew 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 }