// v1View.cpp : implementation of the CV1View class
//

//
// RomaNets Software, RomaNets Hardware, 2003
//
//
//


#include "stdafx.h"
#include "v1.h"

#include "v1Doc.h"
#include "v1View.h"

#include <conio.h>
#include <math.h>


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



int			g_Y[320];
bool		g_bPause = false;
bool		g_bRecord = false;
CByteArray	g_aRecData;



unsigned char n,f,e;
int		b,g;
double	d;
double	d256;


///////////////////////////////////////////////////////////////////////////////
void Init_ADC()
///////////////////////////////////////////////////////////////////////////////
{

	b	= 0x3F8;
	n	= 8;
	
	_outp( b+4, 1);
	//delay(100);
	Sleep(100);
	//int i;
	//for ( i=0; i<2000000; i++)
	//	;

	_outp( b+3, 64);
	//delay(500);
	Sleep(500);
	//for ( i=0; i<20000000; i++)
	//	;

}


///////////////////////////////////////////////////////////////////////////////
void Acquisition()
///////////////////////////////////////////////////////////////////////////////
{
	_outp( b+4, 0);
	d = 0;
	
	for ( f=0; f < n; f++ )
	{
		_outp( b+4, 2);
		e = _inp( b+6) & 16;
		_outp( b+4, 0);
		
		if ( e == 16)
			d = d + exp((n-1-f)*log(2));
	}

	d256 = d;
	d = (5*d)/(exp((n)*log(2))-1);
	
	_outp( b+4, 1);
}


///////////////////////////////////////////////////////////////////////////////
int Get_ADC_8Bit_Data()
///////////////////////////////////////////////////////////////////////////////
{
	Acquisition();

	return  (int(100*d)) / 1 - 248;
}







///////////////////////////////////////////////////////////////////////////////
//
// LEDDisp0.cpp
//
// RomaNets Software, RomaNets Hardware, May 2003
//
//
// This prog is for "RNTH_#10_PCCOM+LEDDisplay"
//
//
///////////////////////////////////////////////////////////////////////////////

// RNS_NOTES:
//
// COM1 Base port: 0x3F8
// COM2 Base port: 0x2F8
//
// B+4 - [MCR] (Modem control register)
//			bit_0 - DTRC (Data terminal ready control)
//					0 - -12V								xxxxxxx0	0
//					1 - +12V								xxxxxxx1	1
//			pin4 on DB9
//			We use this bit as [DATA] for LEDDisplay
//
//			bit_1 - RTSC (Request to send control)
//					0 - -12V								xxxxxx0x	0
//					1 - +12V								xxxxxx1x	2
//			pin7 on DB9
//			We use this bit as [CLOCK] for LEDDisplay
//
//			000000xx
//				  __
//				  ||
//			CLOCK || DATA
//		__________||__________
//
//
// B+3 - [LCR] (Line control register)
//			bit_6 - BRCON (Break control)
//					1 - +12V on TXD ( Transmit data)		x1xxxxxx	0x40	64
//			pin3 on DB9
//			We might be used this bit as [+12V] for circuit
//
// B+6 - [MSR] (Modem status register)
//			bit_4 - state of the line CTS (Clear to send)
//					0 - -12V								xxx0xxxx	0x00
//					1 - +12V								xxx1xxxx	0x10	16
//			pin8 on DB9
//			We might be used this bit as [input DATA] from circuit


//#include <stdio.h>
//#include <conio.h>
//#include <dos.h>



// DB9 pins ///////////////////////////////////////////////////////////////////
//
#define COM1			0x3F8
#define COM2			0x2F8
#define BASE_PORT		COM1
#define MCR				(BASE_PORT + 4)
#define LCR				(BASE_PORT + 3)
#define DATA_PORT		MCR
#define CLOCK_PORT		MCR
#define DATA_CLOCK_PORT	MCR
#define CLOCK_UP		2
#define CLOCK_DOWN		0
#define DATA_UP			1
#define DATA_DOWN		0
#define LEDSEGMENT_OFF	DATA_UP
#define LEDSEGMENT_ON	DATA_DOWN



// GLOBAL FUNCTION PROTOTYPES /////////////////////////////////////////////////
//
int convert( int digit);
void loader( int digit);
void segment_off();
void segment_on();
void mydelay();



//#define NOTHING	loader( convert( 17));\
//	delay( 500);\
//	loader( convert( 17));\
//	delay( 500);\
//	loader( convert( 17));\
//	delay( 500);\
//	loader( convert( 17));\
//	delay( 500);\
//

/*
void main()
{

	loader( convert( 17));
	loader( convert( 17));
	loader( convert( 17));
	loader( convert( 17));


	while ( 1 )
	{
		if ( kbhit() )
		{
			int ch;
			ch = getch();

			switch ( ch )
			{
			case 27:
				return;

			case '1':
				loader( convert( 1));
				break;
			case '2':
				loader( convert( 2));
				break;
			case '3':
				loader( convert( 3));
				break;
			case '4':
				loader( convert( 4));
				break;
			case '5':
				loader( convert( 5));
				break;
			case '6':
				loader( convert( 6));
				break;
			case '7':
				loader( convert( 7));
				break;
			case '8':
				loader( convert( 8));
				break;
			case '9':
				loader( convert( 9));
				break;
			case '0':
				loader( convert( 0));
				break;

			case 'a':
			case 'A':
				loader( convert( 10));
				break;
			case 'b':
			case 'B':
				loader( convert( 11));
				break;
			case 'c':
			case 'C':
				loader( convert( 12));
				break;
			case 'd':
			case 'D':
				loader( convert( 13));
				break;
			case 'e':
			case 'E':
				loader( convert( 14));
				break;
			case 'f':
			case 'F':
				loader( convert( 15));
				break;


			case ' ':					// SPACE
				loader( convert( 17));
				break;
			case 13:					// ENTER
				loader( convert( 17));
				loader( convert( 17));
				loader( convert( 17));
				loader( convert( 17));
				break;

			}
		}
	}

} // main
*/



///////////////////////////////////////////////////////////////////////////////
int convert( int digit)
///////////////////////////////////////////////////////////////////////////////
{
	int data = 0;

	switch ( digit )
	{
	case 0:
		data = 0x3F;
		break;
	case 1:
		data = 0x06;
		break;
	case 2:
		data = 0x5B;
		break;
	case 3:
		data = 0x4F;
		break;
	case 4:
		data = 0x66;
		break;
	case 5:
		data = 0x6D;
		break;
	case 6:
		data = 0x7D;
		break;
	case 7:
		data = 0x07;
		break;
	case 8:
		data = 0x7F;
		break;
	case 9:
		data = 0x6F;
		break;
	case 10:			//A
		data = 0x77;
		break;
	case 11:			// b
		data = 0x7C;
		break;
	case 12:			// C
		data = 0x39;
		break;
	case 13:			// d
		data = 0x5E;
		break;
	case 14:			// E
		data = 0x79;
		break;
	case 15:			// F
		data = 0x71;
		break;
	case 16:			// .
		data = 0x80;
		break;
	case 17:			// nothing
		data = 0x00;
		break;
	case 18:			// -
		data = 0x40;
		break;
	}

	//return data ^ 0xFF;
	return data;

} // convert


/*
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Must be in first 256 address bank
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
convert
	addwf	PCL, f
	retlw	b'00111111'	; 0					0x3F
	retlw	b'00000110'	; 1					0x06
	retlw	b'01011011'	; 2					0x5B
	retlw	b'01001111'	; 3					0x4F
	retlw	b'01100110'	; 4					0x66
	retlw	b'01101101'	; 5					0x6D
	retlw	b'01111101'	; 6					0x7D
	retlw	b'00000111'	; 7					0x07
	retlw	b'01111111'	; 8					0x7F
	retlw	b'01101111'	; 9					0x6F
	retlw	b'01110111'	; A			10		0x77
	retlw	b'01111100'	; b			11		0x7C
	retlw	b'00111001'	; C			12		0x39
	retlw	b'01011110'	; d			13		0x5E
	retlw	b'01111001'	; E			14		0x79
	retlw	b'01110001'	; F			15		0x71
	retlw	b'10000000'	; .			16		0x80
	retlw	b'00000000'	; nothing	17		0x00
	retlw	b'01000000'	; -			18		0x40
	;retlw	b'01110011'	; P			15
	;retlw	b'01110110'	; H			16
;--------------------------------------
						;  _
	;retlw	b'00110111'	; | |		17
						; | |
						;
;--------------------------------------
						;  _
	;retlw	b'01100011'	; |_|		18
						;
						;
;--------------------------------------
						;
	;retlw	b'01011100'	;			19
						;  _
						; |_|
;--------------------------------------
						;  _
	;retlw	b'00110001'	; | 		20
						; | 
						;
;--------------------------------------
;--------------------------------------
;--------------------------------------
;--------------------------------------

;
; End convert subroutin ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
*/



//;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
//;
//; 0) For every bit in byte
//; 1) Set Sync to 0
//; 2) Set Data X (0 or 1)
//; 3) Set Sync to 1
//;
//; Source V.S. Jatsenkov p.263
//;
///////////////////////////////////////////////////////////////////////////////
void loader( int digit)
///////////////////////////////////////////////////////////////////////////////
{
	int mask = 0x80;

	for ( int i=0; i<8; i++ )
	{
		if ( mask == (digit & mask) )
			segment_on();
		else
			segment_off();
		
		mask >>= 1;

	}
}



///////////////////////////////////////////////////////////////////////////////
void segment_off()
///////////////////////////////////////////////////////////////////////////////
{
	unsigned char D;

		D = LEDSEGMENT_OFF;

		_asm {
			mov dx, DATA_CLOCK_PORT
			mov al, CLOCK_DOWN		// -_
			or al, D				// set data
			out dx, al
		}
		mydelay();
	
		_asm {
			mov dx, DATA_CLOCK_PORT
			mov al,CLOCK_UP			// _-
			or al, D
			out dx, al
		}
		mydelay();

}

///////////////////////////////////////////////////////////////////////////////
void segment_on()
///////////////////////////////////////////////////////////////////////////////
{
	unsigned char D;

		D = LEDSEGMENT_ON;

		_asm {
			mov dx, DATA_CLOCK_PORT
			mov al, CLOCK_DOWN		// -_
			or al, D				// set data
			out dx, al
		}
		mydelay();
	
		_asm {
			mov dx, DATA_CLOCK_PORT
			mov al,CLOCK_UP			// _-
			or al, D
			out dx, al
		}
		mydelay();

}


///////////////////////////////////////////////////////////////////////////////
void mydelay()
///////////////////////////////////////////////////////////////////////////////
{
    // P4 1600 MHz:
	// if max_i == 2000
    // CLOCK: -_-_-_-_-_-_-_-_------------------ ... -_-_-_-_-_-_-_-_------------------
    //         |-|                                    |
    //          6 mks                                 |
    //          |-------------------------------------|
    //                          30 ms

	//for ( int i=0; i<2000; i++)
	//	;

	for ( int i=0; i<2000; i++)
		;

	//delay(1);
}







/////////////////////////////////////////////////////////////////////////////
// CV1View

IMPLEMENT_DYNCREATE(CV1View, CView)

BEGIN_MESSAGE_MAP(CV1View, CView)
	//{{AFX_MSG_MAP(CV1View)
	ON_WM_ERASEBKGND()
	ON_COMMAND(ID_BUTTON_1, OnButton1)
	ON_UPDATE_COMMAND_UI(ID_BUTTON_1, OnUpdateButton1)
	ON_COMMAND(ID_BUTTON_A, OnButtonA)
	ON_UPDATE_COMMAND_UI(ID_BUTTON_A, OnUpdateButtonA)
	ON_WM_TIMER()
	ON_WM_DESTROY()
	ON_COMMAND(ID_BUTTON_PAUSE, OnButtonPause)
	ON_UPDATE_COMMAND_UI(ID_BUTTON_PAUSE, OnUpdateButtonPause)
	ON_COMMAND(ID_BUTTON_RECORD, OnButtonRecord)
	ON_UPDATE_COMMAND_UI(ID_BUTTON_RECORD, OnUpdateButtonRecord)
	ON_COMMAND(ID_BUTTON_STOP_RECORD, OnButtonStopRecord)
	ON_UPDATE_COMMAND_UI(ID_BUTTON_STOP_RECORD, OnUpdateButtonStopRecord)
	//}}AFX_MSG_MAP
	// Standard printing commands
	ON_COMMAND(ID_FILE_PRINT, CView::OnFilePrint)
	ON_COMMAND(ID_FILE_PRINT_DIRECT, CView::OnFilePrint)
	ON_COMMAND(ID_FILE_PRINT_PREVIEW, CView::OnFilePrintPreview)
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CV1View construction/destruction

CV1View::CV1View()
{
	// TODO: add construction code here
		// open com 1

	Open_Serial( COM_1,
				 //SER_BAUD_600,
				 //SER_BAUD_1200,
				 //SER_BAUD_9600,
				 SER_BAUD_19200,
				 SER_PARITY_NONE | SER_BITS_8 | SER_STOP_1);


	srand( time( NULL));

	for ( int i=0; i<140; i++)
	{
		g_Y[i] = rand()%50;
	}

	Init_ADC();

}


//=============================================================================
CV1View::~CV1View()
//=============================================================================
{
	Close_Serial(COM_1);			// close the connection and blaze

	// Save recorded sound data to file

	CFileException e;
	CFile myFile;
	if ( !myFile.Open( "_snd_test.dat",
						CFile::modeCreate | CFile::modeWrite | CFile::typeBinary,
						&e) )
		MessageBeep(-1);

	CArchive ar(&myFile, CArchive::store);
	g_aRecData.Serialize( ar);
	
	//ar << m_nPositionX;							// save last map position
	//ar << m_nPositionY;
	ar.Close();
	myFile.Close(); 


	// 10 sec sound file: address of the last file byte  = 0x014859

	

}



BOOL CV1View::PreCreateWindow(CREATESTRUCT& cs)
{
	// TODO: Modify the Window class or styles here by modifying
	//  the CREATESTRUCT cs

	return CView::PreCreateWindow(cs);
}

/////////////////////////////////////////////////////////////////////////////
// CV1View drawing

void CV1View::OnDraw(CDC* pDC)
{
	CV1Doc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);
	// TODO: add draw code for native data here


	CRect r( 10,200, 15, 205);
	



	// create and select a thick, black pen
	CPen penGreen;
	penGreen.CreatePen(PS_SOLID, 3, RGB(0, 255, 0));
	CPen* pOldPen = pDC->SelectObject(&penGreen);


//	pDC->MoveTo( r.left + r.Width()/2, r.top + r.Height()/2);
//	pDC->LineTo( 300, 300);




	// create and select a solid blue brush
	CBrush brushGreen(RGB(0, 255, 0));
	CBrush* pOldBrush = pDC->SelectObject(&brushGreen);


	for ( int i=0; i<140; i++)
	{
	//	pDC->RoundRect( &r, CPoint( 5,5));
		pDC->MoveTo( r.left + r.Width()/2, r.top + r.Height()/2);

		r.OffsetRect( 5, 0);
		r.top = 200 + g_Y[i];
		r.bottom = r.top + 5;


		pDC->LineTo( r.left + r.Width()/2, r.top + r.Height()/2);

	}


	CString str;
	str.Format( "%d", g_aRecData.GetSize() );

	pDC->TextOut( 10,10, str);



	//CPoint pt = pDC->GetCurrentPosition();	
	//r.OffsetRect( 300-10,300-10);
	//pDC->Rectangle( &r);
	//pDC->RoundRect( &r, CPoint( 10,10));


	// put back the old objects
	pDC->SelectObject(pOldBrush);
	pDC->SelectObject(pOldPen);





}

/////////////////////////////////////////////////////////////////////////////
// CV1View printing

BOOL CV1View::OnPreparePrinting(CPrintInfo* pInfo)
{
	// default preparation
	return DoPreparePrinting(pInfo);
}

void CV1View::OnBeginPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
	// TODO: add extra initialization before printing
}

void CV1View::OnEndPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
	// TODO: add cleanup after printing
}

/////////////////////////////////////////////////////////////////////////////
// CV1View diagnostics

#ifdef _DEBUG
void CV1View::AssertValid() const
{
	CView::AssertValid();
}

void CV1View::Dump(CDumpContext& dc) const
{
	CView::Dump(dc);
}

CV1Doc* CV1View::GetDocument() // non-debug version is inline
{
	ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CV1Doc)));
	return (CV1Doc*)m_pDocument;
}
#endif //_DEBUG

/////////////////////////////////////////////////////////////////////////////
// CV1View message handlers

BOOL CV1View::OnEraseBkgnd(CDC* pDC) 
{
	// TODO: Add your message handler code here and/or call default
	
	CRect r;
	GetClientRect( &r);
	
	CBrush brush;
	brush.CreateSolidBrush( 0);
	CBrush * pOldBrush = pDC->SelectObject( &brush);

	pDC->Rectangle( r);

	pDC->SelectObject( pOldBrush);

	//return CView::OnEraseBkgnd(pDC);
	return TRUE;
}


void CV1View::OnButton1() 
{
	// TODO: Add your command handler code here


	if ( !g_bPause )
		MessageBox( "Pause the oscilloscope to see the action");

	// This code is for LEDDisplay
	static int n = 0;
	loader( convert( n++));

	if ( n > 17 )
		n = 0;
	
}


void CV1View::OnUpdateButton1(CCmdUI* pCmdUI) 
{
	// TODO: Add your command update UI handler code here
	
}

//=============================================================================
void CV1View::OnButtonA()
//=============================================================================
{
	// TODO: Add your command handler code here

	// This code is for ADC8

	for ( int i=0; i<140; i++)
	{
		//g_Y[i] = rand()%50;

		int y = Get_ADC_8Bit_Data();
		g_Y[i] = y;

		if ( g_bRecord )
		{
			g_aRecData.Add( BYTE(d256) );
		}


	}

	Invalidate();
	
}

void CV1View::OnUpdateButtonA(CCmdUI* pCmdUI) 
{
	// TODO: Add your command update UI handler code here
	
}


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

	if ( !g_bPause )
	{
		//MessageBeep(-1);
		OnButtonA();
	}
	
	CView::OnTimer(nIDEvent);
}


//=============================================================================
void CV1View::OnInitialUpdate() 
//=============================================================================
{
	CView::OnInitialUpdate();
	
	// TODO: Add your specialized code here and/or call the base class

	SetTimer( 0, 1, NULL);
}


//=============================================================================
void CV1View::OnDestroy() 
//=============================================================================
{
	CView::OnDestroy();
	
	// TODO: Add your message handler code here
	if ( !KillTimer( 0) )
		MessageBeep(-1);

	
}


//=============================================================================
void CV1View::OnButtonPause() 
//=============================================================================
{
	// TODO: Add your command handler code here
	
	g_bPause = !g_bPause;
}

void CV1View::OnUpdateButtonPause(CCmdUI* pCmdUI) 
{
	// TODO: Add your command update UI handler code here
	
}


//=============================================================================
void CV1View::OnButtonRecord() 
//=============================================================================
{
	// TODO: Add your command handler code here

	g_aRecData.RemoveAll();
	g_bRecord = true;
	
}

void CV1View::OnUpdateButtonRecord(CCmdUI* pCmdUI) 
{
	// TODO: Add your command update UI handler code here

	pCmdUI->Enable( !g_bRecord);
	
}


//=============================================================================
void CV1View::OnButtonStopRecord() 
//=============================================================================
{
	// TODO: Add your command handler code here

	g_bRecord = false;
	
}

void CV1View::OnUpdateButtonStopRecord(CCmdUI* pCmdUI) 
{
	// TODO: Add your command update UI handler code here
	pCmdUI->Enable( g_bRecord);
	
}