Dangerous Prototypes Open Source Hardware

# 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()  =====================================================

time(sec)	src	dest	type	data or status		bytes	URB id:
----------------------------------------------------------------------------------
Teensy 2.0 USB-ACM packet trace		Linux debian 2.6.32-5-686  Wireshark 1.2.11
----------------------------------------------------------------------------------
14.627059	5.4	host	C	min,sps,avg,pkpk,...	68	0x00000000f61b5800
14.627076	host	5.4	S	-EINPROGRESS (-115)	0	0x00000000f61b5800
14.628010	host	5.3	S	m (-EINPROGRESS)	1	0x00000000f61b5900
14.628019	host	5.3	S	i (-EINPROGRESS)	1	0x00000000f61b5600
14.628023	host	5.3	S	n (-EINPROGRESS)	1	0x00000000f61b5380
...
14.628081	host	5.3	S	k (-EINPROGRESS)	1
14.629057	5.3	host	C	Success			0	0x00000000f61b5900
14.629064	5.3	host	C	Success			0	0x00000000f61b5600

16.324065	5.4	host		0.07,5899.70,175...   	33	0x00000000f61b5180
16.324084	host	5.4		-EINPROGRESS (-115)	0	0x00000000f61b5180
...
22.258057	5.4	host	C	-ENOENT			0	0x00000000f61b5180
22.259057	5.4	host	C	-ENOENT			0	0x00000000f61b5800
----------------------------------------------------------------------------------
Teensy 3.0 USB-ACM packet trace 	Linux debian 2.6.32-5-686   Wireshark 1.2.11
----------------------------------------------------------------------------------
22.004169	4.4	host	C	min,sps,avg,pkpk,...	68	0x00000000f61e9e80
22.004189	host	4.4	S	-EINPROGRESS (-115)	0	0x00000000f61e9e80
22.008006	host	4.3	S	m (-EINPROGRESS)	1	0x00000000f61e9400
22.008016	host	4.3	S	i (-EINPROGRESS)	1	0x00000000f61a3880
22.008020	host	4.3	S	n (-EINPROGRESS)	1	0x00000000f6f90400
...
22.008077	host	4.3	S	k (-EINPROGRESS)	1	0x00000000f6f90b80
22.008155	4.3	host	C	Success			0	0x00000000f61e9400
22.008162	4.3	host	C	Success			0	0x00000000f61a3880
22.009165	4.3	host	C	Success			0	0x00000000f6f90400
...
22.009206	4.3	host	C	Success			0	0x00000000f6f90b80

36.196116	host	4.0	S	(-EINPROGRESS)		0	0x00000000f6286100
------------------------------------------------------------------------------------------

root@debian:/home/john# cat /dev/ttyACM0
min,sps,avg,pkpk,stdev 
# Teensy 3.0 ADC test v1.1 2012.10.6 JPB 
0.07,5899.70,175.05,905,214.296
0.10,5934.72,70.29,98,11.796
0.13,5941.77,72.79,98,11.616
0.16,5927.68,71.95,105,14.226

root@debian:/home/john# cat /dev/ttyACM0
min,sps,avg,pkpk,stdev 
# Teensy 3.0 ADC test v1.1 2012.10.6 JPB 

    // 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("min,sps,avg,pkpk,stdev ");
          Serial.println("# Teensy 3.0 ADC test v1.1 2012.10.6 JPB ");
        } // ==== 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(oldT/60000.0,2);
          Serial.print(","); 
          Serial.print((1000.0*n/durT),2);
          Serial.print(","); 
          
          Serial.print(datAvg,2);
//          Serial.print(" Offset: ");  
//          Serial.print(datAvg - EXPECTED,2);
          Serial.print(",");  
          Serial.print(sMax-sMin);
          Serial.print(",");  
          Serial.println(stdev,3);
         
    //     while (true) {}
 } // end main()  =====================================================
 
        

root@debian:/home/john# cat /dev/ttyACM0
min,sps,avg,pkpk,stdev 
# Teensy 3.0 ADC test v1.1 2012.10.6 JPB 
0.07,2238.14,32788.21,8,0.886
0.14,2238.14,32788.15,7,0.902
0.22,2238.14,32788.16,7,0.923
0.29,2238.14,32788.14,6,0.926
0.37,2238.14,32788.13,7,0.907
0.44,2238.14,32788.14,6,0.894
0.52,2237.64,32788.24,6,0.885
0.59,2238.14,32788.21,6,0.871

stty -F /dev/ttyACM0 1:0:80001cb1:0:3:1c:7f:15:4:5:1:0:11:13:1a:0:12:f:17:16:0:0:0:0:0:0:0:0:0:0:0:0:0:0:0:0
cat /dev/ttyACM0 > /home/pi/teensy3.log

#define T GPIOC_PTOR = 1<<5; // toggle state of PortC,bit5 = LED pin
void setup() {pinMode(13, OUTPUT);} // make LED pin an output
void loop() { T T T T T T T T T T T T T T T T T T T } // toggle pin 19x as unrolled loop

#define H PORTB = 1<<5; // Arduino set D13 (LED pin) high
#define L PORTB = 0; // make PortB all zeros
void setup() {pinMode(13, OUTPUT);}  // make LED pin an output
void loop() { H L H L H L H L H L H L H L H L H L H L }

/* -----------------------------------------------------------------
  Interface between Teensy 3.0 and MAX11209 18-bit ADC
  compiled with Arduino 1.0.1 Teensy 3 beta 5
  October 12 2012 John Beale
 
  Note: this ADC requires 3.3V logic levels.

   MAX11209  <---------->  Arduino Device
   11: /CS  <- to digital pin 10  (SS pin)
   12: MOSI <- to digital pin 11 (MOSI pin)
   13: MISO -> to digital pin 12 (MISO pin)
   14: SCLK <- to digital pin 13 (CLK pin)
    4: GND  - ground
    9: AVDD - 3.3V supply
   10: DVDD - 3.3V supply
------------------------------------------------------------------ */

/*   MAX11209 8-bit Command Byte, and Status & Control Registers
 ------------------------------------------------------------------------
 #  name     b7     b6     b5     b4     b3     b2     b1     b0      dir
 ------------------------------------------------------------------------
 - COMMAND  START  MODE   CAL1   CAL0   IMPD   RATE2  RATE1  RATE0     W
 0 STAT1    SYSOR  RATE2  RATE1  RATE0  OR     UR     MSTAT  RDY       R
 1 CTRL1    LINEF  U/B    EXTCLK REFBUF SIGBUF FORMAT SCYCLE UNUSED   R/W
 2 CTRL2    DIR4   DIR3   DIR2   DIR1   DIO4   DIO3   DIO2   DIO1     R/W
 3 CTRL3    DGAIN2 DGAIN1 DGAIN0 NOSYSG NOSYSO NOSCG  NOSCO  RESERVED R/W
 ----------------------------------------------------------------------- */
 
// NOTE: MAX11209 SlaveSelect pin must be toggled high & low between each command
// (despite data sheet claim to the contrary)
 
#include <SPI.h>  // include the SPI library for talking with chip

#define UC unsigned char    // 8 bits unsigned char = 1 byte
#define STAT1 0            // addresses of ADC status/control registers
#define CTRL1 1
#define CTRL2 2
#define CTRL3 3

// set I/O pins used in addition to clock, data in, data out
const byte slaveSelectPin = 10;  // digital pin 10 for /CS
const byte SPICLK = 13;  // digital pin for SPI Clock
const byte SPIMISO = 12;  // digital pin for MISO
const byte SPIMOSI = 11;  // digital pin for MOSI

// analog calibration numbers
#define ADCMID 131072   // 2^17 is 0 with 18-bit offset binary
#define VMINUS 2492000.0    // negative analog Vinput (microvolts)
#define TWOE18 262144   // 2^18
#define VFS (1.236*2)        // ADC Volts full-scale = 2(VrefP-VrefN)
#define LSBSIZE (VFS/TWOE18) 
#define AVERAGES 48    // for approx 100 millisecond output period

void setup() {
  
    Serial1.begin(115200);      // set up serial port #1 output at this baud rate
    delay(3000);
    SPI.begin(); // initialize SPI, configures SPIMOSI,SPIMISO,SPICLK signals
    pinMode (slaveSelectPin, OUTPUT);   // make CS/ pin an output
    digitalWrite(slaveSelectPin,HIGH);  // CS/ chip select is active low   
    SPI.setBitOrder(MSBFIRST);  // data is clocked in MSB first
    
    // MAX11209 max SPI clock is 5 MHz (assuming no problem with long wires...)
    // SPI.setClockDivider(SPI_CLOCK_DIV16);  // this cmd is not currently supported on Teensy 3.0 beta 5

    Serial1.println("sec,degC");
    Serial1.println("# MAX11209 ADC Test Oct 12 2012");

    initADC();

    // ==== ADC SAMPLING RATE set by this SendCmd() command
    // Possible sampling rates: 1-120 Hz in single shot; 60-480 Hz in continuous
    
    SendCmd(0b10000111); // start converting at Max Rate 120/480 sps
//    SendCmd(0b10000100); // start converting at Rate 15/60 sps
    digitalWrite(slaveSelectPin,LOW);   // enable chip, to monitor RDY/DATA for "conversion ready"
    for (int i=0; i<16; i++) {
      readADC();   // First few readings in continuous mode are invalid (settling time)
    }
}

void loop() { //             ================ MAIN LOOP ===========================
long adcSum;
  
  adcSum = 0;
  for (int i=0;i<AVERAGES;i++) {
    adcSum += readADC();   // get 18 bit ADC reading
  }
  
  float Vin = ((float)(adcSum - (ADCMID*AVERAGES)) * (LSBSIZE/AVERAGES));
  Serial1.println(Vin*100.0,4);          // send ADC value out serial port
      
} //  =================== END of main loop() =================================

// ======================== set up ADC chip registers ==============
void initADC(void) {

// NOTE: if Signal or Ref buffer ON, Sig or Ref must be 100 mV above GND and 100 mV below AVdd
// with buffers OFF, Sig and Ref can swing over full range (actually, 30 mV beyond rails)

/* SCYCLE: The single-cycle bit, SCYCLE, determines if the device runs in “no-latency” 
single-conversion mode (SCYCLE = 1) or continuously (SCYCLE = 0). When in single-cycle 
conversion mode, the device completes one no-latency conversion and then powers down 
into a leakage-only state. When in continuous mode, the part is continuously converting 
and the first three data from the part are incorrect due to the SINC4 filter latency.  */

//  WriteReg8(CTRL1, 0b00011110); // 60 Hz,bipolar,intClk,RefBuf,SigBuf,Offset,SingleCycle
//  WriteReg8(CTRL1, 0b00000110); // 60 Hz,bipolar,intClk,NoRefBuf,NoSigBuf,Offset,SingleCycle
    WriteReg8(CTRL1, 0b00000100); // 60 Hz,bipolar,intClk,NoRefBuf,NoSigBuf,Offset,Continuous
    WriteReg8(CTRL2, 0b11110010); // DIO1-4 all outputs, set 4 output pins to 0010
    WriteReg8(CTRL3, 0b00011000); // Gain=1,no system gain/offset, use self-cal gain/offset
    
    SendCmd(0b10010000); // start self-calibration cycle
    delay(220);    // self-calibration takes 200 msec
    
} // end initADC()

// =======================================================
//   Get ADC data from 24-bit register 4. 
long readADC(void) {
  
  do {} while (digitalRead(SPIMISO) == HIGH);  // wait for next ADC conversion result to be ready

  digitalWrite(slaveSelectPin,LOW);   // take the SS pin low to select the chip
  long result = SPI.transfer(0b11001001); // send command to read register 4
  result |= SPI.transfer(0x00);   // obtain high-order byte
  result = result << 8;          // shift left one byte
  result |= SPI.transfer(0x00);   // obtain 2nd byte
  result = result << 8;          // shift left one byte
  result |= SPI.transfer(0x00);   // obtain low-order byte
  
  digitalWrite(slaveSelectPin,HIGH);   // take the SS pin high, ending SPI transaction
  digitalWrite(slaveSelectPin,LOW);   // enable chip, to monitor RDY/DATA for "conversion ready"  
  result = result >> 6;         // 24-bit word: 18 data bits, and low-order 6 bits = 0
  return(result);
}

// ===================  read an 8-bit register (Registers 0,1,2,3)
UC ReadReg8(UC addr) {
// mode 1 command byte
// b7 b6 b5 b4  b3  b2  b1  b0
// 1  1  0  RS3 RS2 RS1 RS0 1   (b0 = W/R)

 digitalWrite(slaveSelectPin,LOW);   // take the SS pin low to select the chip
 UC a = (addr << 1) | 0b11000001;  // set b7,b6,b0 = 1
 a &= 0b11011111;    // set b5 = 0
 UC result = SPI.transfer(a);	// send command to read register 'addr'
 result = SPI.transfer(0x00);   // obtain 1-byte register value
 digitalWrite(slaveSelectPin,HIGH);   // take the SS pin high to deselect chip
 return(result);
} // end ReadReg8()

// =======================================================
// write an 8-bit register (Registers 0,1,2,3)

void WriteReg8(UC addr, UC data) {
// mode 1 command byte
// b7 b6 b5 b4  b3  b2  b1  b0
// 1  1  0  RS3 RS2 RS1 RS0 0   (b0 = W/R)

 digitalWrite(slaveSelectPin,LOW);   // DEBUG 
 delay(4);  // DEBUG
 digitalWrite(slaveSelectPin,HIGH);  // DEBUG
 delay(4); // DEBUG

 digitalWrite(slaveSelectPin,LOW);   // take the SS pin low to select the chip
 UC a = (addr << 1) | 0b11000000;  // set b7,b6 = 1
 a &= 0b11011110;    // set b5,b0 = 0
 SPI.transfer(a);	// send command to read register 'addr'
 SPI.transfer(data);   // obtain 1-byte register value
 digitalWrite(slaveSelectPin,HIGH);   // take the SS pin high to deselect chip

} // end WriteReg8()


// =======================================================
// send Command Byte (MODE = 0)

void SendCmd(UC data) {
// === mode 0 command byte format =======
// b7 b6 b5   b4   b3   b2    b1    b0
// 1  0  CAL1 CAL0 IMPD RATE2 RATE1 RATE0
 digitalWrite(slaveSelectPin,LOW);   // take the SS pin low to select the chip
 UC a = data | 0b10000000;  // set b7 = 1
 a &= 0b10111111;    // set b6 = 0
 SPI.transfer(a);	// send command byte
 digitalWrite(slaveSelectPin,HIGH);   // take the SS pin high to deselect chip
} // end SendCmd()

// =======================================================
// read a 24-bit register (Registers 4,5,6,7,8)

long ReadReg24(UC addr) {
// mode 1 command byte
// b7 b6 b5 b4  b3  b2  b1  b0
// 1  1  0  RS3 RS2 RS1 RS0 W/R

 digitalWrite(slaveSelectPin,LOW);   // take the SS pin low to select the chip
 UC a = (addr << 1) | 0b11000001;  // set b7,b6,b0 = 1
 a &= 0b11011111;    // set b5 = 0
 long result = SPI.transfer(a);	// send command to read register 'addr'
 result |= SPI.transfer(0x00);   // obtain high-order byte
 result = result << 8;          // shift left one byte
 result |= SPI.transfer(0x00);   // obtain 2nd byte
 result = result << 8;          // shift left one byte
 result |= SPI.transfer(0x00);   // obtain low-order byte
 digitalWrite(slaveSelectPin,HIGH);   // take the SS pin high to deselect chip

 return(result);  // return 24-bit value
  
} // end ReadReg24()

val,n,p-p,stdev
#Teensy3.0 Touchprogram Oct.232012
688.03,4315,7,1.465
688.07,4318,7,1.461
687.99,4317,8,1.477
687.95,4318,7,1.454
687.81,4319,7,1.468
689.23,4315,9,1.786
691.18,4307,6,1.307
690.99,4309,6,1.302
690.90,4310,7,1.275
690.84,4308,7,1.281
690.81,4309,8,1.287
690.82,4309,7,1.290
690.58,4309,7,1.291
690.69,4309,7,1.284
688.76,4312,10,1.865
687.82,4318,7,1.458
687.78,4318,7,1.457
687.77,4317,8,1.465
687.85,4318,7,1.469
687.93,4318,7,1.466
687.94,4317,7,1.465
687.81,4319,7,1.459
687.77,4317,7,1.451
687.87,4318,7,1.460
687.77,4317,7,1.477
688.02,4318,8,1.478
687.93,4318,7,1.472

val,n,p-p,stdev
# Teensy 3.0 Touch program Oct. 23 2012
908.20,3713,18,2.854
910.23,3708,22,2.910
912.22,3704,23,3.007
831.56,3901,233,102.050
689.36,4312,8,1.458
689.57,4313,9,1.502
1230.76,3084,2859,877.954
3574.54,1376,981,155.670
3795.12,1308,941,170.153
3923.82,1272,1118,186.593
4035.86,1242,1058,194.914
2393.54,1911,3912,1677.471
688.00,4315,8,1.540
687.82,4318,7,1.438
687.85,4317,7,1.445

/*  Test capacitive touch sensor function on Teensy 3.0
    using Teensy 3.0 beta 6 (Windows) release    J.Beale Oct. 23 2012
 */
 
#define SAMPLES (5000)   // maximum number of separate readings to take
#define TIMEOUT (500)    // maximum sample integration time in milliseconds

int led = 13;

void setup() {                
  pinMode(led, OUTPUT);     
  digitalWrite(led, HIGH);   // turn the LED on (HIGH is the voltage level)
  delay(3000);               // wait for user to start up logging program
  Serial.begin(115200);       // baud rate is ignored with Teensy USB ACM i/o
  delay(2000);
  Serial.println("val,n,p-p,stdev");
  Serial.println("# Teensy 3.0 Touch program Oct. 23 2012");
  digitalWrite(led, LOW);    // turn the LED off by making the voltage LOW
}

void loop() {
int t1;
long tStart;  // starting time
long datSum;  // reset our accumulated sum of input values to zero
int sMax;
int sMin;
long n;            // count of how many readings so far
double x,mean,delta,sumsq,m2,variance,stdev;  // to calculate standard deviation
 
  datSum = 0;
  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;
  sMax = 0;
  sMin = 65535;
         
  tStart = millis();
  for (int i=0;i<SAMPLES && ((millis()-tStart)<TIMEOUT);i++) {
            x = touchRead(A1);
            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(mean);
  Serial.print(",");  
  Serial.print(n);
  Serial.print(",");  
  Serial.print(sMax-sMin);
  Serial.print(",");  
  Serial.println(stdev,3);
}