//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include <math.h>

#include "MainUnit.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
#include "acces32.h"
//---------------------------------------------------------------------------
#define RLD 0x80
#define XRLD 0x00
#define YRLD XRLD
#define Rst_BP 0x01
#define Rst_CTR 0x02
#define Rst_FLAGS 0x04
#define Rst_E 0x06
#define Trf_PR_CTR 0x08
#define Trf_CTR_OL 0x10
#define Trf_PS0_PSC 0x18

#define CMR 0xA0
#define XCMR 0x20
#define YCMR XCMR
#define BINCnt 0x00
#define BCDCnt 0x01
#define NrmCnt 0x00
#define RngLmt 0x02
#define NRcyc 0x04
#define ModN 0x06
#define NQDX 0x00
#define QDX1 0x08
#define QDX2 0x10
#define QDX4 0x18

#define IOR 0xC0
#define XIOR 0x40
#define YIOR 0x00
#define DisAB 0x00
#define EnAB 0x01
#define LCTR 0x00
#define LOL 0x02
#define RCTR 0x00
#define ABGate 0x04
#define CYBW 0x00
#define CPBW 0x08
#define CB_UPDN 0x10
#define IDX_ERR 0x18

#define IDR 0xE0
#define XIDR 0x60
#define YIDR XIDR
#define DisIDX 0x00
#define EnIDX 0x01
#define NIDX 0x00
#define PIDX 0x02
#define LIDX 0x00
#define RIDX 0x04


#define PI 3.141593

//---------------------------------------------------------------------------
void Init_7266(unsigned short Addr)
{
    unsigned long XCt;
    unsigned long YCt;

    for (int count = 0; count < 4; count++)
    {
    XCt = 0xFFFFFF;
    YCt = 0xFFFFFF;

	//Setup IOR reg
	OutPortB(Addr + 1, IOR + DisAB + LOL + ABGate + CYBW);

	//Setup RLD reg
	OutPortB(Addr + 1, RLD + Rst_BP + Rst_FLAGS);
	OutPortB(Addr + 0, 0x0);
	OutPortB(Addr + 2, 0x0);
	OutPortB(Addr + 1, RLD + Rst_E + Trf_PS0_PSC);
	OutPortB(Addr + 1, RLD + Rst_BP + Rst_CTR);

	//Setup IDR reg
	OutPortB(Addr + 1, IDR + EnIDX + NIDX + LIDX);

	//Setup CMR reg
	OutPortB(Addr + 1, CMR + BINCnt + ModN + QDX1);

	//Setup PR reg for modulo N counter to XCt
	OutPortB(Addr + 0, XCt);
        XCt >>= 8;
	OutPortB(Addr + 0, XCt);
        XCt >>= 8;
	OutPortB(Addr + 0, XCt);

	//Setup PR reg for modulo N counter to YCt
	OutPortB(Addr + 2, YCt);
        YCt >>= 8;
	OutPortB(Addr + 2, YCt);
        YCt >>= 8;
	OutPortB(Addr + 2, YCt);

	//Enable counters
	OutPortB(Addr + 1, IOR + EnAB);

    Addr += 4;
    }
}

void Write_7266_PR(unsigned short Addr, unsigned long Data)
{
	OutPortB(Addr + 1, RLD + Rst_BP);
	OutPortB(Addr + 0, Data);
	Data >>= 8;
	OutPortB(Addr + 0, Data);
	Data >>= 8;
	OutPortB(Addr + 0, Data);
}

int Read_7266_OL(unsigned short Addr)
{
	union pos_tag {		/* allows access of 32-bit integer as 4 bytes */
		int l;
		struct byte_tag {char b0; char b1; char b2; char b3;} byte;
	}
	pos;

  	OutPortB(Addr + 1, 0x10);	/* reset address pointer */
	OutPortB(Addr + 1, 0x01);	/* command to latch counter */
	pos.byte.b0 = InPortB(Addr);
	pos.byte.b1 = InPortB(Addr);
	pos.byte.b2 = InPortB(Addr);
	/* extend sign of position */
	if (pos.byte.b2 < 0) pos.byte.b3 = -1;
	else pos.byte.b3 = 0;
	
	return pos.l;

/*
	long Data = 0;
	unsigned char* pData = (unsigned char *)(&Data);
    unsigned char signTest;

	OutPortB(Addr + 1, RLD + Rst_BP + Trf_CTR_OL);
	*pData = InPortB(Addr + 0);
	++pData;
	*pData = InPortB(Addr + 0);
	++pData;
	*pData = InPortB(Addr + 0);

    signTest = *pData;

    if (signTest & 0x8) Data *= -1;

	return Data;
*/



}

unsigned char Get_7266_Flags(unsigned short Addr)
{
	return InPortB(Addr + 1);
}
//---------------------------------------------------------------------------
typedef TEdit* PEdit;
typedef TLabel* PLabel;
typedef TProgressBar* PProgressBar;
typedef TPaintBox* PPaintBox;
typedef TTrackBar* PTrackBar;
typedef TComboBox* PComboBox;
typedef TGroupBox* PGroupBox;
typedef TButton* PButton;

unsigned short Addr = 0x300;
PEdit ChEdit[8], LoadEdit[8], resolution[8];
PLabel rpmLabel[8], maxRpmGroupLabel[8], maxRpmBarLabel[8];
PProgressBar rpmBar[8];
PPaintBox paintBox[8];
PTrackBar trackBar[8];
PComboBox multBox[8];
PGroupBox gBoxes[8];
PButton setBtn[8];

//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
  ChEdit[0] = ChEdit0;
  ChEdit[1] = ChEdit1;
  ChEdit[2] = ChEdit2;
  ChEdit[3] = ChEdit3;
  ChEdit[4] = ChEdit4;
  ChEdit[5] = ChEdit5;
  ChEdit[6] = ChEdit6;
  ChEdit[7] = ChEdit7;

  rpmLabel[0] = chnl0Rpm;
  rpmLabel[1] = chnl1Rpm;
  rpmLabel[2] = chnl2Rpm;
  rpmLabel[3] = chnl3Rpm;
  rpmLabel[4] = chnl4Rpm;
  rpmLabel[5] = chnl5Rpm;
  rpmLabel[6] = chnl6Rpm;
  rpmLabel[7] = chnl7Rpm;

  rpmBar[0] = chnl0RpmBar;
  rpmBar[1] = chnl1RpmBar;
  rpmBar[2] = chnl2RpmBar;
  rpmBar[3] = chnl3RpmBar;
  rpmBar[4] = chnl4RpmBar;
  rpmBar[5] = chnl5RpmBar;
  rpmBar[6] = chnl6RpmBar;
  rpmBar[7] = chnl7RpmBar;

  channelControlBytes[0] = 1;
  channelControlBytes[1] = 3;
  channelControlBytes[2] = 5;
  channelControlBytes[3] = 7;
  channelControlBytes[4] = 9;
  channelControlBytes[5] = 11;
  channelControlBytes[6] = 13;
  channelControlBytes[7] = 15;

  paintBox[0] = chnl0PaintBox;
  paintBox[1] = chnl1PaintBox;
  paintBox[2] = chnl2PaintBox;
  paintBox[3] = chnl3PaintBox;
  paintBox[4] = chnl4PaintBox;
  paintBox[5] = chnl5PaintBox;
  paintBox[6] = chnl6PaintBox;
  paintBox[7] = chnl7PaintBox;

  resolution[0] = chn0ResEdit;
  resolution[1] = chn1ResEdit;
  resolution[2] = chn2ResEdit;
  resolution[3] = chn3ResEdit;
  resolution[4] = chn4ResEdit;
  resolution[5] = chn5ResEdit;
  resolution[6] = chn6ResEdit;
  resolution[7] = chn7ResEdit;

  trackBar[0] = chnl0Track;
  trackBar[1] = chnl1Track;
  trackBar[2] = chnl2Track;
  trackBar[3] = chnl3Track;
  trackBar[4] = chnl4Track;
  trackBar[5] = chnl5Track;
  trackBar[6] = chnl6Track;
  trackBar[7] = chnl7Track;

  maxRpmGroupLabel[0] = chnl0MaxRpmLbl;
  maxRpmGroupLabel[1] = chnl1MaxRpmLbl;
  maxRpmGroupLabel[2] = chnl2MaxRpmLbl;
  maxRpmGroupLabel[3] = chnl3MaxRpmLbl;
  maxRpmGroupLabel[4] = chnl4MaxRpmLbl;
  maxRpmGroupLabel[5] = chnl5MaxRpmLbl;
  maxRpmGroupLabel[6] = chnl6MaxRpmLbl;
  maxRpmGroupLabel[7] = chnl7MaxRpmLbl;

  maxRpmBarLabel[0] = chnl0Max;
  maxRpmBarLabel[1] = chnl1Max;
  maxRpmBarLabel[2] = chnl2Max;
  maxRpmBarLabel[3] = chnl3Max;
  maxRpmBarLabel[4] = chnl4Max;
  maxRpmBarLabel[5] = chnl5Max;
  maxRpmBarLabel[6] = chnl6Max;
  maxRpmBarLabel[7] = chnl7Max;

  multBox[0] = chnl0MultBox;
  multBox[1] = chnl1MultBox;
  multBox[2] = chnl2MultBox;
  multBox[3] = chnl3MultBox;
  multBox[4] = chnl4MultBox;
  multBox[5] = chnl5MultBox;
  multBox[6] = chnl6MultBox;
  multBox[7] = chnl7MultBox;

  gBoxes[0] = GroupBox0;
  gBoxes[1] = GroupBox1;
  gBoxes[2] = GroupBox2;
  gBoxes[3] = GroupBox3;
  gBoxes[4] = GroupBox4;
  gBoxes[5] = GroupBox5;
  gBoxes[6] = GroupBox6;
  gBoxes[7] = GroupBox7;

  setBtn[0] = setBtn0;
  setBtn[1] = setBtn1;
  setBtn[2] = setBtn2;
  setBtn[3] = setBtn3;
  setBtn[4] = setBtn4;
  setBtn[5] = setBtn5;
  setBtn[6] = setBtn6;
  setBtn[7] = setBtn7;


  GoButton->Enabled = false;
  WriteButton->Enabled = false;
  FlagButton->Enabled = false;

  for (int count = 0; count < 8; count++)
  {
    channelResolutions[count] = 1000;
    channelMults[count] = 4;
    maxRpmGroupLabel[count]->Caption = IntToStr(trackBar[count]->Position);
    maxRpmBarLabel[count]->Caption = maxRpmGroupLabel[count]->Caption;
    gBoxes[count]->Enabled = false;
  }


}
//---------------------------------------------------------------------------
void __fastcall TForm1::WriteButtonClick(TObject *Sender)
{
  unsigned short Chan = StrToInt("$" + WriteChEdit->Text);
  unsigned long Data = StrToInt("$" + WriteDataEdit->Text);
  Write_7266_PR(Addr + Chan * 2, Data);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::BaseEditChange(TObject *Sender)
{
  try
  {
    Addr = StrToInt("$" + BaseEdit->Text);
    BaseEdit->ParentColor = true;
  }
  catch(...)
  {
    BaseEdit->Color = TColor(0x000080);
    BaseEdit->Font->Color = TColor(0x4040FF);
  }
}
//---------------------------------------------------------------------------
void __fastcall TForm1::GoButtonClick(TObject *Sender)
{
  TheTime->Enabled = true;

  GoButton->OnClick = StopButtonClick;
  GoButton->Caption = "Stop";
}
//---------------------------------------------------------------------------

void __fastcall TForm1::StopButtonClick(TObject *Sender)
{
  TheTime->Enabled = false;

  GoButton->OnClick = GoButtonClick;
  GoButton->Caption = "Go";
}
//---------------------------------------------------------------------------

void __fastcall TForm1::TheTimeTimer(TObject *Sender)
{
  double rpm;


  for ( int I = 0; I < 8; ++I )
  {
    channelReads[I] = Read_7266_OL(Addr + I * 2);
    rpm = (channelReadsPrev[I] - channelReads[I]);
    rpm = rpm / (channelResolutions[I] * channelMults[I]);
    rpm = rpm * 60 /(TheTime->Interval * 0.001);
    rpm = fabs(rpm);
    rpmLabel[I]->Caption = FloatToStr(rpm);
    ChEdit[I]->Text = IntToStr(channelReads[I]);

    if (channelReadsPrev[I] != channelReads[I])
        paintBox[I] ->Invalidate();

    channelReadsPrev[I] = channelReads[I];

    if (rpm > rpmBar[I]->Max)
        rpmBar[I]->Position = rpmBar[I]->Max;
    else
        rpmBar[I]->Position = rpm;
  }

//  chnl0Rpm->Caption = FloatToStr(rpm);

}
//---------------------------------------------------------------------------

void __fastcall TForm1::InitButtonClick(TObject *Sender)
{
  //initialize all the counters to a resolution of 1000
  //with a mulitplier of 4

  Addr = StrToInt("0x" + BaseEdit->Text);

  Init_7266(Addr);

  for (int count = 0; count < 8; count++)
  {
    channelReads[count] = 0;
    channelReadsPrev[count] = 0;
    gBoxes[count]->Enabled = true;
  }

  OutPortB(Addr + 0x14, 1); //enable fast mode

  InitButton->Enabled = false;

  GoButton->Enabled = true;
  WriteButton->Enabled = true;
  FlagButton->Enabled = true;

}
//---------------------------------------------------------------------------

void __fastcall TForm1::FlagButtonClick(TObject *Sender)
{
  unsigned short Chan = StrToInt("$" + WriteChEdit->Text);
  FlagLabel->Caption = IntToHex(Get_7266_Flags(Addr + Chan * 2), 2);
}
//---------------------------------------------------------------------------




void __fastcall TForm1::PaintBoxPaint(TObject *Sender)
{
    TBrush *brush;
    double angle;
    PPaintBox pBox;
    int currentChannel;

    pBox = (PPaintBox)Sender;
    currentChannel = pBox->Tag;

    brush = new (TBrush);

    if (rpmBar[currentChannel]->Position == rpmBar[currentChannel]->Max)
        brush->Color = clRed;
    else
        brush->Color = clWhite;

    
    pBox->Canvas->Brush = brush;


    pBox->Canvas ->Pen->Color = clBlack;

    pBox->Canvas->Ellipse(10, 10, 100, 100);
    pBox->Canvas->MoveTo(55, 55);
    pBox->Canvas->LineTo(55, 100);

    pBox->Canvas->MoveTo(55, 55);

//    if (TheTime->Enabled)
//    {

        angle = channelReads[currentChannel];
        angle = angle * 2 * PI;
        angle = angle / (channelResolutions[currentChannel] *
                channelMults[currentChannel]) - 0.5 * PI;

        pBox->Canvas->Pen->Color = clBlue;
        pBox->Canvas->LineTo(55 - 45 * cos(angle), 55 - 45 * sin(angle));
//    }

}
//---------------------------------------------------------------------------


void __fastcall TForm1::chnlTrackChange(TObject *Sender)
{
     TTrackBar* pBar;

     pBar = (TTrackBar*)Sender;

     maxRpmBarLabel[pBar->Tag]->Caption = IntToStr(trackBar[pBar->Tag]->Position);
     maxRpmGroupLabel[pBar->Tag]->Caption = maxRpmBarLabel[pBar->Tag]->Caption;
     rpmBar[pBar->Tag]->Max = trackBar[pBar->Tag]->Position;
}
//---------------------------------------------------------------------------


void __fastcall TForm1::chnlMultBoxChange(TObject *Sender)
{
    TComboBox *pBox;

    pBox = (TComboBox*)Sender;

    pBox->Text = IntToStr(setChannelMult(pBox->Tag, StrToInt(pBox->Text)));

    paintBox[pBox->Tag]->Invalidate();
}
//---------------------------------------------------------------------------

int __fastcall TForm1::setChannelMult(int channel, int mult)
{
    switch(mult)
    {
    case 1:
        channelMults[channel] = 1;
        OutPortB(Addr + channelControlBytes[channel],
                CMR + BINCnt + ModN + QDX1);
        return 1;
    case 2:
        channelMults[channel] = 2;
        OutPortB(Addr + channelControlBytes[channel],
                 CMR + BINCnt + ModN + QDX2);
        return 2;
    case 4:
        channelMults[channel] = 4;
        OutPortB(Addr + channelControlBytes[channel],
                 CMR + BINCnt + ModN + QDX4);
        return 4;
    default:
        return channelMults[channel];
    };
}
void __fastcall TForm1::RestBtnClick(TObject *Sender)
{

    TButton *pBtn;

    pBtn = (TButton*)Sender;

    OutPortB(Addr + channelControlBytes[pBtn->Tag], Rst_CTR);
    resetTimer->Tag = pBtn->Tag;
    resetTimer->Enabled = true;
}
//---------------------------------------------------------------------------


void __fastcall TForm1::resetTimerTimer(TObject *Sender)
{
    resetTimer->Enabled = false;

    rpmBar[resetTimer->Tag]->Position = rpmBar[resetTimer->Tag]->Min;
    paintBox[resetTimer->Tag]->Invalidate();
}
//---------------------------------------------------------------------------

void __fastcall TForm1::setBtnClick(TObject *Sender)
{
    TButton *pBtn;

    pBtn = (TButton*)Sender;

    channelResolutions[pBtn->Tag] = StrToIntDef(resolution[pBtn->Tag]->Text, 1000);
    paintBox[pBtn->Tag]->Invalidate();    
}
//---------------------------------------------------------------------------

void __fastcall TForm1::ChEditKeyDown(TObject *Sender, WORD &Key,
      TShiftState Shift)
{
    short result;
    TEdit *pEdit;

    result = GetAsyncKeyState(VK_RETURN);

    if (result & 0x8000)
    {
        pEdit = (TEdit *)Sender;
        setBtn[pEdit->Tag]->Click();
    }

}
//---------------------------------------------------------------------------