// sample0Dlg.cpp : implementation file
//

#include "stdafx.h"
#include "sample0.h"
#include "sample0Dlg.h"
#include "ACCES32.H"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif


#define TIMER_ID 0
#define LAPSE 500 //how many milliseconds for the timer

/*************************************************************
** These global variables are used by the functions that are common
** to this board. They are also utilized by functions within the dialog box
*************************************************************/ 


unsigned int BASE=0x300; //base address of card
unsigned short jumpers; //the jumper settings of the card. Only bits 0-4 should be used. Status information should
						//be read from the board immediately before use
unsigned char adrange;	//bits 0-3 are equal to bits 0-3 of the jumpers variable.
unsigned char dacBrange; //if this is 0 then DAC1 is set to 0-10 volt range
unsigned char dacArange; //if this is 0 then DAC0 is set to 0-10 volt range

/*************************************************************
** The following function declarations include some common operations
** for this board.
*************************************************************/

unsigned char sbitd(unsigned int data,unsigned char bit);
double DAC(unsigned char DACnum,double DACV);
void EEPROM_Enable(void);
void EEPROM_Disable(void);
void EEPROM_Write(unsigned int addr,unsigned int data);
unsigned int EEPROM_Read(unsigned int addr);
void CAL_ADC(unsigned char M,unsigned char B);
void CALWrite(unsigned zAM,unsigned zAB,unsigned zDAM,unsigned zDBM);
void doCAL(void);
void init(void);
double readAD();





/////////////////////////////////////////////////////////////////////////////
// CSample0Dlg dialog

CSample0Dlg::CSample0Dlg(CWnd* pParent /*=NULL*/)
	: CDialog(CSample0Dlg::IDD, pParent)
{
	//{{AFX_DATA_INIT(CSample0Dlg)
	m_dac0LBL = _T("");
	m_dac1LBL = _T("");
	//}}AFX_DATA_INIT
	// Note that LoadIcon does not require a subsequent DestroyIcon in Win32
	m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
	dac0out = dac1out = 0;
}

void CSample0Dlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CSample0Dlg)
	DDX_Control(pDX, IDC_BUTTON_STOP, m_stopBTN);
	DDX_Control(pDX, IDC_EDIT_DAC1, m_dac1EDIT);
	DDX_Control(pDX, IDC_EDIT_DAC0, m_dac0EDIT);
	DDX_Control(pDX, IDC_EDIT_CHN8, m_chn8EDIT);
	DDX_Control(pDX, IDC_EDIT_CHN7, m_chn7EDIT);
	DDX_Control(pDX, IDC_EDIT_CHN6, m_chn6EDIT);
	DDX_Control(pDX, IDC_EDIT_CHN5, m_chn5EDIT);
	DDX_Control(pDX, IDC_EDIT_CHN4, m_chn4EDIT);
	DDX_Control(pDX, IDC_EDIT_CHN3, m_chn3EDIT);
	DDX_Control(pDX, IDC_EDIT_CHN2, m_chn2EDIT);
	DDX_Control(pDX, IDC_EDIT_CHN15, m_chn15EDIT);
	DDX_Control(pDX, IDC_EDIT_CHN14, m_chn14EDIT);
	DDX_Control(pDX, IDC_EDIT_CHN13, m_chn13EDIT);
	DDX_Control(pDX, IDC_EDIT_CHN12, m_chn12EDIT);
	DDX_Control(pDX, IDC_EDIT_CHN11, m_chn11EDIT);
	DDX_Control(pDX, IDC_EDIT_CHN9, m_chn9EDIT);
	DDX_Control(pDX, IDC_EDIT_CHN10, m_chn10EDIT);
	DDX_Control(pDX, IDC_EDIT_CHN1, m_chn1EDIT);
	DDX_Control(pDX, IDC_EDIT_CHN0, m_chn0EDIT);
	DDX_Control(pDX, IDC_EDIT_ADDR, m_addrEDIT);
	DDX_Control(pDX, IDC_BUTTON_BEGIN, m_beginBTN);
	DDX_Text(pDX, IDC_DAC0_LBL, m_dac0LBL);
	DDX_Text(pDX, IDC_DAC1_LBL, m_dac1LBL);
	//}}AFX_DATA_MAP
}

BEGIN_MESSAGE_MAP(CSample0Dlg, CDialog)
	//{{AFX_MSG_MAP(CSample0Dlg)
	ON_WM_PAINT()
	ON_WM_QUERYDRAGICON()
	ON_BN_CLICKED(IDC_BUTTON_BEGIN, OnButtonBegin)
	ON_WM_TIMER()
	ON_NOTIFY(UDN_DELTAPOS, IDC_SPIN_DAC0, OnDeltaposSpinDac0)
	ON_NOTIFY(UDN_DELTAPOS, IDC_SPIN_DAC1, OnDeltaposSpinDac1)
	ON_BN_CLICKED(IDC_BUTTON_STOP, OnButtonStop)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CSample0Dlg message handlers

BOOL CSample0Dlg::OnInitDialog()
{
	CDialog::OnInitDialog();

	// Set the icon for this dialog.  The framework does this automatically
	//  when the application's main window is not a dialog
	SetIcon(m_hIcon, TRUE);			// Set big icon
	SetIcon(m_hIcon, FALSE);		// Set small icon
	
	// TODO: Add extra initialization here
	
	m_addrEDIT.SetWindowText("300");
	m_stopBTN.EnableWindow(false);

	return TRUE;  // return TRUE  unless you set the focus to a control
}

// If you add a minimize button to your dialog, you will need the code below
//  to draw the icon.  For MFC applications using the document/view model,
//  this is automatically done for you by the framework.

void CSample0Dlg::OnPaint() 
{
	if (IsIconic())
	{
		CPaintDC dc(this); // device context for painting

		SendMessage(WM_ICONERASEBKGND, (WPARAM) dc.GetSafeHdc(), 0);

		// Center icon in client rectangle
		int cxIcon = GetSystemMetrics(SM_CXICON);
		int cyIcon = GetSystemMetrics(SM_CYICON);
		CRect rect;
		GetClientRect(&rect);
		int x = (rect.Width() - cxIcon + 1) / 2;
		int y = (rect.Height() - cyIcon + 1) / 2;

		// Draw the icon
		dc.DrawIcon(x, y, m_hIcon);
	}
	else
	{
		CDialog::OnPaint();
	}
}

// The system calls this to obtain the cursor to display while the user drags
//  the minimized window.
HCURSOR CSample0Dlg::OnQueryDragIcon()
{
	return (HCURSOR) m_hIcon;
}


/**************************************************************
** This function performs the following operations:
** 1) Get base address from user.
** 2) initialize global variables and calibrate the card
** 3) Determine DAC ranges and pass them on to the user
** 4) Determine the number of channels and store that value for later use
** 5) Tell the board which channels will be scanned
** 6) Tell the board that conversions will be software driven
** 7) Disable the start button and enable the stop button on the window
** 8) Start the timer
*************************************************************/



void CSample0Dlg::OnButtonBegin() 
{
	// TODO: Add your control notification handler code here
	CString addr;
	char *buf;

	//////////////////////////////////////////
	// 1) Get base address from user.

	m_addrEDIT.GetWindowText(addr);
	buf = addr.GetBuffer(5);
	sscanf(buf, "%x", &BASE);
	addr.ReleaseBuffer(-1);


	/////////////////////////////////////////
	// 2) initialize global variables and calibrate the card

	init();
	doCAL();

	/////////////////////////////////////////
	// 3) Determine DAC ranges and pass them on to the user

	if (dacArange)
		m_dac0LBL = "DAC 0 output Range is 0 to 5 volts";
	else
		m_dac0LBL = "DAC 0 output Range is 0 to 10 volts";

	if (dacBrange)
		m_dac1LBL = "DAC 1 output Range is 0 to 5 volts";
	else
		m_dac1LBL = "DAC 1 output Range is 0 to 10 volts";
	
	UpdateData(false);

	////////////////////////////////////////////
	// 4) Determine the number of channels and store that value for later use

	channels = jumpers & 0x01 ? 16 : 8;

	///////////////////////////////////////////
	// 5) Tell the board which channels will be scanned

	OutPortB(BASE + 0x02, (channels - 1) * 0x10); // bits 0-3 tell the board the start channel and bits 4-7 are the 
													// end channel


	//////////////////////////////////////////
	// 6) Tell the board that conversions will be software driven

	OutPortB(BASE + 0x01, 0); //reset FIFO
	OutPortB(BASE + 0x1A, 0x00); //enable software conversion start


	/////////////////////////////////////////
	// 7) Disable the start button and enable the stop button on the window

	m_beginBTN.EnableWindow(false);
	m_stopBTN.EnableWindow(true);

	///////////////////////////////////////
	// 8) Start the timer

	SetTimer(TIMER_ID, LAPSE, NULL);

}



/****************************************************
** This function performs the following functions
** 1) stop the timer
** 2) Take 1 reading per channel
** 3) retrieve the readings and display to the window
** 4) Send output to the DACs and display the sent value to the window
** 5) restart the timer
***************************************************/


void CSample0Dlg::OnTimer(UINT nIDEvent) 
{
	// TODO: Add your message handler code here and/or call default


	////////////////////////////////////////////////////////
	// 1) stop the timer
	KillTimer(TIMER_ID);

	double reading;
	char display[10];


	/////////////////////////////////////////////////////////
	// 2) Take 1 reading per channel

	for (int count = 0; count < channels; count++)
		OutPortB(BASE, 0);

	////////////////////////////////////////////////////////
	// 3) retrieve the readings and display to the window


	// it is possible to create control arrays with VC6, but doing so tends to break the class wizard
	// and should be attempted only by advanced programmers. So we have to do this the long way

	reading = readAD();
	sprintf(display, "%6f", reading);
	m_chn0EDIT.SetWindowText(display);
	
	reading = readAD();
	sprintf(display, "%6f", reading);
	m_chn1EDIT.SetWindowText(display);

	reading = readAD();
	sprintf(display, "%6f", reading);
	m_chn2EDIT.SetWindowText(display);

	reading = readAD();
	sprintf(display, "%6f", reading);
	m_chn3EDIT.SetWindowText(display);

	reading = readAD();
	sprintf(display, "%6f", reading);
	m_chn4EDIT.SetWindowText(display);

	reading = readAD();
	sprintf(display, "%6f", reading);
	m_chn5EDIT.SetWindowText(display);

	reading = readAD();
	sprintf(display, "%6f", reading);
	m_chn6EDIT.SetWindowText(display);

	reading = readAD();
	sprintf(display, "%6f", reading);
	m_chn7EDIT.SetWindowText(display);

	if (channels == 16)
	{
		reading = readAD();
		sprintf(display, "%6f", reading);
		m_chn8EDIT.SetWindowText(display);

		reading = readAD();
		sprintf(display, "%6f", reading);
		m_chn9EDIT.SetWindowText(display);

		reading = readAD();
		sprintf(display, "%6f", reading);
		m_chn10EDIT.SetWindowText(display);

		reading = readAD();
		sprintf(display, "%6f", reading);
		m_chn11EDIT.SetWindowText(display);

		reading = readAD();
		sprintf(display, "%6f", reading);
		m_chn12EDIT.SetWindowText(display);

		reading = readAD();
		sprintf(display, "%6f", reading);
		m_chn13EDIT.SetWindowText(display);

		reading = readAD();
		sprintf(display, "%6f", reading);
		m_chn14EDIT.SetWindowText(display);

		reading = readAD();
		sprintf(display, "%6f", reading);
		m_chn15EDIT.SetWindowText(display);
	}

	/////////////////////////////////////////////////////////////
	//4) Send output to the DACs and display the sent value to the window

	reading = DAC(0, (dacArange ? .49 * double(dac0out) : .99 * double(dac0out)));
	sprintf(display, "%6f", reading);	
	m_dac0EDIT.SetWindowText(display);

	reading = DAC(1, (dacArange ? .49 * double(dac1out) : .99 * double(dac1out)));
	sprintf(display, "%6f", reading);	
	m_dac1EDIT.SetWindowText(display);


	///////////////////////////////////////////////////////////////
	// 5) restart the timer

	SetTimer(TIMER_ID, LAPSE, NULL);

	CDialog::OnTimer(nIDEvent);
}


/****************************************************
** This function performs the following functions
** 1) determine if the user clicked the up or down button and adjust the dac multiplier
****************************************************/

void CSample0Dlg::OnDeltaposSpinDac0(NMHDR* pNMHDR, LRESULT* pResult) 
{
	NM_UPDOWN* pNMUpDown = (NM_UPDOWN*)pNMHDR;
	// TODO: Add your control notification handler code here

	////////////////////////////////////////////////
	// 1) determine if the user clicked the up or down button and adjust the dac multiplier

	//windows sends a negative delta for the up arrow and a positive delta for the down arrow. 

	pNMUpDown->iDelta > 0 ? dac0out-- : dac0out++;

	if (dac0out > 10)
		dac0out = 0;
	else if (dac0out < 0)
		dac0out = 10;
	
	*pResult = 0;
}

/****************************************************
** This function performs the following functions
** 1) determine if the user clicked the up or down button and adjust the dac multiplier
****************************************************/

void CSample0Dlg::OnDeltaposSpinDac1(NMHDR* pNMHDR, LRESULT* pResult) 
{
	NM_UPDOWN* pNMUpDown = (NM_UPDOWN*)pNMHDR;
	// TODO: Add your control notification handler code here
	
	////////////////////////////////////////////////
	// 1) determine if the user clicked the up or down button and adjust the dac multiplier

	//windows sends a negative delta for the up arrow and a positive delta for the down arrow. 


	pNMUpDown->iDelta > 0 ? dac1out-- : dac1out++;

	if (dac1out > 10)
		dac1out = 0;
	else if (dac1out < 0)
		dac1out = 10;

	*pResult = 0;
}

/****************************************************
** This function performs the following functions
** 1) Stop the timer
** 2) Disable the stop button and enable the start button
****************************************************/
void CSample0Dlg::OnButtonStop() 
{
	// TODO: Add your control notification handler code here

	//////////////////////////////////////////////////////////
	// 1) Stop the timer


	KillTimer(TIMER_ID);
	
	//////////////////////////////////////////////////////////
	// 2) Disable the stop button and enable the start button

	m_beginBTN.EnableWindow(true);
	m_stopBTN.EnableWindow(false);
	
}



//sbitd takes data and bit, then returns 0x81 or 0x01 based on data[bit]
unsigned char sbitd(unsigned int data,unsigned char bit)
{
  return (data & (1<<bit))?0x81:0x01;
}

//DAC will write to the selected DAC and returns the actual volts
//(as modified for 12-bit D/A)
//DACnum is 0 or 1
//DACV is volts
double DAC(unsigned char DACnum,double DACV)
{
  unsigned int count=DACV/((DACnum?dacBrange:dacArange)?5.0L:10.0L)*4096;
  count &= 0xFFF; //12-bit DAC
  
  OutPortB(BASE+9,0x81);//DAC load mode = software
  OutPortB(BASE+9,sbitd(DACnum + 1,1)|2);//DACnum bit 1
  OutPortB(BASE+9,sbitd(DACnum + 1,0)|2);//DACnum bit 0
  OutPortB(BASE+9,0x01);//unused bit
  OutPortB(BASE+9,sbitd(count,11));//data bit 11
  OutPortB(BASE+9,sbitd(count,10));//data bit 10
  OutPortB(BASE+9,sbitd(count,9));//data bit 9
  OutPortB(BASE+9,sbitd(count,8));//data bit 8
  OutPortB(BASE+9,sbitd(count,7));//data bit 7
  OutPortB(BASE+9,sbitd(count,6));//data bit 6
  OutPortB(BASE+9,sbitd(count,5));//data bit 5
  OutPortB(BASE+9,sbitd(count,4));//data bit 4
  OutPortB(BASE+9,sbitd(count,3));//data bit 3
  OutPortB(BASE+9,sbitd(count,2));//data bit 2
  OutPortB(BASE+9,sbitd(count,1));//data bit 1
  OutPortB(BASE+9,sbitd(count,0));//data bit 0
  OutPortB(BASE+9,0x00);//end trans
  OutPortB(BASE+9,0x02);//Load DACs
  return double(count)/4096.0L*((DACnum?dacBrange:dacArange)?5.0L:10.0L);//actual V}
}

// Enable the EEEPROM for writing

void EEPROM_Enable(void)
{
  OutPortB(BASE+0x0a,0x81);//start bit
  OutPortB(BASE+0x0a,0x01);//Opcode bit 0 (00 = enable/disable)
  OutPortB(BASE+0x0a,0x01);//Opcode bit 1  ""
  OutPortB(BASE+0x0a,0x81);//a5 (must be 1 to enable)
  OutPortB(BASE+0x0a,0x81);//a4 (must be 1 to enable)
  OutPortB(BASE+0x0a,0x01);//a3 (don't care because enable/disable)
  OutPortB(BASE+0x0a,0x01);//a2 (don't care because enable/disable)
  OutPortB(BASE+0x0a,0x01);//a1 (don't care because enable/disable)
  OutPortB(BASE+0x0a,0x01);//a0 (don't care because enable/disable)
  OutPortB(BASE+0x0a,0x00);//end trans
}

// Disable the EEPROM write 

void EEPROM_Disable(void)
{
  OutPortB(BASE+0x0a,0x81);//start bit
  OutPortB(BASE+0x0a,0x01);//Opcode bit 0 (00 = enable/disable)
  OutPortB(BASE+0x0a,0x01);//Opcode bit 1  ""
  OutPortB(BASE+0x0a,0x01);//a5 (must be 0 to disable)
  OutPortB(BASE+0x0a,0x01);//a4 (must be 0 to disable)
  OutPortB(BASE+0x0a,0x01);//a3 (don't care because enable/disable)
  OutPortB(BASE+0x0a,0x01);//a2 (don't care because enable/disable)
  OutPortB(BASE+0x0a,0x01);//a1 (don't care because enable/disable)
  OutPortB(BASE+0x0a,0x01);//a0 (don't care because enable/disable)
  OutPortB(BASE+0x0a,0x00);//end trans
}


// write the value in data to the EEPROM to the location specified by addr

void EEPROM_Write(unsigned int addr,unsigned int data)
{
  OutPortB(BASE+0x0a,0x81);//Start Bit
  OutPortB(BASE+0x0a,0x01);//Opcode Bit 0 (01=write)
  OutPortB(BASE+0x0a,0x81);//Opcode Bit 1  ""
  OutPortB(BASE+0x0a,sbitd(addr,5));//a5 (address to write to)
  OutPortB(BASE+0x0a,sbitd(addr,4));//a4
  OutPortB(BASE+0x0a,sbitd(addr,3));//a3
  OutPortB(BASE+0x0a,sbitd(addr,2));//a2
  OutPortB(BASE+0x0a,sbitd(addr,1));//a1
  OutPortB(BASE+0x0a,sbitd(addr,0));//a0
  OutPortB(BASE+0x0a,sbitd(data,15));//d15
  OutPortB(BASE+0x0a,sbitd(data,14));//d14
  OutPortB(BASE+0x0a,sbitd(data,13));//d13
  OutPortB(BASE+0x0a,sbitd(data,12));//d12
  OutPortB(BASE+0x0a,sbitd(data,11));//d11
  OutPortB(BASE+0x0a,sbitd(data,10));//d10
  OutPortB(BASE+0x0a,sbitd(data,9));//d9
  OutPortB(BASE+0x0a,sbitd(data,8));//d8
  OutPortB(BASE+0x0a,sbitd(data,7));//d7
  OutPortB(BASE+0x0a,sbitd(data,6));//d6
  OutPortB(BASE+0x0a,sbitd(data,5));//d5
  OutPortB(BASE+0x0a,sbitd(data,4));//d4
  OutPortB(BASE+0x0a,sbitd(data,3));//d3
  OutPortB(BASE+0x0a,sbitd(data,2));//d2
  OutPortB(BASE+0x0a,sbitd(data,1));//d1
  OutPortB(BASE+0x0a,sbitd(data,0));//d0
  OutPortB(BASE+0x0a,0x00);//end trans
  Sleep(20);
}

// read the value from the EEPROM at the location specified by addr and return it

unsigned int EEPROM_Read(unsigned int addr)
{
  unsigned int data=0;
  OutPortB(BASE+0x0a,0x81);//Start Bit
  OutPortB(BASE+0x0a,0x81);//Opcode Bit 0 (10=Read)
  OutPortB(BASE+0x0a,0x01);//Opcode Bit 1  ""
  OutPortB(BASE+0x0a,sbitd(addr,5));//a5 (address to write to)
  OutPortB(BASE+0x0a,sbitd(addr,4));//a4
  OutPortB(BASE+0x0a,sbitd(addr,3));//a3
  OutPortB(BASE+0x0a,sbitd(addr,2));//a2
  OutPortB(BASE+0x0a,sbitd(addr,1));//a1
  OutPortB(BASE+0x0a,sbitd(addr,0));//a0
//  delay(10);
//  InPortB(BASE+0x0a);//dummy bit
  data=(data<<1) | ((InPortB(BASE+0x0a) & 0x80)?1:0);//d15
  data=(data<<1) | ((InPortB(BASE+0x0a) & 0x80)?1:0);//d14
  data=(data<<1) | ((InPortB(BASE+0x0a) & 0x80)?1:0);//d13
  data=(data<<1) | ((InPortB(BASE+0x0a) & 0x80)?1:0);//d12
  data=(data<<1) | ((InPortB(BASE+0x0a) & 0x80)?1:0);//d11
  data=(data<<1) | ((InPortB(BASE+0x0a) & 0x80)?1:0);//d10
  data=(data<<1) | ((InPortB(BASE+0x0a) & 0x80)?1:0);//d9
  data=(data<<1) | ((InPortB(BASE+0x0a) & 0x80)?1:0);//d8
  data=(data<<1) | ((InPortB(BASE+0x0a) & 0x80)?1:0);//d7
  data=(data<<1) | ((InPortB(BASE+0x0a) & 0x80)?1:0);//d6
  data=(data<<1) | ((InPortB(BASE+0x0a) & 0x80)?1:0);//d5
  data=(data<<1) | ((InPortB(BASE+0x0a) & 0x80)?1:0);//d4
  data=(data<<1) | ((InPortB(BASE+0x0a) & 0x80)?1:0);//d3
  data=(data<<1) | ((InPortB(BASE+0x0a) & 0x80)?1:0);//d2
  data=(data<<1) | ((InPortB(BASE+0x0a) & 0x80)?1:0);//d1
  data=(data<<1) | ((InPortB(BASE+0x0a) & 0x80)?1:0);//d0
  OutPortB(BASE+0x0a,0x00);//end com
  return data;
}


// write the gain (M) and the offset (B) to the pots. y=Mx + B

void CAL_ADC(unsigned char M,unsigned char B)
{ //write cal to A/D, offset first, then slope
  OutPortB(BASE+0x0b,0x01);//a1 pot 00 is offset
  OutPortB(BASE+0x0b,0x01);//a0 ""
  OutPortB(BASE+0x0b,sbitd(B,7));//data bit 7 of offset
  OutPortB(BASE+0x0b,sbitd(B,6));//data bit 6 of offset
  OutPortB(BASE+0x0b,sbitd(B,5));//data bit 5 of offset
  OutPortB(BASE+0x0b,sbitd(B,4));//data bit 4 of offset
  OutPortB(BASE+0x0b,sbitd(B,3));//data bit 3 of offset
  OutPortB(BASE+0x0b,sbitd(B,2));//data bit 2 of offset
  OutPortB(BASE+0x0b,sbitd(B,1));//data bit 1 of offset
  OutPortB(BASE+0x0b,sbitd(B,0));//data bit 0 of offset
  OutPortB(BASE+0x0b,0x00);//end trans
  //write slope now
  OutPortB(BASE+0x0b,0x01);//a1 pot 01 is slope of A/D
  OutPortB(BASE+0x0b,0x81);//a0 pot 01 is slope of A/D
  OutPortB(BASE+0x0b,sbitd(M,7));//data bit 7 of slope
  OutPortB(BASE+0x0b,sbitd(M,6));//data bit 6 of slope
  OutPortB(BASE+0x0b,sbitd(M,5));//data bit 5 of slope
  OutPortB(BASE+0x0b,sbitd(M,4));//data bit 4 of slope
  OutPortB(BASE+0x0b,sbitd(M,3));//data bit 3 of slope
  OutPortB(BASE+0x0b,sbitd(M,2));//data bit 2 of slope
  OutPortB(BASE+0x0b,sbitd(M,1));//data bit 1 of slope
  OutPortB(BASE+0x0b,sbitd(M,0));//data bit 0 of slope
  OutPortB(BASE+0x0b,0x00);//end trans
}


// write the gain(M) for the specified DAC to the pots

void CAL_DAC(unsigned char DACNum,unsigned char M)
{
  OutPortB(BASE+0x0b,0x81);//a1 pot 10 is slope of DAC0
  OutPortB(BASE+0x0b,sbitd(DACNum,0));//a0 pot 11 is slope of DAC1
  OutPortB(BASE+0x0b,sbitd(M,7));//data bit 7 of slope
  OutPortB(BASE+0x0b,sbitd(M,6));//data bit 6 of slope
  OutPortB(BASE+0x0b,sbitd(M,5));//data bit 5 of slope
  OutPortB(BASE+0x0b,sbitd(M,4));//data bit 4 of slope
  OutPortB(BASE+0x0b,sbitd(M,3));//data bit 3 of slope
  OutPortB(BASE+0x0b,sbitd(M,2));//data bit 2 of slope
  OutPortB(BASE+0x0b,sbitd(M,1));//data bit 1 of slope
  OutPortB(BASE+0x0b,sbitd(M,0));//data bit 0 of slope
  OutPortB(BASE+0x0b,0x00);//end trans
}

// writes the current calibration values to the EEPROM. 

void CALWrite(unsigned zAM,unsigned zAB,unsigned zDAM,unsigned zDBM)
{
 EEPROM_Enable();
 EEPROM_Write((adrange+0),zAB);
 EEPROM_Write((adrange+8),zAM);
 EEPROM_Write((dacArange+0x10),zDAM);
 EEPROM_Write((dacBrange+0x12),zDBM);
 EEPROM_Disable();
}

// reads the calibration values from the EEPROM and write them to the pots
// this should be done before taking any readings from the board.

void doCAL(void)
{
  unsigned char zDAM, zDBM, zAM, zAB;

  zAB=EEPROM_Read((adrange+0))&0xff;  //byte 0-7 in EEPROM holds "B" for ADC
  zAM=EEPROM_Read((adrange+8))&0xff;  //byte 8-f in EEPROM holds "M" for ADC
  zDAM=EEPROM_Read((dacArange+0x10))&0xff; //byte x10,x11 in EEPROM holds "M" for DAC0
  zDBM=EEPROM_Read((dacBrange+0x12))&0xff; //byte x12,x13 in EEPROM holds "M" for DAC1
  CAL_DAC(0,zDAM);//write the calibration value from EEPROM to CAL Pots
  CAL_DAC(1,zDBM);// ""
  CAL_ADC(zAM,zAB);// ""

}

//reads the jumper config from the board and initializes the global variables

void init(void)
{
  jumpers=InPortB(BASE+0x08);//jumper configuration readback
  adrange=jumpers & 0x07;//d2,d1,d0 are 5/10, uni/bip, 16/8
  dacBrange=(jumpers>>3) & 0x01;//d4,d3 are 5/10 for daca,b
  dacArange=(jumpers>>4) & 0x01;
//  CAL();
}


// reads the next available value from the FIFO and converts it to volts before returning the reading

double readAD()
{
  //scale counts into AD Range Volts
	unsigned short data;

	data = InPort(BASE);

  return
	(double(data) / 65536.0
	- ((adrange&0x02)?0.5:0.0))   //Adjust for polarity jumper
	* ((adrange&0x04)?10.0:20.0) //Adjust for gain jumper
  ;
}