Yale Cards Voltage Gain Analysis

Yale Cards Voltage Gain Analysis

S. H. Cheng

February 9, 2006

Abstract

The Yale card plays the role of amplifying the output signal from the NMR. Because of the importance of knowing the actual amplitude of this signal, it is necessary to know the gain of the Yale cards to a high precision. The method used was to measure a continuous input and output signal of the Yale card and then do linear square fit of the data.

1.Introduction: A Brief Description of the Yale Card

The basic schematic of the Yale card is:

Fig. 1

Besides the conventional input/output pins the Yale card has three special pins relevant to our analysis. Two of them are Gain 1 and Gain 207. The Yale card uses the combinations of signals in these two pins to switch among gains of 1, 20 and 50 times. Logically, these are set in the following way:

1X / 20X / 50X
GAIN 1 / Low / High / High
GAIN 207 / Low / High / High

Table 1

It is worth to remember that since the Yale card is based on TTL technology a low means a value between 0 to 0.8 volts whereas high between 2 to 5 volts.

The third special pin is the TTL convert. Due to the nature of the operational amplifiers within the Yale cards, the output signal will most likely have an additional DC component. In order to minimize this vertical shift in the output signal a TTL pulse of at least 10 msec is needed at TTL convert.

2.Analysis Method

The method chosen was to have GEOFF provide a sequence of input signals for the Yale card through GEOFF’s DAC. In order to avoid saturating the Yale cards, the following range of values were chosen for each gain value:

INPUT VOLTAGE RANGE
1x / -6 to 6 volts
20x / -341 to 341 mvolts
50x / -146.25 to 146.25 mvolts

Table 2

The signals for the gain selection and TTL convert were provided by the digital output of the same DAC. The ADC in GEOFF was used to read and save the output and input signals of the Yale card. Using GNUPLOT, a linear square fit was applied to each set of data in order to extract the slope of the Vout vs. Vin plot. This command in GNUPLOT is:

fit a*x+b ‘filename’ using 1:2 via a,b

This fitting method was chosen against measuring the gain from the Gain vs. Vin plot mainly because it gives a statistically more precise measurement of the quantity. Another reason is that the gain of the Yale cards for values very close to zero (+/- 5mvolts) is enormous. This along with the fact that GEOFF’s DAC cannot provide an exact zero volts makes the removal of the offset impossible. Hence, by measuring the slope of the Vout vs. Vin response, it is possible to measure the correct value of the gain without taking into account the offset of the output signal. The code run by GEOFF for this analysis is provided in appendix A.

3.Equipment and Program

Two crucial components of this measurement were DM6620 (GEOFF’s DAC) and STRATUS-X-ND (GEOFF’s ADC). Their pin-summaries, obtained from their respective manuals[1], are included in appendix B.

The DAC, ADC and the Yale Card were wired as indicated in the following diagram:

Fig. 2

In Fig. 2, the internal connections of GEOFF are not shown; these are, but not limited to, the connections between the central processor and the ADC (or DAC).

The pins 37 and 35 (P0.0 and P0.1 respectively) were used to set the gain of the Yale card by providing the necessary TTL signal. Pin 31 (P0.2), instead, provides the TTL pulses that are needed for DC convert. The logical values of these digital ports are set with the following command:

DIOWriteBit6620(dac_board_number, port_number, bit_number, value)

where the first argument specifies the board on the DAC. The second and third arguments specify the port (in this case, 0) and the bit of the port, respectively. Finally the last argument can be set either 1 (logic high) or 0 (logic low).

The input signal for the Yale card is provided by the ADC through Aout1 and ANALOG GND, which is also connected to channel 0 of the ADC. There are a few steps that need to be followed to set the values at Aout1 (and ANALOG GND). First, this output is taken from an internal FIFO, which needs to be loaded with the following command:

LoadDACFIFO6620(dac_board_number, dac_channel, value )

It is worth noting that the last argument should not be in mili-volts or volts. But instead in Unipolar D/A bit weight. More information of this can be found in the DM6620 manual. After loading the wanted value, the same value can be expressed at Aout1 with the following command:

UpdateDAC6620(dac_board_number, dac_channel )

Once the desired value is expressed at Aout1, the same value can be loaded to the ADC FIFO with:

UpdateADCSXND(adc_board_number )

The final step is to read the value from the ADC FIFO and convert it to volts. This is done with

ConvertADCDataToVoltsSXNDF(0, ReadADCDataSXND(adc_board_number))

which also returns a float32 value.

All the above commands mentioned should not be relevant for anyone who uses the program in appendix A, since all those commands are included in the function ‘IloveTediousWork’. However, if rewriting the code is needed, one should remember to link his program to ‘geofftypes.h’, ‘dm6620.h’ and ‘stratusxnd.h’. For additional reference and information, please refer to the programs (by Josh Doe) in SPIN at /home/exp/b28/geoff/sweeper.

4.Raw Data Analysis

As mentioned in section 2, the raw data obtained from GEOFF were only the input and output voltage of all the Yale cards. For instance the following plot corresponds to the raw data obtained from Yale card # 8[2] with gain of 20x:

Fig. 3

By linear fitting the raw data, one can obtain a linear equation

a x + b

where a is just the gain and b the offset. For the example at hand,

a = 23.0502 +/- 0.04331

b = 0.149881 +/- 0.149881

indicating that the estimated gain is 23.05 with and estimated offset of 0.1499 volts.

5.Results

01x / 20x / 50x
card# / Gain / Offset [volts] / Gain / Offset [volts] / Gain / Offset [volts]
1 / 1.14944 / 0.0208552 / 23.4211 / -0.176109 / 57.9845 / 0.279976
2 / 1.14834 / 0.0076843 / 23.2712 / -0.054483 / 57.674 / 0.760867
3 / 1.15181 / 0.0163005 / 23.4747 / 0.378427 / 57.864 / 0.552636
4 / 1.15005 / 0.0056173 / 23.2943 / 0.216175 / 57.5345 / -0.279452
5 / 1.15131 / 0.0133027 / 23.5043 / 0.177775 / 58.3853 / 1.15658
6 / 1.14985 / 0.006421 / 23.321 / 0.054449 / 58.02 / -0.902829
7 / 1.15262 / 0.0056308 / 23.2469 / 0.027195 / 57.6678 / 0.0992731
8 / 1.15073 / -0.0062669 / 23.0502 / 0.149881 / 56.8051 / -0.31848
9 / 1.14927 / 0.0048465 / 23.4362 / -0.067421 / 57.8273 / 0.598243
10 / 1.14917 / -0.0062531 / 23.813 / 0.172842 / 58.9902 / 1.1834
11 / 1.15137 / 0.0104968 / 24.4101 / 0.040844 / 60.8587 / -0.24088
12 / 1.14653 / -0.0006291 / 24.2685 / -0.185533 / 60.0917 / 0.01422
13 / 1.14695 / -0.0009189 / 23.3131 / 0.368288 / 57.4183 / 0.12482
16 / 1.14728 / -0.0059019 / 23.1898 / 0.423709 / 57.2667 / 0.79355
17 / 1.14909 / -0.009052 / 23.3735 / 0.286697 / 57.4116 / 0.28166
18 / 1.15143 / 0.0152896 / 23.4293 / -0.108961 / 58.2639 / 0.22539
19 / 1.15129 / 0.0067491 / 23.4438 / -0.216141 / 57.9663 / 0.62496
21 / 1.15117 / 0.0092803 / 23.4563 / 0.143146 / 58.0542 / 0.31357
22 / 1.15002 / -0.002867 / 22.7561 / 0.029241 / 59.4671 / 0.01257
23 / 1.15129 / 0.0135815 / 22.2085 / 0.237403 / 58.8023 / 0.70584
24 / 1.14736 / 0.0048595 / 23.2423 / 0.140856 / 57.2549 / -0.2757

Appendix A

Beginning of Source Code 1 (Program Driver):

// 'dataTaker.c' (by Shih Ho Cheng) provides a way to determine

// automatically the gains of yale cards with GEOFF.

#include <stdio.h>

#include <sys/io.h>

#include <string.h>

#include "geofftypes.h"

#include "dm6620.h"

#include "stratusxnd.h"

#include "dataTakerlib.h"

int main( int argc, char *argv[] ) {

// Board, channel and address of the DAC

const uchar8 DAC_brd = 0;

const uint16 DAC_chn = 0;

const int DAC_add = 800;

// Board, channels (yale input and output) and address of the ADC

const uchar8 ADC_brd = 0;

const uint16 ADC_in_chn = 0;

const uint16 ADC_out_chn = 1;

const int ADC_add = 864;

char date[9]; // Contains the acquisition date MMDDYY

char outputfile1x[20], // Point to the output file names

outputfile20x[20],

outputfile50x[20];

int gain_sl = 0; // 0 for 1x (default), 1 for 20x and 2 for 50x

//***********************************************************************

// WARNING !!!

// The following constants should be set according to the previous

// variable 'step' so to avoid overflowing the DAC fifo, which can

// only hold 1024 samples. Also, these constants should be set so

// that the resultant absolute output from the yale card doen't

// excced 10 v.

// (For reference, check /exp/b28/geoff/manuals/dm6620.pdf, pg. 54)

//***********************************************************************

// SETTINGS SETTINGS SETTINGS SETTINGS

//======

//======

const uint16 initv_1x = -1230; // = -6005.859375 mv

const uint16 lastv_1x = 1230; // = 5996.859375 mv (+/-10v range)

const uint16 initv_20x = -140; // = -341.25 mv

const uint16 lastv_20x = 140; // = 341.25 mv (+/-5 range)

const uint16 initv_50x = -60; // = -146.25 mv

const uint16 lastv_50x = 60; // = 146.25 mv (+/-5 range)

const uint16 step_1x = 5;

const uint16 step_20x = 1;

const uint16 step_50x = 1;

//======

//======

if( argc != 2 ) {

printf( "ERROR: one and only one argument is needed!\n" );

return -1;

}

AqDate( date );

strcpy( outputfile1x , date );

strcpy( outputfile20x, date );

strcpy( outputfile50x, date );

strcat( outputfile1x, argv[1] );

strcat( outputfile1x, ".01x.dat" );

strcat( outputfile20x, argv[1] );

strcat( outputfile20x, ".20x.dat" );

strcat( outputfile50x, argv[1] );

strcat( outputfile50x, ".50x.dat" );

FILE *filename1;

FILE *filename2;

FILE *filename3;

filename1 = fopen( outputfile1x, "w" );

filename2 = fopen( outputfile20x, "w" );

filename3 = fopen( outputfile50x, "w" );

// Setting and initializing the addresses for the DAC and ADC

// (also the rang for DAC).

SetBaseAddress6620( DAC_brd, DAC_add );

GetAccess6620 ( DAC_brd );

InitBoard6620 ( DAC_brd );

//SetDACRange6620 ( DAC_brd, DAC_chn, 3 ); // The last argument

// indicates that the

// range is +/- 10v

SetDACUpdate6620( DAC_brd, DAC_chn, 0 );

SetDACUpdateEnable6620( DAC_brd, 1, 0, 0, 0 );

DIOSetPort0DirectionBit6620( DAC_brd, 0, 1 ); // The 2nd arg. indicates

DIOSetPort0DirectionBit6620( DAC_brd, 1, 1 ); // the bit and the 3rd

DIOSetPort0DirectionBit6620( DAC_brd, 2, 1 ); // arg. the direction.

SetBaseAddressSXND( ADC_brd, ADC_add );

GetAccessSXND( ADC_brd );

InitBoardSXND( ADC_brd );

SetChannelRegisterSXND( ADC_brd, ADC_in_chn, ADC_out_chn );

SetHardwareTriggerSXND( ADC_brd, 0 );

SetGateControlSXND( ADC_brd, 0 );

SetADCRangeSXND( ADC_brd, 0 ); // The last arg. indicates

// the range; 0 indicates +/- 10v

//************************************************************************

// Acquisition Section

//************************************************************************

// Begin data acquisition for 1x

SetDACRange6620( DAC_brd, DAC_chn, 3 ); // Input range +/- 10v

// Check whether the DAC fifo can hold the number of samples requested

if( ( (lastv_1x - initv_1x)/step_1x + 1) >= 1000 ) {

printf( "ERROR[1x]: The current settings will overflow the DAC fifo\n"

);

return -1;

}

ILoveTediousWork( 0,

initv_1x,

lastv_1x,

step_1x,

filename1,

outputfile1x,

ADC_brd,

ADC_in_chn,

ADC_out_chn,

DAC_brd,

DAC_chn );

// Begin data acquisition for 20x

SetDACRange6620( DAC_brd, DAC_chn, 2 ); // Inpuut range +/- 5v

// Check whether the DAC fifo can hold the number of samples requested

if( ((lastv_20x - initv_20x)/step_20x + 1) >= 1000 ) {

printf( "ERROR[20x]: The current settings will overflow the DAC fifo\n"

);

return -1;

}

ILoveTediousWork( 1,

initv_20x,

lastv_20x,

step_20x,

filename2,

outputfile20x,

ADC_brd,

ADC_in_chn,

ADC_out_chn,

DAC_brd,

DAC_chn );

// Begin data acquisition for 50x

SetDACRange6620( DAC_brd, DAC_chn, 2 ); // Input range +/- 5v

// Check whether the DAC fifo can hold the number of samples requested

if( (lastv_50x - initv_50x + 1)/step_50x >= 1000 ) {

printf( "ERROR[50]: The current settings will overflow the DAC fifo\n"

);

return -1;

}

ILoveTediousWork( 2,

initv_50x,

lastv_50x,

step_50x,

filename3,

outputfile50x,

ADC_brd,

ADC_in_chn,

ADC_out_chn,

DAC_brd,

DAC_chn );

fclose( filename3 );

fclose( filename2 );

fclose( filename1 );

// system( "scp ./*yale*.*.dat rss@spin:/tmp" );

return 0;

}

~End of Source code 1~

Beginning of Source code 2 (Program Library):

// dataTakerlib.c

// by Shih Ho Cheng

#include <stdio.h>

#include <sys/io.h>

#include <time.h>

#include <termios.h>

#include <unistd.h>

#include "geofftypes.h"

#include "dm6620.h"

#include "stratusxnd.h"

#include "dataTakerlib.h"

int getch( ) {

struct termios oldt,

newt;

int ch;

tcgetattr( STDIN_FILENO, &oldt );

newt = oldt;

newt.c_lflag &= ~( ICANON | ECHO );

tcsetattr( STDIN_FILENO, TCSANOW, &newt );

ch = getchar();

tcsetattr( STDIN_FILENO, TCSANOW, &oldt );

return ch;

}

// Gets the date and stores it to where str points. The format is MMDDYY.

void AqDate( char str[] ) {

struct tm *localTptr;

time_t tm;

tm = time( NULL );

localTptr = localtime( &tm );

strftime( str, 100, "%m%d%y", localTptr );

}

void SetYaleGain( int num, uchar8 adc_brd ) {

uchar8 on = 1,

off = 0;

switch (num) {

// Gain 1x

case 0:

DIOWriteBit6620( adc_brd, 0, 0, off ); // The two zeros correspond

// to the port and bit.

DIOWriteBit6620( adc_brd, 0, 1, off );

break;

// Gain 20x

case 1:

DIOWriteBit6620( adc_brd, 0, 0, on );

DIOWriteBit6620( adc_brd, 0, 1, off );

break;

// Gain 50x

case 2:

DIOWriteBit6620( adc_brd, 0, 0, on );

DIOWriteBit6620( adc_brd, 0, 1, on );

break;

}

}

// Gets rid of the DC offset (when the input of the yale card is 0 volts)

void DCConvert( uchar8 adc_brd ) {

uchar8 on = 1,

off = 0;

//Pulse dcconvert high for 100ms

//The second argument corresponds to channel 0.

DIOWriteBit6620( adc_brd, 0, 2, off );

DIOWriteBit6620( adc_brd, 0, 2, on );

//printf("I'm inside DCConvert, press any key to continue\n");

//getch();

usleep(300000);

DIOWriteBit6620( adc_brd, 0, 2, off );

}

// Loads a value to the DAC and updates it

//void Write2DAC( uchar8 board, uint16 channel, int16 value ) {

// LoadDACFIFO6620( board, channel, value );

// UpdateDAC6620( board, channel );

//}

// Updates the specified channel of the ADC,

// reads from it and converts it into volts units

//float32 Read4ADC( uchar8 board, uint16 channel ) {

//

// UpdateADCSXND( board );

// usleep( 100 );

//

// return ;

//}

void ILoveTediousWork( int gain_sl,

uint16 init_v,

uint16 last_v,

uint16 step,

FILE *filename,

char outputfile[],

uchar8 adc_brd,

uint16 adc_chn0,

uint16 adc_chn1,

uchar8 dac_brd,

uint16 dac_chn ) {

//int sample_n = 0;

uint16 e = 0;

float32 input_v = 0.0;

float32 output_v = 0.0;

float32 offset = 0.0;

float32 gain = 0.0;

float32 offset_bDCConvert = 0.0; // offset before DC convert

int tmp;

/*

// Clear ADC and DAC fifo

SetChannelRegisterSXND( adc_brd, adc_chn0, adc_chn1 );

ClearDACFIFO6620( dac_brd, dac_chn );

//======

// Obtaining the offset before DC convert

// ------

LoadDACFIFO6620( dac_brd, dac_chn, 0 );

UpdateDAC6620( dac_brd, dac_chn ); // set DAC analog output to 0v

usleep( 1000 );

//printf( "Before DCc., you should be able to read the original offset\n" );

//getch();

UpdateADCSXND( adc_brd ); // Loads 0v (chn0) into ADC fifo

UpdateADCSXND( adc_brd ); // Loads offset (chn1) into ADC fifo

printf( "1st: ch0 = %f\n", ReadADCDataSXND( adc_brd ) ); // Dump the first element in ADC fifo

offset_bDCConvert = ConvertADCDataToVoltsSXND( 0, ReadADCDataSXND(adc_brd) );

//======

*/

// Clear ADC and DAC fifo

SetChannelRegisterSXND( adc_brd, adc_chn0, adc_chn1 );

ClearDACFIFO6620( dac_brd, dac_chn );

//======

// Obtaining the offset after DC convert

// ------

// Loads a 0 volts into the DAC fifo

LoadDACFIFO6620( dac_brd, dac_chn, 0 );

UpdateDAC6620( dac_brd, dac_chn ); // set DAC analog output to 0v

usleep( 1000 );

//printf( "Before DCConvert\n" );

//printf( "Press any key to continue... \n" );

//getch();

DCConvert( adc_brd );

usleep( 1000 );

SetYaleGain( gain_sl, adc_brd );

usleep( 1000 );

//printf( "After DCConvert, gain set\n" );

//printf( "Press any key to continue... \n" );

//getch();

UpdateADCSXND( adc_brd ); // Loads 0v (chn0) into ADC fifo

UpdateADCSXND( adc_brd ); // Loads offset (chn1) into ADC fifo

ReadADCDataSXND(adc_brd);

usleep( 100000 );

offset = ConvertADCDataToVoltsSXND( 0, ReadADCDataSXND(adc_brd) );

printf( "ch1 = %8.5f\n", offset );

//======

fprintf(filename, "# %s %8.5f\n", outputfile, offset/*, offset_bDCConvert*/);

// printf( "*************\ngain signals\n**************\n" );

//printf( "press any key to continue...\n" );

//getch();

// The following is just to clear the ADC and DAC fifo

SetChannelRegisterSXND( adc_brd, adc_chn0, adc_chn1 );

ClearDACFIFO6620( dac_brd, dac_chn );

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

// Loading the DAC fifo

// ------

for( e = last_v; e >= 5; e -= step ) {

LoadDACFIFO6620( dac_brd, dac_chn, e );

//sample_n++;

}

for( e = -5; e >= init_v; e -= step ) {

//printf( "e = %d\n", e );

LoadDACFIFO6620( dac_brd, dac_chn, e );

//sample_n++;

}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

//printf( "%d samples loaded into DAC FIFO\n\n", sample_n );

// sample_n = 0;

// Loading the ADC fifo

while(1) {

if( IsDAC1FIFOEmpty6620(dac_brd) ) {

break;

}

UpdateDAC6620( dac_brd, dac_chn );

usleep(1000); // EVIL LINE !!!!!!!!!!!!

UpdateADCSXND( adc_brd ); // chn0 : Loads from DAC FIFO

usleep(1000);

UpdateADCSXND( adc_brd ); // chn1 : Loads form yale output

//sample_n++;

}

// Writing the data in output file

while(1 ) {

if(IsFIFOEmptySXND( adc_brd ) ){

break;

}

input_v = ConvertADCDataToVoltsSXND( 0, ReadADCDataSXND(adc_brd) );

output_v = ConvertADCDataToVoltsSXND( 0, ReadADCDataSXND(adc_brd) );

gain = output_v / input_v;

fprintf( filename, "%8.5f\t%8.5f\t%8.5f\n", input_v, output_v, gain );

}

// Clear ADC and DAC fifo

SetChannelRegisterSXND( adc_brd, adc_chn0, adc_chn1 );

ClearDACFIFO6620( dac_brd, dac_chn );

}

~End of Source Code 2~

Beginning of Source Code 3 (Header File):

// dataTakerlib.h

// ------

// The functions are defined in 'dataTaker.c'

#ifndef DATATAKERLIB_H

#define DATATAKERLIB_H

#include "geofftypes.h"

// Returns a string with the date of the measurement

//void AqDate( char *str );

// set the gain of the yale card: num = 0 for 1x, 1 for 20x and 2 for 50x.

void SetYaleGain( int num, uchar8 adc_brd );

// DC convert... What else can I say?

void DCConvert( uchar8 adc_brd );

// Loads 'value' to the DAC and updates it.

//void Write2DAC( uchar8 board, uint16 channel, int16 value );

// Updates the specified 'channel' of the specified 'board'. Then it

// reads and converts obtained value into volts units.

//float32 Read4ADC( uchar8 board, uint16 channel );

// Measurement loop: reads the yale card input and output voltages and

// calculates the gain (it also takes the offset into consideration).

void ILoveTediousWork( int gain_sl,

uint16 init_v,

uint16 last_v,

uint16 step,

FILE *filename,

char *outputfile,

uchar8 adc_brd,

uint16 adc_chn1,

uint16 adc_chn2,

uchar8 dac_brd,

uint16 dac_chn );

#endif

~End of Source Code 3~

Appendix B

Stratus-X-ND (ADC)
I/O Connector J7
+5v POWER / 1 / ■ / ● / 2 / CT_OUT2
CT_OUT0 / 3 / ● / ● / 4 / CT_CLK0
DOUT3 / 5 / ● / ● / 6 / DOUT2
DOUT1 / 7 / ● / ● / 8 / DOUT0
DIN3 / 9 / ● / ● / 10 / CT_GATE0 / DIN2
DIN1 / 11 / ● / ● / 12 / TRIG / DIN0
DGND / 13 / ● / ● / 14 / SSH
-5V / 15 / ● / ● / 16 / No Connectio (NC)
No Connection (NC) / 17 / ● / ● / 18 / AGND
No Connection (NC) / 19 / ● / ● / 20 / AGND
CH7 LOW / CH15 / 21 / ● / ● / 22 / CH7 / CH7 HIGH
CH6 LOW / CH14 / 23 / ● / ● / 24 / CH6 / CH6 HIGH
CH5 LOW / CH13 / 25 / ● / ● / 26 / CH5 / CH5 HIGH
CH4 LOW / CH12 / 27 / ● / ● / 28 / CH4 / CH4 HIGH
CH3 LOW / CH11 / 29 / ● / ● / 30 / CH3 / CH3 HIGH
CH2 LOW / CH10 / 31 / ● / ● / 32 / CH2 / CH2 HIGH
CH1 LOW / CH9 / 33 / ● / ● / 34 / CH1 / CH1 HIGH
CH0 LOW / CH8 / 35 / ● / ● / 36 / CH0 / CH0 HIGH
AGND / 37 / ● / ● / 38 / No Connectio (NC)
No Connection (NC) / 39 / ● / ● / 40 / No Connectio (NC)
DM6620 (DAC)
AOUT1 / 1 / ● / ● / 2 / ANALOG GND
AOUT2 / 3 / ● / ● / 4 / ANALOG GND
AOUT3 / 5 / ● / ● / 6 / ANALOG GND
AOUT4 / 7 / ● / ● / 8 / ANALOG GND
DAC1 DATA MARKER / 9 / ● / ● / 10 / DIGITAL GND
DAC2 DATA MARKER / 11 / ● / ● / 12 / DIGITAL GND
DAC3 DATA MARKER / 13 / ● / ● / 14 / DIGITAL GND
DAC4 DATA MARKER / 15 / ● / ● / 16 / DIGITAL GND
N.C. / 17 / ● / ● / 18 / DIGITAL GND
EXT INT / 19 / ● / ● / 20 / DIGITAL GND
DIGITAL GND / 21 / ● / ● / 22 / DIGITAL GND
P0.7 / 23 / ● / ● / 24 / P1.7
P0.6 / 25 / ● / ● / 26 / P1.6
P0.5 / 27 / ● / ● / 28 / P1.5
P0.4 / 29 / ● / ● / 30 / P1.4
P0.3 / 31 / ● / ● / 32 / P1.3
P0.2 / 33 / ● / ● / 34 / P1.2
P0.1 / 35 / ● / ● / 36 / P1.1
P0.0 / 37 / ● / ● / 38 / P1.0
EXT CLK / 39 / ● / ● / 40 / DIGITAL GND
EXT GATE 0 / 41 / ● / ● / 42 / CLK OUT 0
EXT GATE 1 / 43 / ● / ● / 44 / CLK OUT 1
EXT GATE 2 / 45 / ● / ● / 46 / CLK OUT 2
+12 VOLTS / 47 / ● / ● / 48 / +5 VOLTS
-12 VOLTS / 49 / ● / ● / 50 / DIGITAL GND

Appendix C

First Yale Card Analysis without using Geoff.

(Results from only Yale cards 1, 2, 3, 5 and 11)

NOTE: r := range in mV

yale01.1x.DAT : gain = 1.14771 +/- 0.00003 | 50.47 < r < 250.42 ,

-50.26 > r > -250.57

yale01.20x.DAT : gain = 23.65696 +/- 0.06047 | 50.80 < r < 200.56 ,

-50.00 > r > -201.44

yale01.50x.DAT : gain = 57.55023 +/- 0.03128 | 50.13 < r < 148.70 ,

-51.79 > r > -111.06

yale02.1x.DAT : gain = 1.14693 +/- 0.00004 | 50.15 < r < 449.56 ,

-51.60 > r > -298.29

yale02.20x.DAT : gain = 23.24514 +/- 0.01002 | 49.83 < r < 401.10 ,

-49.82 > r > -400.17

yale02.50x.DAT : gain = 57.98190 +/- 0.53004 | 6.05 < r < 140.09 ,

-6.18 > r > -124.05

yale03.1x.DAT : gain = 1.15029 +/- 0.00009 | 49.67 < r < 400.42 ,

-51.15 > r > -403.10

yale03.20x.DAT : gain = 23.42598 +/- 0.01902 | 51.39 < r < 398.34 ,

-51.30 > r > -400.72

yale03.50x.DAT : gain = 57.77706 +/- 0.05770 | 50.40 < r < 139.80 ,

-50.34 > r > -100.25

yale05.1x.DAT : gain = 1.15021 +/- 0.00004 | 51.77 < r < 402.23 ,

-50.86 > r > -398.66

yale05.20x.DAT : gain = 23.44134 +/- 0.00812 | 49.90 < r < 401.16 ,

-49.04 > r > -402.70

yale05.50x.DAT : gain = 57.66034 +/- 0.19344 | 50.94 < r < 150.94 ,

-49.58 > r > -112.55

yale11.1x.DAT : gain = 1.15091 +/- 0.00046 | 51.77 < r < 398.69 ,

-50.46 > r > -402.45

yale11.20x.DAT : gain = 24.35327 +/- 0.01658 | 51.54 < r < 400.62 ,

-52.00 > r > -349.69

yale11.50x.DAT : gain = 60.37580 +/- 0.01402 | 31.79 < r < 102.40 ,

-20.92 > r > -99.46

1

[1] They can be found in SPIN at/home/exp/b28/geoff/manuals/dm6620.pdfand in the same directory but with file namestratus-x-nd_manual_revg.pdf

[2] The file containing these raw data is ‘090905yale08.20x.dat’