Dangerous Prototypes Open Source Hardware

// Demo Code to read Microchip MCP3424 18-bit ADC on Arduino / JeeNode   
// see also PCB page http://jeelabs.net/projects/hardware/wiki/Analog_Plug
// and MCP3424 datasheet http://ww1.microchip.com/downloads/en/devicedoc/22088c.pdf
// by JBeale  (John Beale 2010, updated 2013)

#include <JeeLib.h> // sensor library from https://github.com/jcw/jeelib

PortI2C myI2C (3);  // JeeNode Port 3, see http://jeelabs.org/2009/09/16/jeenode-pinout/
DeviceI2C adc (myI2C, 0x68);  // 0x68 or other address codes set on A0/A1 pins
// No solder links (A0,A1 both open, or both low) = 0x68 see p.20-21, MCP3424 datasheet

static void AP2init (DeviceI2C& dev, byte mode) {    
    dev.send();
    dev.write(mode);
    dev.stop();
}

// 'mode' = MCP3424 8-bit configuration register
// see sec. 5.2 Configuration Register, p. 18 of datasheet
// b7  b6  b5  b4    b3  b2  b1  b0  ----- (bit number)
// RDY C1  C0  O/C   S1  S0  G1  G0  ----- (bit name)
// --------------------------------
// RDY = 0 when ready (or in one-shot, write '1' to start conversion)
// C1/C0: input channel # 00 = 0, 01 = 1, 10 = 2, 11 = 3
// O/C: 1 = continuous conversion mode, 0 =  single-shot conversion
// S1/S0: rate: 00 = 240 Hz (12 b), 01 = 60 Hz (14 b) 10 = 15 Hz (16 b) 11 = 3.75 Hz (18 b)
// G1/G0: gain: 00 = x1, 01 = x2, 10 = x4, 11 = x8    FullScale: 2.048 V, 1.024, 0.512, 0.256

// 0001 1100  0x1C is channel 0, continuous, 18-bit, gain x1
// 0011 1100  0x3C is channel 1, continuous, 18-bit, gain x1

static long AP2read (DeviceI2C& dev) {
    dev.receive();
    long raw = (long) dev.read(0) << 16;
    raw |= (word) dev.read(0) << 8;
    raw |= dev.read(0);
    byte status = adc.read(1);  // throw away "status" result
    return (raw * 1000) / 64;   // not sure if correct for negative readings.
            // need different scaling if PGA gain setting changed from x1
}

void setup () {
    Serial.begin(57600);
    Serial.println("18-bit ADC test");
    AP2init(adc, 0x1C); // 0x1c = channel 1, continuous, 18-bit, gain x1 (FS = +2.048 V)
    //    AP2init(adc, 0x1E); // chan 1, continuous, 18-bit, gain x8 (FS = +0.256 V)  
    delay(300);  // wait long enough for 1 sample to complete
}

void loop () {
long val;
unsigned long time;

    time = millis() / 1000;  // seconds since reset
    Serial.print(time); // time in seconds
    Serial.print(","); 
    AP2init(adc, 0x1C); // chan 1, continuous, 18-bit, gain x1
    delay(300);  // wait for sample to complete
    val = AP2read(adc);
    Serial.println(val);  // ADC reading
}

Hello from Mitch and Tully! We're two hackers from Australia and the USA who have moved to Shenzhen China. Why Shenzhen? Because Shenzhen has the world's largest electronics market! Here's what we can do:

    Make PCBs to your specifications.
    Give you a quote on the parts for your latest project.

Parts that we quote on are added to the store, so you can order them there if you like the quote.

# Teensy 3.0 @ 96 MHz
# Samples/sec: 2246.69 Avg: 43582.86 Offset: 19.94 P-P noise: 7 St.Dev: 0.944
# Samples/sec: 2245.68 Avg: 43583.17 Offset: 20.25 P-P noise: 8 St.Dev: 0.938
# Samples/sec: 2245.68 Avg: 43583.22 Offset: 20.31 P-P noise: 7 St.Dev: 0.931
# Samples/sec: 2245.68 Avg: 43583.40 Offset: 20.48 P-P noise: 8 St.Dev: 0.940
# Samples/sec: 2246.18 Avg: 43583.25 Offset: 20.33 P-P noise: 8 St.Dev: 0.921

# Teensy 3.0 @ 48 MHz
# Samples/sec: 2236.64 Avg: 43583.83 Offset: 20.92 P-P noise: 9 St.Dev: 1.116
# Samples/sec: 2236.64 Avg: 43583.67 Offset: 20.76 P-P noise: 8 St.Dev: 1.123
# Samples/sec: 2236.14 Avg: 43583.81 Offset: 20.89 P-P noise: 8 St.Dev: 1.117
# Samples/sec: 2236.64 Avg: 43583.73 Offset: 20.81 P-P noise: 10 St.Dev: 1.107

# Teensy 3.0 @ 24 MHz
# Teensy 3.0 ADC test start: 
# Samples/sec: 2156.10 Avg: 43573.35 Offset: 10.44 P-P noise: 7 St.Dev: 0.913
# Samples/sec: 2156.10 Avg: 43573.42 Offset: 10.50 P-P noise: 8 St.Dev: 0.928
# Samples/sec: 2156.10 Avg: 43573.55 Offset: 10.64 P-P noise: 7 St.Dev: 0.927
# Samples/sec: 2156.10 Avg: 43573.44 Offset: 10.52 P-P noise: 7 St.Dev: 0.907
# Samples/sec: 2156.10 Avg: 43573.33 Offset: 10.42 P-P noise: 7 St.Dev: 0.923

// Analog input test for Teensy 3.0    Oct 4 2012 J.Beale
// Setup: https://picasaweb.google.com/109928236040342205185/Electronics#5795546092126071650

    #define VREF (3.266)         // ADC reference voltage (= power supply)
    #define VINPUT (2.171)       // ADC input voltage from resistive divider to VREF
    #define ADCMAX (65535)       // maximum possible reading from ADC
    #define EXPECTED (ADCMAX*(VINPUT/VREF))     // expected ADC reading
    #define SAMPLES (10000)      // how many samples to combine for pp, std.dev statistics

    const int analogInPin = A0;  // Analog input is AIN0 (Teensy3 pin 14, next to LED)
    const int LED1 = 13;         // output LED connected on Arduino digital pin 13

    int sensorValue = 0;        // value read from the ADC input
    long oldT;

    void setup() {    // ==============================================================
      pinMode(LED1,OUTPUT);       // enable digital output for turning on LED indicator
      analogReference(INTERNAL);  // set analog reference to internal ref
      analogReadRes(16);          // Teensy 3.0: set ADC resolution to this many bits
     
      Serial.begin(115200);       // baud rate is ignored with Teensy USB ACM i/o
      digitalWrite(LED1,HIGH);   delay(1000);   // LED on for 1 second
      digitalWrite(LED1,LOW);    delay(3000);   // wait for slow human to get serial capture running
     
      Serial.println("# Teensy 3.0 ADC test start: ");
    } // ==== end setup() ===========

    void loop() {  // ================================================================ 
     
      long datSum = 0;  // reset our accumulated sum of input values to zero
      int sMax = 0;
      int sMin = 65535;
      long n;            // count of how many readings so far
      double x,mean,delta,sumsq,m2,variance,stdev;  // to calculate standard deviation
     
      oldT = millis();   // record start time in milliseconds

      sumsq = 0; // initialize running squared sum of differences
      n = 0;     // have not made any ADC readings yet
      mean = 0; // start off with running mean at zero
      m2 = 0;
     
      for (int i=0;i<SAMPLES;i++) {
        x = analogRead(analogInPin);
//        Serial.println(x,0);
        datSum += x;
        if (x > sMax) sMax = x;
        if (x < sMin) sMin = x;
              // from http://en.wikipedia.org/wiki/Algorithms_for_calculating_variance
        n++;
        delta = x - mean;
        mean += delta/n;
        m2 += (delta * (x - mean));
      } 
      variance = m2/(n-1);  // (n-1):Sample Variance  (n): Population Variance
      stdev = sqrt(variance);  // Calculate standard deviation

      Serial.print("# Samples/sec: ");
      long durT = millis() - oldT;
      float datAvg = (1.0*datSum)/n;
      Serial.print((1000.0*n/durT),2);

      Serial.print(" Avg: ");     Serial.print(datAvg,2);
      Serial.print(" Offset: ");  Serial.print(datAvg - EXPECTED,2);
      Serial.print(" P-P noise: ");  Serial.print(sMax-sMin);
      Serial.print(" St.Dev: ");  Serial.println(stdev,3);
     
//     while (true) {}
    } // end main()  =====================================================