Revision 0:c584a588c24f, committed 2011-12-16

Comitter:

cfscontrols2

Date:

Fri Dec 16 20:31:01 2011 +0000

Commit message:

Changed in this revision

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/AD7730.cpp	Fri Dec 16 20:31:01 2011 +0000
@@ -0,0 +1,684 @@
+#include "AD7730.h"
+
+/************************************************************************************************************************/
+//default constructor requires pin names for spi and ready pin
+/************************************************************************************************************************/
+AD7730::AD7730(PinName mosi, PinName miso, PinName sclk, PinName ready, PinName cs) : _spi(mosi, miso, sclk), _cs(cs), _readyDig(ready), _LED3(LED3){
+    
+    _readyPin = ready;
+      
+    //setup default parameters for spi
+    _spi.format(8, 1);  //8bits with polarity 0 (clock idle low), phase 1 (write on falling edge, read on rising edge)
+    _spi.frequency(1000000); //2Mhz
+    
+    //set default setup
+    _minWeight = 1;
+    _maxWeight = 5;
+    _fullScaleWeight = 11.023; //5kgs
+    
+    //reset the device
+    reset(true);
+    
+    //get default registry values
+    _mode = readRegistry(MODE_REG);
+    _filter = readRegistry(FILTER_REG);
+    _dac = readRegistry(DAC_REG);
+    _offset = readRegistry(OFFSET_REG);
+    _gain = readRegistry(GAIN_REG);
+    
+    //set chip select high
+    _cs = 1; 
+    
+    //run internal calibration
+    internalFullCal();
+    internalZeroCal(); 
+    
+    //turn off LED3
+    _LED3 = false; 
+    
+
+    _continous = false;
+    _bufferCount = 0;
+    memset(_readBuffer, 0, 100);
+      
+}
+
+/************************************************************************************************************************/
+// default destructor
+/************************************************************************************************************************/
+AD7730::~AD7730(void){}
+
+
+
+
+/************************************************************************************************************************/
+//function to read the specified registry value
+/************************************************************************************************************************/
+int AD7730::readRegistry(int registry){
+
+    int readReg = 0;
+    int bytes = 0;
+    
+    switch(registry){
+    
+        case STATUS_REG: //status registry
+        {   
+            readReg = 0x10;
+            bytes = 1;
+            break;
+        }
+        case DATA_REG: //data registry
+        {
+            _LED3 = _readyDig ? true : false;
+            readReg = 0x11;
+            bytes = 3;
+            break;
+        }
+        case MODE_REG: //mode registry
+        {
+            readReg = 0x12;
+            bytes = 2;
+            break;
+        }
+        case FILTER_REG: //filter registry
+        {
+            readReg = 0x13;
+            bytes = 3;
+            break;
+        }
+        case DAC_REG: //dac registry
+        {
+            readReg = 0x14;
+            bytes = 1;
+            break;
+        }
+        case OFFSET_REG: //offset registry
+        {
+            readReg = 0x15;
+            bytes = 3;
+            break;
+        }
+        case GAIN_REG: //gain registry
+        {
+            readReg = 0x16;
+            bytes = 3;
+            break;
+        }
+        case TEST_REG: //test registry
+        {
+            readReg = 0x17;
+            bytes = 3;
+            break;
+        }
+        default: //default to status registry
+        {
+            readReg = 0x10;
+            bytes = 1;
+            break;
+        }
+    } // end of switch statement
+    
+    //send command to read the registry
+    _cs = 0; 
+    wait_us(5);
+    _spi.write(readReg);
+    
+    int value = 0;
+    //loop through bytes of returned data
+    for(int i=0; i<bytes; i++){
+        value = (value << 8) | _spi.write(EMPTY_SPI); //shift previous return value up by 8 bits to make room for new data
+    }
+    wait_us(5);
+    _cs = 1;
+    
+    return value;
+}
+
+/************************************************************************************************************************/
+//function to write to the specified registry
+/************************************************************************************************************************/
+int AD7730::writeRegistry(int registry, int value){
+
+    int writeReg = 0;
+    int bytes = 0;
+    
+    switch(registry){
+    
+        case MODE_REG: //mode registry
+        {
+            writeReg = 0x02;
+            bytes = 2;
+            _mode = value;
+            //check if continous converstion is being stopped or started
+            _continous = ((value & 0x2000) > 0)? true : false;
+            break;
+        }
+        case FILTER_REG: //filter registry
+        {
+            writeReg = 0x03;
+            bytes = 3;
+            _filter = value;
+            break;
+        }
+        case DAC_REG: //dac registry
+        {
+            writeReg = 0x04;
+            bytes = 1;
+            _dac = value;
+            break;
+        }
+        case OFFSET_REG: //offset registry
+        {
+            writeReg = 0x05;
+            bytes = 3;
+            _offset = value;
+            break;
+        }
+        case GAIN_REG: //gain registry
+        {
+            writeReg = 0x06;
+            bytes = 3;
+            _gain = value;
+            break;
+        }
+        default: //default to communications register
+        {
+            writeReg = 0x00;
+            bytes = 0;
+            break;
+        }
+    } // end of switch statement
+    
+    //send command to write to a the registry
+    _cs = 0;
+    wait_us(5);
+    _spi.write(writeReg);
+    
+    //send data
+    switch(bytes)
+    {
+        case 3:
+            _spi.write(((value >> 16) & 255));
+        case 2:
+            _spi.write(((value >> 8) & 255));
+        case 1:
+            _spi.write((value & 255));
+            break;
+        default:
+            break;
+    }
+    wait_us(5);
+    _cs = 1;
+    
+    return value;
+}
+
+
+/************************************************************************************************************************/
+//function to initiate an internal full-scale calibration
+/************************************************************************************************************************/
+int AD7730::internalFullCal(void){
+    
+    //reset execution timer
+    _exeTmr.reset();
+
+    //1011000100110000 (0xB130) Internal Full-Scale Calibration, unipolar, long data, low reference, 0-80mv, channel 0
+    writeRegistry(MODE_REG, 0xB130);
+    wait_us(1); //give time for ready line to go high
+    
+    //wait for ready pin to go low indicating calibration complete with timeout of 2000ms
+    int time = 0;
+    while(_readyDig && time < 2000){
+        wait_ms(2);
+        time += 2;
+    }
+    
+    //update execution time
+    _exeTime = _exeTmr.read_us();
+    
+    //check if timeout occurred
+    if(time >= 2000){
+        _exeError = 56;
+        return 1;
+    }
+    else {
+        _exeError = 0;
+        return 0;
+    } 
+}
+
+
+/************************************************************************************************************************/
+//function to initiate an internal zero-scale calibration
+/************************************************************************************************************************/
+int AD7730::internalZeroCal(void){
+    
+    //reset execution timer
+    _exeTmr.reset();
+
+    //1001000100110000 (0x9100) Internal Zero-Scale Calibration, unipolar, long data, low reference, 0-10mv, channel 0
+    writeRegistry(MODE_REG, 0x9100);
+    wait_us(1); //give time for ready line to go high
+    
+    //wait for ready pin to go low indicating calibration complete with timeout of 2000ms
+    int time = 0;
+    while(_readyDig && time < 2000){
+        wait_ms(2);
+        time += 2;
+    }
+    
+    //update execution time
+    _exeTime = _exeTmr.read_us();
+    
+    //check if timeout occurred
+    if(time >= 2000){
+        _exeError = 56;
+        return 1;
+    }
+    else {
+        _exeError = 0;
+        return 0;
+    } 
+}
+
+
+
+/************************************************************************************************************************/
+//function to initialize the chip settings to default values after power up and to run internal calibration
+/************************************************************************************************************************/
+int AD7730::initialize(void){
+
+    //reset device
+    reset(true); //initate a full reset
+    
+    systemLowCal(_minWeight);
+    
+    //set the Offset
+    writeRegistry(OFFSET_REG, _offset);
+    
+    //set the Gain
+    writeRegistry(GAIN_REG, _gain);
+    
+    //set the DAC
+    writeRegistry(DAC_REG, _dac); 
+    
+    return 0;   
+     
+}
+
+
+/************************************************************************************************************************/
+//function to initiate a system zero-scale calibration
+/************************************************************************************************************************/
+int AD7730::systemLowCal(double wgt){
+    
+    //set minimum weight for low calibration
+    _minWeight = wgt;
+    
+    
+    //1101000100000000 (0xD100) System Zero-Scale Calibration, unipolar, long data, low reference, 0-10mv, channel 0
+    int mode = 0xD100;
+    
+    writeRegistry(MODE_REG, mode);
+    
+    wait_us(1);  //give time for ready pin to go high
+    int time = 0;
+    while(_readyDig && time < 2000){
+        time += 2;
+        wait_ms(2);
+    }//wait for ready pin to go low     
+    
+    if(_readyDig){
+        //printf("External Zero Failed\r\n");
+    }
+    
+    return (time >= 2000) ? 1 : 0;
+    
+}
+
+
+/************************************************************************************************************************/
+//function to initiate a system high calibration
+/************************************************************************************************************************/
+int AD7730::systemHighCal(double max, double fullScale){
+    
+    //get the current offset value
+    int offset = readRegistry(OFFSET_REG);
+    int fullScaleAdjust = ((double)offset - 8388608) + 16777215;
+    fullScaleAdjust /= 2;
+    //double calFactor = fullScale / (fullScaleAdjust / 2); //dual load cells splits the weight in half
+    
+    //set maximum weight for high calibration
+    _maxWeight = max;
+    //calculate the expected value for the maximum weight based on the full scale of the load cell
+    double expected = ((fullScaleAdjust * max) / fullScale);
+    
+    //take some samples
+    double avg = 0;
+    double value = 0;
+    for(int i=0; i<20; i++){
+        value = (double)read();
+        avg += value;  
+    }
+    
+    avg = avg / 20;
+    
+    //get current gain setting
+    double gain = (double)readRegistry(GAIN_REG);
+    
+    //calculate new gain value
+    double adjustedGain = gain * (expected / avg);
+    
+    printf("Expected: %.3f\r\nActual: %.3f\r\n", expected, avg);
+    
+    int err = 0;
+    if(adjustedGain > 16777215){
+        //printf("Exceeded Maximum Gain Value\r\n");
+        err = 1;
+    }
+    
+    //update gain registry
+    writeRegistry(GAIN_REG, (int)adjustedGain);
+    
+    return err;
+}
+
+
+
+/************************************************************************************************************************/
+//function to initiate the conversion of a sample
+/************************************************************************************************************************/
+int AD7730::startConversion(bool wait){
+    
+    //set the mode to do a single conversion
+    //0101000100000000 (0x5000)  Single Conversion, unipolar, short data, low reference, 0-10mv, channel 0
+    int mode = 0x5100;
+
+    writeRegistry(MODE_REG, mode);
+    
+    if(wait){
+        //wait for conversion to complete
+         
+        wait_us(1); //give time for ready to go high*/
+    
+        int time = 0;
+        while(_readyDig && time < 2000000){
+            time += 2;
+            wait_us(2);
+        }//wait for ready pin to go low.*/
+        
+        if(time >= 2000000){
+            //printf("Convert Timeout\r\n");
+            _exeError = 56;
+            return 1;
+        }
+    }
+    
+    return 0;
+}
+
+/************************************************************************************************************************/
+//function to do a single read with conversion
+/************************************************************************************************************************/
+int AD7730::read(){
+
+    if(_continous){
+        //chip is running in continous conversion mode
+        return _lastValue;
+    }
+    else {
+        //a new conversion must be started
+        startConversion(true);
+        return readRegistry(DATA_REG);
+    }              
+}
+
+
+/************************************************************************************************************************/
+//function to set the filter settings
+/************************************************************************************************************************/
+void AD7730::setFilter(int SF, bool chop, int filter2){
+    
+    SF = SF << 12; //slide SF settings up 12 bits
+    
+    switch(filter2){
+        case 2:
+            SF = SF | 512;  //turn on bit 10 for skip mode
+            break;
+        case 1:
+            SF = SF | 256; //turn on bit 09 for fast mode
+            break;
+        default:
+            break; //leave bits 9 & 10 off so secondary filter is fully enabled
+    }
+    
+    if(chop){
+        SF = SF | 16; //turn on bit 5 to enable chop mode
+    }
+    
+    writeRegistry(FILTER_REG,SF);
+    
+}
+
+/************************************************************************************************************************/
+//function to reset the chip
+/************************************************************************************************************************/
+void AD7730::reset(bool fullReset){
+    
+    _cs = 0;
+    wait_us(5);
+    _spi.write(0xFF);
+    _spi.write(0xFF);
+    _spi.write(0xFF);
+    _spi.write(0xFF);
+    _spi.write(0xFF);
+    wait_us(5);
+    _cs = 1;
+    
+    //if not a full reset, then reload registry settings
+    if(!fullReset){
+        writeRegistry(MODE_REG, _mode);
+        writeRegistry(FILTER_REG, _filter);
+        writeRegistry(DAC_REG, _dac);
+        writeRegistry(OFFSET_REG, _offset);
+        writeRegistry(GAIN_REG, _gain);
+    }
+    else {
+        //reinitiate internal calibration
+        internalFullCal();
+        wait_ms(100);
+        internalZeroCal();
+        wait_ms(100);
+    }
+}
+
+/************************************************************************************************************************/
+//function to adjust the DAC
+/************************************************************************************************************************/
+int AD7730::adjustDAC(int direction){
+
+    int DAC = readRegistry(DAC_REG);
+    int sign = DAC & 32; //get the sign bit
+    DAC &= 31; //remove sign bit 
+ 
+    
+    if(direction > 0){
+        //increment DAC
+        if((sign > 0) && (DAC == 1)){ //sign bit is set and DAC is already at 1 change to 0;
+            DAC = 0;
+            sign = 0;
+        }
+        else if((sign == 0) && (DAC >= 0)){  //sign bit is not set increment DAC
+            DAC++;
+        }
+        else if ((sign > 0) && (DAC > 0)){  //sign bit is set decrement DAC because it is negative
+            DAC--;
+        }
+        
+    }
+    
+   else if(direction < 0){
+        //decrement DAC
+        if((sign == 0) && (DAC == 0)){ //sign bit is not set and DAC is already at 0
+            DAC = 1;
+            sign = 1;
+        }
+        else if((sign == 0) && (DAC > 0)){  //sign bit is not set increment DAC
+            DAC--;
+        }
+        else if ((sign > 0) && (DAC >= 0)){  //sign bit is set decrement DAC because it is negative
+            DAC++;
+        }
+        
+    }    
+
+    else{
+        //no change in direction
+        //do nothing
+        return DAC;
+    }
+    
+    if(DAC > 31){
+        DAC = 31;  //limit DAC to maximum value of 31 (5 bits)
+    }
+    
+    if(sign > 0){
+        DAC |= 32; //set the sign bit of DAC
+    }
+    
+    //update DAC
+    writeRegistry(DAC_REG, DAC);
+    
+    return DAC;
+}
+
+/************************************************************************************************************************/
+//function to set the filtering SF setting
+/************************************************************************************************************************/
+void AD7730::setFilterSF(int sf){
+
+    //get current filter setting
+    int filter = readRegistry(FILTER_REG);
+    
+    //clear sf bits 
+    filter &= 0xFFF;
+    
+    //bitshift sf up by 12 bits
+    sf = sf << 12;
+    
+    //or sf bits with filter bits
+    filter = filter | sf;
+    
+    //apply new filter setting
+    writeRegistry(FILTER_REG, filter);
+}
+
+/************************************************************************************************************************/
+//function to set the filtering chop mode
+/************************************************************************************************************************/
+void AD7730::setFilterChop(int enabled){
+
+    //get current filter setting
+    int filter = readRegistry(FILTER_REG);
+    
+    //clear bit 5 
+    filter &= ~0x10;
+    
+    //apply chop setting
+    if(enabled)
+        filter |= 0x10;
+    
+    //apply new filter setting
+    writeRegistry(FILTER_REG, filter);
+}
+
+/************************************************************************************************************************/
+//function to set the mode of the second filter
+/************************************************************************************************************************/
+void AD7730::setFilterMode(int mode){
+
+    //get current filter setting
+    int filter = readRegistry(FILTER_REG);
+    
+    //clear bits 9 & 10 
+    filter &= ~0x300;
+    
+    //apply mode setting
+    if(mode == 1){
+        filter |= 0x100; //apply fast mode
+    }
+    else if(mode == 2){
+        filter |= 0x200; //apply skip mode
+    }
+    else {
+        //leave both bits unset
+    }
+    
+    
+    //apply new filter setting
+    writeRegistry(FILTER_REG, filter);
+}
+
+/************************************************************************************************************************/
+//function to set the chip to continous conversion
+/************************************************************************************************************************/
+void AD7730::start(void){
+    
+    writeRegistry(MODE_REG, 0x3100); //set to continous conversion mode
+    _interruptReady = new InterruptIn(_readyPin);
+    _tmr.start();
+    _frequency = 0;
+    _interruptReady->fall(this, &AD7730::interruptRead);  
+}
+
+/************************************************************************************************************************/
+//function to stop the chip running in continous conversion mode
+/************************************************************************************************************************/
+void AD7730::stop(void){
+    
+    writeRegistry(MODE_REG, 0x1100); //set to idle mode
+    
+    _interruptReady = NULL;
+  
+}
+
+/************************************************************************************************************************/
+//function to check if the ready digital line is low
+/************************************************************************************************************************/
+bool AD7730::isReady(void){
+     
+    //if digital line is high, return not ready  
+    return (_readyDig)? false : true;
+    
+}
+
+/************************************************************************************************************************/
+//function to read data on falling edge of ready pin when running in continous conversion mode
+/************************************************************************************************************************/
+void AD7730::interruptRead(void){
+
+    _continous = true; //set flag indicating that chip is running in continous mode
+    
+    _lastValue = readRegistry(DATA_REG);
+    
+    //store data in circular buffer
+    _readBuffer[_bufferCount] = _lastValue;
+    if(_bufferCount < 99){
+        _bufferCount++;
+    }
+    else {
+        _bufferCount = 0;
+    }
+    
+    //update conversion speed frequency
+    _frequency = _tmr.read_us();
+    _tmr.reset();
+}
+
+/************************************************************************************************************************/
+//function to return the hertz of the data conversion 
+/************************************************************************************************************************/
+double AD7730::getHz(void){
+
+    return (1000000 / (double)_frequency);
+}
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/AD7730.h	Fri Dec 16 20:31:01 2011 +0000
@@ -0,0 +1,85 @@
+#ifndef AD7730_H
+#define AD7730_H
+
+#include "mbed.h"
+
+class AD7730{
+
+    public:
+        AD7730(PinName mosi, PinName miso, PinName sclk, PinName ready, PinName cs);
+        ~AD7730(void);
+        
+        int readRegistry(int registry);
+        int writeRegistry(int registry, int value);
+        int initialize(void);
+        int systemLowCal(double wgt);
+        int systemHighCal(double wgt, double fullScale);
+        int read();
+        int startConversion(bool wait); 
+        void setFilter(int SF, bool chop, int filter2);
+        void setFilterSF(int SF);
+        void setFilterMode(int mode);
+        void setFilterChop(int enabled);
+        void reset(bool fullReset);
+        int adjustDAC(int direction);
+        void start(void);
+        void stop(void);
+        bool isReady(void);
+        double getHz(void);
+
+    
+    private:
+    
+        SPI _spi;
+        DigitalOut _cs;
+        DigitalIn _readyDig;
+        DigitalOut _LED3;
+        InterruptIn *_interruptReady;
+        PinName  _readyPin;
+        double _fullScaleWeight;
+        double _minWeight;
+        double _maxWeight;
+        int _readBuffer[100];
+        int _bufferCount;
+        int _lastValue;
+        bool _continous;
+        int _frequency;
+        Timer _tmr;
+        
+        //Registry value constants
+        static const int STATUS_REG = 0;
+        static const int DATA_REG = 1;
+        static const int MODE_REG = 2;
+        static const int FILTER_REG = 3;
+        static const int DAC_REG = 4;
+        static const int OFFSET_REG = 5;
+        static const int GAIN_REG = 6;
+        static const int TEST_REG = 7;
+        
+        //define empty spi command
+        static const int EMPTY_SPI = 0xFF;
+        
+        //internal registries
+        int _mode;
+        int _filter;
+        int _dac;
+        int _offset;
+        int _gain;
+        
+        
+        //timing variables
+        Timer _exeTmr;
+        int _exeTime;
+        
+        //error variables
+        int _exeError;
+        
+        //private functions
+        int internalZeroCal(void);
+        int internalFullCal(void); 
+        void interruptRead(void);       
+        
+        
+};
+
+#endif