Description

I would like to improve the sensitivity of the data acquisition system used in my homemade seismometer. I'm hoping circuit will deliver more than 21-bits (126.4 dB of dynamic range) to push the seismometer sensitivity below 10nm.

Details

Background:

My homemade seismometer uses a fully differential capacitance displacement sensor to detect the movement of the earth. The sensor interface is an AD7745 capacitance-to-digital converter. The AD7745 has some advantages:

It's easy to interface. It provides excitation drivers and can interface directly with a fully differential capacitance bridge.
It's low power -- less than 1mA supply current.
It uses the I2C interface for communication.
Relatively inexpensive at $11 or so in low quantities.

And disadvantages:

The AD7745 was released around 1995 and is showing its age relative to other high-bit ADC converters.
Advertised as a 24-bit converter, it can only really produce about 16-bits of noise free resolution.
Susceptible to EM interference because there is no input filtering.
It's not ratiometric. It relies on a 1.17V internal voltage reference.
Pretty poor tempco of the converted capacitance.

A chopper-stabilized sensor interface:

See the log files for all the details. The system uses a square wave modulator to drive the top and bottom of the capacitor sensor bridge between zero and VCC (the supply voltage). The maximum differential capacitance that the sensor can develop across the output is ±4pF when the displacement is ±5mm. At zero displacement all of the capacitors in the bridge are 2pF and the differential output capacitance is zero.

V(OUT+ - OUT-) = Vout = 2VCC ∆C/C1

If C1 = C2 = 10pF, Max Vout = ±0.8VCC.

If this output is fed to a 24-bit ADC using VCC for its reference (ratiometric conversion) then it should be able to produce a noise free resolution approaching 22bits (>130dB dynamic range). If theory matches reality then the capacitor sensor should be able to improve the displacement sensor performance by a factor of about 10x-30x, which would allow it to resolve displacements of less than 10nm. But that's still a long way from a professional instrument's capability.

This is the circuit I’ve designed to implement the concept.

The 100kHz clock generator for the modulation is a PIC10F202 — a 6 pin micro controller with an accurate internal clock. The exciters are driven by two Schmitt trigger inverters. The AC amplifiers are TP07 (or OPA376) opamps biased at TBD VCC. The SPDT switches are Vishay DG3157E -- which have low charge injection (<2pC).

I found a 24-bit sigma-delta ADC with decent noise performance — the MAX11200. When sampling at 245kHz (decimated to 5 Hz) the ADC is expected to have a noise free resolution of 21 bits — that’s a noise floor of 3.45µV p-p when using a 3.6V VREF ( input range = ±0.8VCC = 5.76V).

The LP2985 LDO has a bypass cap to reduce the noise on VCC. I'm pretty paranoid about noise on this circuit.

One last thing: This approach would lend itself to a force balance wide-bandwidth type seismometer.

Files

BOM.xls Bill of Materials spreadsheet ms-excel - 10.00 kB - 07/20/2019 at 14:17		Download
ChopperNulADC24.zip These are the Gerber files to create the 2-sided PCB. You can upload this zip file to OSH Park, or JLCPCB and get boards built. Zip Archive - 62.12 kB - 07/19/2019 at 21:18		Download
capsense-wp.pdf Baxter, L. K., "Capacitive Sensors", revised 2000-07-20. This is a nice treatise on interfacing to capacitance sensors. Chapter 5 covers signal conditioning circuitry. Adobe Portable Document Format - 127.25 kB - 05/31/2019 at 12:11	Preview	Download

Project Logs

Collapse logs

Software

Bud Bennett • 07/18/2019 at 20:36 • 0 comments

These code snippets are what I'm using to interface with the C2D. This first one is the class for the C2D converter. When instantiated it performs a self calibration for gain and offset. Otherwise, the user must customize it for use.

#!/usr/bin/env python3
#
#  Connections are:
#     CLK => SCLK  
#     DOUT =>  MISO
#     DIN => MOSI
#     CS => CE0

import time
import sys
import spidev
import math

class C2D:
    # commands
    SelfCalibration = 0x90
    SystemOffsetCal = 0xA0
    SystemGainCal = 0xB0
    Convert1p0 = 0x80
    Convert2p5 = 0x81
    Convert5p0 = 0x82
    Convert10 = 0x83
    # register addresses
    regSTAT = 0xC0
    regCTRL1 = 0xC2
    regCTRL2 = 0xC4
    regCTRL3 = 0xC6
    regDATA = 0xC8
    regSOC = 0xCA
    regSGC = 0xCC
    regSCOC = 0xCE
    regSCGC = 0xD0
    
    def __init__(self, debug=False):
        self.spi = spidev.SpiDev()
        self.spi.open(0,0)
        self.spi.max_speed_hz=(1000000)
        # Enable Self Calibration
        self.writeReg(self.regCTRL3,[0x18])
        time.sleep(0.1)
        # Performing System Self Calibration.
        self.command([self.SelfCalibration])
        time.sleep(0.3)

    
    def command(self, register):
        self.spi.xfer(register)
        return
    
    def writeReg(self, register, dataList):
        registerData = [register]
        for data in dataList:
            registerData.append(data)
        self.spi.xfer2(registerData)
                 
    def readReg(self, register, dataList):
        registerData = [register+1]
        for data in dataList:
            registerData.append(0)
        r = self.spi.xfer2(registerData)
        return r[-len(dataList):] # toss out the first byte

    def twosComplement(self,data):
        result = data[0] << 16 | data[1] << 8 | data[2]
        if result > (1 << 23) - 1:
            result = result - (1 << 24)
        return result
    
    def convert2volts(self, data):
        v = data/(2**23-1) * 3.6
        return v

    def readADC(self):
        r = self.readReg(self.regDATA,[0,0,0])
        return self.twosComplement(r)

    def readSelfCalOffset(self):
        r = self.readReg(self.regSCOC,[0,0,0])
        return self.twosComplement(r)

    def readSelfCalGain(self):
        r = self.readReg(self.regSCGC,[0,0,0])
        return self.twosComplement(r)/2**23

    def readSystemOffset(self):
        r = self.readReg(self.regSOC,[0,0,0])
        return int(self.twosComplement(r)/4)

    def readSystemGain(self):
        r = self.readReg(self.regSGC,[0,0,0])
        return self.twosComplement(r)
    
    def meanstdv(self, x):
        """
        Calculate mean and standard deviation of data x[]:
        mean = {\sum_i x_i \over n}
        std = math.sqrt(\sum_i (x_i - mean)^2 \over n-1)
        """
        n, mean, std = len(x), 0, 0
        for a in x:
            mean = mean + a
        mean = mean / float(n)
        for a in x:
            std = std + (a - mean)**2
        if(n > 1):
            std = math.sqrt(std / float(n-1))
        else:
            std = 0.0
        return mean, std

        
if __name__ == '__main__':
    
    # instantiate C2D
    cap2dig = C2D(debug=True)
    print("-1 = {0}".format(cap2dig.twosComplement([0xff,0xff,0xff])))
    print("1 = {0}".format(cap2dig.twosComplement([0x00,0x00,0x01])))
    # set CTRL3 register
    cap2dig.writeReg(cap2dig.regCTRL3,[0x18])
    CTRL3 = cap2dig.readReg(cap2dig.regCTRL3,[0])
    print("CTRL3 = {}".format(hex(CTRL3[0])))
    #config register: SCYCLE = 1, SIGBUF = 0
    cap2dig.writeReg(cap2dig.regCTRL1,[0x02])
    time.sleep(1)
    CTRL1 = cap2dig.readReg(cap2dig.regCTRL1, [0])
    print("CTRL1 = {}".format(hex(CTRL1[0])))
    print("Self Cal Offset = {0}".format(int(cap2dig.readSelfCalOffset())))
    print("Self Cal Gain = {0}".format(cap2dig.readSelfCalGain()))
    cap2dig.command([cap2dig.SystemOffsetCal])
    time.sleep(0.5)
    print("System Offset = {0}".format(cap2dig.readSystemOffset()))
    print("System Gain = {0}".format(cap2dig.readSystemGain()))
    
    result_array = []
    oldSTAT = 0x00
    n = 0
    sd_avg2 = float(0)
    try:
        while True:
            # start conversion
            cap2dig.command([cap2dig.Convert10])
            # wait for result
            time.sleep(0.11)
            STAT = cap2dig.readReg(cap2dig.regSTAT,[0])
            if (STAT != oldSTAT):
                print("STAT = {}".format(hex(STAT[0])))
                oldSTAT = STAT
            val = cap2dig.readADC()
            print ("ADC Result: {0}".format(int(val)))
            result_array.append(int(val))
            if (len(result_array) == 10):
                n += 1
                mean,sd = cap2dig.meanstdv(result_array)
                result_array = []
                print("\n\tmean: {0} Counts".format(mean))
                print("\tstd dev: {0:.4f} Counts".format(sd))
...

Debugging the ADC

Bud Bennett • 07/01/2019 at 19:30 • 0 comments

I had not used a SPI interface with the Raspberry Pi before starting on this circuit. The documentation for the Python implementation is sparse compared to what's available for C. It required a day of tinkering to obtain the first valid data from the ADC. I had to get my Rigol oscilloscope involved. After that things progressed quickly.

At first, the only data returned from the ADC was 0xFF. I found two things that needed understanding before the data would come. The Raspberry Pi has a wicked fast SPI interface. It was cruising along at more than 100MHz, but the poor ADC couldn't go faster than 5MHz, according to the spec. I had to slow it down with the following line of code, which sets the SCLK frequency at 1MHz.

spi.max_speed_hz=(1000000)

Now I could see square waves pinging between VDD and GND.

Next I determined that the SPI had to keep clocking data into the ADC after it was given a command byte in order to clock data out of the ADC and into the Raspberry Pi. There isn't a built-in read or write command for the SPI protocol -- it's doing both at the same time. So if you need to just write a single-byte command to start an ADC conversion it is pretty simple:

spi.xfer([Convert2p5])

If you need to read or write data from/to a register then the SPI must send a command byte followed by the required bytes for the read/write:

r = spi.xfer2([regDATA, 0, 0, 0]) # for a read

spi.xfer2([regSOC, 0x1f, 0xCA, 0x02]) # for a write

And the last thing to understand is that the data comes little-endian. For the read statement above, r is a list of 4 bytes, for example:

r = [0xff, 0x0f, 0x12, 0xD1]

r[0] can be tossed, r[1] is the MSB and r[3] is the LSB.

Here's the code that I cobbled together to get an understanding of the ADC:

#!/usr/bin/env python
#
# Bitbang'd SPI interface with an MCP3008 ADC device
# MCP3008 is 8-channel 10-bit analog to digital converter
#  Connections are:
#     CLK => SCLK  
#     DOUT =>  MISO
#     DIN => MOSI
#     CS => CE0

import time
import sys
import spidev
import math

SelfCalibration = 0x90
SystemOffsetCal = 0xA0
SystemGainCal = 0xB0
Convert2p5 = 0x81
regSTAT = 0xC0
regCTRL1 = 0xC2
regCTRL2 = 0xC4
regCTRL3 = 0xC6
regDATA = 0xC9
regSOC = 0xCA
regSGC = 0xCC


spi = spidev.SpiDev()
spi.open(0,0)
spi.max_speed_hz=(1000000)
#spi.mode = 0b11

def buildReadCommand(channel):
    startBit = 0x01
    singleEnded = 0x08
    
    return [startBit, singleEnded|(channel<<4), 0]
    
def processAdcValue(result):
    '''Take in result as array of three bytes. 
       Return the two lowest bits of the 2nd byte and
       all of the third byte'''
    byte2 = (result[1] & 0x03)
    return (byte2 << 8) | result[2]

def command(register):
    spi.xfer(register)
    return

def writeReg(register, dataList):
    registerData = [register]
    for data in dataList:
        registerData.append(data)
    spi.xfer2(registerData)
             
def readReg(register, dataList):
    registerData = [register+1]
    for data in dataList:
        registerData.append(data)
    r = spi.xfer2(registerData)
    return r
        
def readAdc():
    r = spi.xfer2([regDATA,0,0,0])
    result = r[1]*256*256 + r[2]*256 + r[3]
    if result > (2**23)-1:
        result = (result - 2**24)
    return result

def convert2volts(data):
    v = data/(2**23-1) * 3.6
    return v

def meanstdv(x):
    """
    Calculate mean and standard deviation of data x[]:
    mean = {\sum_i x_i \over n}
    std = math.sqrt(\sum_i (x_i - mean)^2 \over n-1)
    """
    n, mean, std = len(x), 0, 0
    for a in x:
        mean = mean + a
    mean = mean / float(n)
    for a in x:
        std = std + (a - mean)**2
    if(n > 1):
        std = math.sqrt(std / float(n-1))
    else:
        std = 0.0
    return mean, std

        
if __name__ == '__main__':
    writeReg(regSOC,[0,0,0])
    time.sleep(0.1)
    CTRL1 = readReg(regCTRL1, [0])
    print("CTRL1 = {}".format(hex(CTRL1[1])))
    CTRL3 = readReg(regCTRL3, [0])
    print("CTRL3 = {}".format(hex(CTRL3[1])))
    time.sleep(1)
    print("Enable Self Calibration")
    writeReg(regCTRL3,[0x18])
    time.sleep(1)
    CTRL3 = readReg(regCTRL3,[0])
    print("CTRL3 = {}".format(hex(CTRL3[1])))
 writeReg(regCTRL1,[...