digitalpoweranalystview.cpp

串行通讯程序,为电池分析仪与电脑通讯软件,效果不错.

// ex31bView.cpp : implementation of the CDigitalPowerAnalystView class
//

#include "stdafx.h"
#include "DigitalPowerAnalyst.h"

#include "DigitalPowerAnalystSet.h"
#include "DigitalPowerAnalystDoc.h"
#include "DigitalPowerAnalystView.h"
#include <math.h>
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CDigitalPowerAnalystView

char pgm_xref2[17] = {0,1,2,14,9,10,11,12,7,8,13,15,15,3,4,5,6};
const char * default_std_cc[] = { "0000-00-000-0000", "1010-56-500-3646", "1010-26-500-1646", "0301-500-0756", "1010-505-3657"};
#define 	STEPSCALEY (312.5*2) 
#define 	STEPSCALEZ (125.0 *2)
/////////////////////////////////////////////////////////////////////////////
// CDigitalPowerAnalystView

IMPLEMENT_DYNCREATE(CDigitalPowerAnalystView, CRecordView)

BEGIN_MESSAGE_MAP(CDigitalPowerAnalystView, CRecordView)
	//{{AFX_MSG_MAP(CDigitalPowerAnalystView)
	ON_COMMAND(ID_Analysis_Setup, OnAnalysisSetup)
	ON_MESSAGE(WM_COMM_RXCHAR, OnCommunication)
	ON_MESSAGE(WM_COMM_READAnaly,OnCommAnaly)
	ON_COMMAND(ID_Battery_Check, OnBatteryCheck)
	ON_COMMAND(ID_DATA_Process, OnDATAProcess)
	ON_COMMAND(ID_Device_Setup, OnDeviceSetup)
	ON_COMMAND(ID_Setup_SerialPort, OnSetupSerialPort)
	ON_COMMAND(ID_AutoCharge, OnAutoCharge)
	ON_COMMAND(ID_AutoDischarge, OnAutoDischarge)
	ON_BN_CLICKED(IDC_STATICStation1, OnSTATICStation1)
	ON_BN_CLICKED(IDC_STATICStation2, OnSTATICStation2)
	ON_BN_CLICKED(IDC_STATICStation3, OnSTATICStation3)
	ON_BN_CLICKED(IDC_STATICStation4, OnSTATICStation4)
	ON_WM_TIMER()
	ON_WM_MOUSEMOVE()
	ON_BN_CLICKED(IDC_CHECKStation1, OnCHECKStation1)
	ON_BN_CLICKED(IDC_CHECKStation2, OnCHECKStation2)
	ON_BN_CLICKED(IDC_CHECKStation3, OnCHECKStation3)
	ON_BN_CLICKED(IDC_CHECKStation4, OnCHECKStation4)
	ON_BN_CLICKED(IDC_CHECKStationAll, OnCHECKStationAll)
	ON_BN_CLICKED(IDC_BTNCLEARDATA, OnClearData)
	
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CDigitalPowerAnalystView construction/destruction
	CSerialPort m_ComPort;
CDigitalPowerAnalystView::CDigitalPowerAnalystView()
	: CRecordView(CDigitalPowerAnalystView::IDD)
{
	//{{AFX_DATA_INIT(CDigitalPowerAnalystView)
//	m_StationItem[1][0] = _T("");
	//}}AFX_DATA_INIT
	// TODO: add construction code here
	m_StepScaleY=312.5;
	m_STEPSCALEZ=125.0;
	for(int i=0;i<4;i++)
	{
	  m_sProgram[i+1]=1;
	  m_nCycleAll[i+1]=1;
	rgID[i]=IDD_StationPage1+i;
	m_StationVorC[i+1][0]=0;
	m_StationVorC[i+1][1]=0;
	m_StationVorC[i+1][2]=0;
	m_BatteryStatus[i+1]=0;
	m_StationOnLine[i+1]=0;
 	for(int j=0;j<15;j++)
    m_StationItem[i+1][j]="";
	m_nCycleAll[i+1]=0;
	MousePoint=(1,1);
	m_pSet = NULL;
	ChangeLable(0,2500);
	ChangLabeCurrent(-400,100);
	ChangLableTime(0,225);
	nRecordNUM=0;
	}
    CurStation=1;
	m_bTranStation=FALSE;
m_ComData.NextStruct.station=1;
m_lInterval=0;
		m_ccode.type = 0;
    	m_ccode.cells=0;			/* # of cells						*/
		m_ccode.rating=0;			/* battery rating		- mAh			*/
		m_ccode.cr=0;			/* charge rate        		- C			*/
		m_ccode.dr=0;			/* discharge rate     		- C			*/
		m_ccode.tcr=0;			/* trickle charge rate		- C			*/
		m_ccode.tdr=0;			/* recon discharge rate		- C			*/
		m_ccode.temp1=0;			/* low temp cutoff		- 鳦			*/
		m_ccode.Roffset=0;		/* capacity offset		- %			*/
			m_ccode.ns=0;			/* negative slope		- mV/Cell		*/
			m_ccode.ed=0;			/* end discharge threshold	- mV/Cell		*/
			m_ccode.er=0;			/* end recondition threshold	- mV/Cell		*/
			m_ccode.method=0;			/* charge method					*/
			m_ccode.sv=0;			/* maximum standby voltage	- mV/Cell	 	*/
			m_ccode.mv=0;			/* maximum voltage		- mV/Cell		*/
			m_ccode.program=0;		/* charge program					*/
			m_ccode.ctp=0;			/* charge termination point	- C			*/
			m_ccode.target=0;			/* target capacity		- 50 - 150%		*/
	m_CHECKStation1 = TRUE;
	m_CHECKStation2 = FALSE;
	m_CHECKStation3 = FALSE;
	m_CHECKStation4 = FALSE;
	m_CHECKStationALL = FALSE;
bClearData=FALSE;
	m_pSet = NULL;
}

const char program_txt0[]  = {"自动"};//0  //0
const char program_txt1[]  = {"充电"};//1  //1			
const char program_txt2[]  = {"化成"};//2   //2
const char program_txt3[] = {"定制1"};//3
const char program_txt4[] = {"定制2"};//4
const char program_txt5[] = {"定制3"};//5
const char program_txt6[] = {"定制4"};//6
const char program_txt7[]  = {"内阻测试"};//7
const char program_txt8[]  = {"模拟放电"};//8
const char program_txt9[]  = {"自放电"};//9
const char program_txt10[]  = {"循环寿命"};//10
const char program_txt11[]  = {"单放电"};//11
const char program_txt12[]  = {"深度化成"};//12
const char program_txt13[] = {"学习"};//13
const char program_txt14[]  = {"快速测试"};//14
const char program_txt15[] = {"快速学习"};//15
const char program_txt16[] = {"电池激活"};//16


const char program_txtA[]  = {"高级\x87"};
const char program_txtB[]  = {"基本\x87"};



 
char const* m_sConstantProgram[] = {
	program_txt0 ,program_txt1 ,program_txt2 ,program_txt14 , program_txt9  ,
 program_txt10 ,
 program_txt11 ,program_txt12  ,  program_txt7 , program_txt8  , program_txt13 , program_txt15 ,program_txt16 , program_txt3 , 
  program_txt4 ,
 program_txt5  ,
 program_txt6  ,

 
 program_txt3  
};
	char *   m_sConstantCycle[] ={_T("放电"),_T("充电"),_T("修复"),_T("涓涓充电"),_T("电池休眠"),_T("内阻测试"),_T("处理完成"),_T("完成涓充"),_T("错误")};
 //	char *   m_sConstantProgram[]={_T("自动"),_T("充电"),_T("化成"),_T("用户程序1"),_T("用户程序2"),_T("用户程序3"),_T("用户程序4"),_T("内阻测试"),_T("模拟测试"),_T("自放测试"),_T("循环寿命"),_T("电池放电"),_T("深度化成"),_T("学习"),_T("快速测试"),_T("快速学习"),_T("错误")};
	const char * NoStation=_T("无适配器");
	const char * NoBattery=_T("适配器空");
CDigitalPowerAnalystView::~CDigitalPowerAnalystView()
{  
}

void CDigitalPowerAnalystView::DoDataExchange(CDataExchange* pDX)
{
	CRecordView::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CDigitalPowerAnalystView)

    DDX_Control(pDX, IDC_STATICLCD,m_STATICLCD);
    DDX_Control(pDX, IDC_STATICStation1, m_StaticStation[1]);
    DDX_Control(pDX, IDC_STATICStation2, m_StaticStation[2]);
    DDX_Control(pDX, IDC_STATICStation3, m_StaticStation[3]);
    DDX_Control(pDX, IDC_STATICStation4, m_StaticStation[4]);
    DDX_Control(pDX, IDC_STATICPicture, m_StaticPicture);
    DDX_Control(pDX, IDC_STATICVol,m_StaticLab);
    DDX_Control(pDX, IDC_StaticDataDisplay, m_StaticDataDisp);
 	DDX_Text(pDX, IDC_Battery001, m_StationItem[1][1]);
	DDX_Text(pDX, IDC_Battery002, m_StationItem[1][2]);
	DDX_Text(pDX, IDC_Battery003, m_StationItem[1][3]);
	DDX_Text(pDX, IDC_Battery004, m_StationItem[1][4]);
	DDX_Text(pDX, IDC_Battery005, m_StationItem[1][5]);
	DDX_Text(pDX, IDC_Battery006, m_StationItem[1][6]);
	DDX_Text(pDX, IDC_Battery007, m_StationItem[1][7]);
	DDX_Text(pDX, IDC_Battery008, m_StationItem[1][8]);
	DDX_Text(pDX, IDC_Battery009, m_StationItem[1][9]);
	DDX_Text(pDX, IDC_Battery010, m_StationItem[1][10]);
	DDX_Text(pDX, IDC_Battery011, m_StationItem[1][11]);
	DDX_Text(pDX, IDC_Battery012, m_StationItem[1][12]);
	DDX_Text(pDX, IDC_Battery013, m_StationItem[1][13]);
	DDX_Text(pDX, IDC_Battery014, m_StationItem[1][14]);
  	DDX_Text(pDX, IDC_STATICVC0,m_LabelVC[0]);
  	DDX_Text(pDX, IDC_STATICVC1,m_LabelVC[1]);
  	DDX_Text(pDX, IDC_STATICVC2,m_LabelVC[2]);
  	DDX_Text(pDX, IDC_STATICVC3,m_LabelVC[3]);
  	DDX_Text(pDX, IDC_STATICVC4,m_LabelVC[4]);
  	DDX_Text(pDX, IDC_STATICVC5,m_LabelVC[5]);
  	DDX_Text(pDX, IDC_STATICVC6,m_LabelVC[6]);
  	DDX_Text(pDX, IDC_STATICVC7,m_LabelVC[7]);
  	DDX_Text(pDX, IDC_STATICVC8,m_LabelVC[8]);


  	DDX_Text(pDX, IDC_STATICTime1,m_TimeLable[1]);
  	DDX_Text(pDX, IDC_STATICTime2,m_TimeLable[2]);
  	DDX_Text(pDX, IDC_STATICTime3,m_TimeLable[3]);
  	DDX_Text(pDX, IDC_STATICTime4,m_TimeLable[4]);
  	DDX_Text(pDX, IDC_STATICTime5,m_TimeLable[5]);
  	DDX_Text(pDX, IDC_STATICTime6,m_TimeLable[6]);
  	DDX_Text(pDX, IDC_STATICTime7,m_TimeLable[7]);
  	DDX_Text(pDX, IDC_STATICTime8,m_TimeLable[8]);

  	DDX_Text(pDX, IDC_STATICVC01,m_CurrentLable[3]);
  	DDX_Text(pDX, IDC_STATICVC02,m_CurrentLable[2]);
  	DDX_Text(pDX, IDC_STATICVC03,m_CurrentLable[1]);
  	DDX_Text(pDX, IDC_STATICVC04,m_CurrentLable[0]);

  	DDX_Text(pDX, IDC_STATICVC00,m_CurrentLable[4]);
  	DDX_Text(pDX, IDC_STATICVC11,m_CurrentLable[5]);
  	DDX_Text(pDX, IDC_STATICVC12,m_CurrentLable[6]);
  	DDX_Text(pDX, IDC_STATICVC13,m_CurrentLable[7]);
  	DDX_Text(pDX, IDC_STATICVC14,m_CurrentLable[8]);

//	DDX_Text(pDX, IDC_Battery010, m_StationVorC[1][0]);
//	DDX_Text(pDX, IDC_Battery011, m_StationVorC[1][1]);

	DDX_Text(pDX, IDC_Battery021, m_StationItem[2][1]);
	DDX_Text(pDX, IDC_Battery022, m_StationItem[2][2]);
	DDX_Text(pDX, IDC_Battery023, m_StationItem[2][3]);
	DDX_Text(pDX, IDC_Battery024, m_StationItem[2][4]);
	DDX_Text(pDX, IDC_Battery025, m_StationItem[2][5]);
	DDX_Text(pDX, IDC_Battery026, m_StationItem[2][6]);
	DDX_Text(pDX, IDC_Battery027, m_StationItem[2][7]);
	DDX_Text(pDX, IDC_Battery028, m_StationItem[2][8]);
	DDX_Text(pDX, IDC_Battery029, m_StationItem[2][9]);
	DDX_Text(pDX, IDC_Battery030, m_StationItem[2][10]);
	DDX_Text(pDX, IDC_Battery031, m_StationItem[2][11]);
	DDX_Text(pDX, IDC_Battery032, m_StationItem[2][12]);
	DDX_Text(pDX, IDC_Battery033, m_StationItem[2][13]);
	DDX_Text(pDX, IDC_Battery034, m_StationItem[2][14]);
//	DDX_Text(pDX, IDC_Battery030, m_StationVorC[2][0]);
//	DDX_Text(pDX, IDC_Battery031, m_StationVorC[2][1]);

	DDX_Text(pDX, IDC_Battery041, m_StationItem[3][1]);
	DDX_Text(pDX, IDC_Battery042, m_StationItem[3][2]);
	DDX_Text(pDX, IDC_Battery043, m_StationItem[3][3]);
	DDX_Text(pDX, IDC_Battery044, m_StationItem[3][4]);
	DDX_Text(pDX, IDC_Battery045, m_StationItem[3][5]);
	DDX_Text(pDX, IDC_Battery046, m_StationItem[3][6]);
	DDX_Text(pDX, IDC_Battery047, m_StationItem[3][7]);
	DDX_Text(pDX, IDC_Battery048, m_StationItem[3][8]);
	DDX_Text(pDX, IDC_Battery049, m_StationItem[3][9]);
	DDX_Text(pDX, IDC_Battery050, m_StationItem[3][10]);
	DDX_Text(pDX, IDC_Battery051, m_StationItem[3][11]);
	DDX_Text(pDX, IDC_Battery052, m_StationItem[3][12]);
	DDX_Text(pDX, IDC_Battery053, m_StationItem[3][13]);
	DDX_Text(pDX, IDC_Battery054, m_StationItem[3][14]);
//	DDX_Text(pDX, IDC_Battery050, m_StationVorC[3][0]);
//	DDX_Text(pDX, IDC_Battery051, m_StationVorC[3][1]);

	DDX_Text(pDX, IDC_Battery061, m_StationItem[4][1]);
	DDX_Text(pDX, IDC_Battery062, m_StationItem[4][2]);
	DDX_Text(pDX, IDC_Battery063, m_StationItem[4][3]);
	DDX_Text(pDX, IDC_Battery064, m_StationItem[4][4]);
	DDX_Text(pDX, IDC_Battery065, m_StationItem[4][5]);
	DDX_Text(pDX, IDC_Battery066, m_StationItem[4][6]);
	DDX_Text(pDX, IDC_Battery067, m_StationItem[4][7]);
	DDX_Text(pDX, IDC_Battery068, m_StationItem[4][8]);
	DDX_Text(pDX, IDC_Battery069, m_StationItem[4][9]);
	DDX_Text(pDX, IDC_Battery070, m_StationItem[4][10]);
	DDX_Text(pDX, IDC_Battery071, m_StationItem[4][11]);
	DDX_Text(pDX, IDC_Battery072, m_StationItem[4][12]);
	DDX_Text(pDX, IDC_Battery073, m_StationItem[4][13]);
	DDX_Text(pDX, IDC_Battery074, m_StationItem[4][14]);

//	DDX_Text(pDX, IDC_Battery070, m_StationVorC[4][0]);
//	DDX_Text(pDX, IDC_Battery071, m_StationVorC[4][1]);

	DDX_Control(pDX, IDC_LISTStation, m_ListCtrlStation);
	DDX_Check(pDX, IDC_CHECKStation1, m_CHECKStation1);
	DDX_Check(pDX, IDC_CHECKStation2, m_CHECKStation2);
	DDX_Check(pDX, IDC_CHECKStation3, m_CHECKStation3);
	DDX_Check(pDX, IDC_CHECKStation4, m_CHECKStation4);
	DDX_Check(pDX, IDC_CHECKStationAll, m_CHECKStationALL);
	//}}AFX_DATA_MAP
}


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

	return CRecordView::PreCreateWindow(cs);
}



/////////////////////////////////////////////////////////////////////////////
// CDigitalPowerAnalystView diagnostics

#ifdef _DEBUG
void CDigitalPowerAnalystView::AssertValid() const
{
	CRecordView::AssertValid();
}

void CDigitalPowerAnalystView::Dump(CDumpContext& dc) const
{
	CRecordView::Dump(dc);
}

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

/////////////////////////////////////////////////////////////////////////////
// CDigitalPowerAnalystView database support
CRecordset* CDigitalPowerAnalystView::OnGetRecordset()
{
	return m_pSet;
}


/////////////////////////////////////////////////////////////////////////////
// CDigitalPowerAnalystView message handlers

BOOL CDigitalPowerAnalystView::OnMove(UINT nIDMoveCommand) 
{
   /* switch (nIDMoveCommand)
	{
    case ID_RECORD_PREV:
        m_pSet->MovePrev();
        if (!m_pSet->IsBOF())
            break;

    case ID_RECORD_FIRST:
        m_pSet->MoveFirst();
        break;

    case ID_RECORD_NEXT:
        m_pSet->MoveNext();
        if (!m_pSet->IsEOF())
            break;
        if (!m_pSet->CanScroll()) {
            // Clear screen since we抮e sitting on EOF
            m_pSet->SetFieldNull(NULL);
            break;
        }

     case ID_RECORD_LAST:
        m_pSet->MoveLast();
        break;

    default:
        // unexpected case value
        ASSERT(FALSE);
    }

    // Show results of Move operation
    UpdateData(FALSE);
	*/
    return TRUE;
}



void CDigitalPowerAnalystView::OnDraw(CDC* pDC) 
{static int statrt=0;
	// TODO: Add your specialized code here and/or call the base class
		 	ClearLine();
		    WriteGrid(&m_StaticDataDisp);
			m_bTranStation=TRUE;
			if(statrt!=0)
			{m_bTranStation=TRUE;
		// WriteToPicture((m_lInterval),m_StationVorC[CurStation][0],m_StationVorC[CurStation][1]); 
			}
       statrt=1;
      	UpdateData(FALSE); 
    

}



void CDigitalPowerAnalystView::OnUpdateRecordDelete(CCmdUI* pCmdUI) 
{
    pCmdUI->Enable(!m_pSet->IsEOF());
}

void CDigitalPowerAnalystView::OnRecordUpdate() 
{
    m_pSet->Edit();
    UpdateData(TRUE);
    if (m_pSet->CanUpdate()){
      m_pSet->Update();
    }
// should requery if key field changed
}

void CDigitalPowerAnalystView::OnUpdateRecordUpdate(CCmdUI* pCmdUI) 
{
    pCmdUI->Enable(!m_pSet->IsEOF());
}

LONG CDigitalPowerAnalystView::OnCommAnaly(WPARAM CmdnStation, LPARAM nCycle)
{	unsigned  char cmd=(unsigned char)(CmdnStation%256);
	unsigned char nStation=(unsigned char)(CmdnStation/256);
	unsigned char nCy=	(unsigned char) nCycle;
	unsigned len=0;
	char tmpStr[256];
  		CString   str;
		 if(m_AnalysisSetupDlg.IsDlgShow==TRUE)
       	m_AnalysisSetupDlg.AnalysisUpdate(TRUE);
		 if(m_SYSTEMSetupDlg.IsDlgShow==TRUE)
       	m_SYSTEMSetupDlg.SystemUpdate(TRUE);
	//str=_T("81 02 7c 80");
	str=_T("");
 		((CMainFrame * )GetParentFrame())->SetStatusPaneText(2,"   ",TRUE);
		((CMainFrame * )GetParentFrame())->SetStatusPaneText(3,"      ",TRUE);
	switch(cmd) {
     	case   0x80+ 1:			/* Return Battery ID#				*/
			//
            	break; 
		case   0x80+ 2:										/* Set Battery ID#				*/
		  str=m_AnalysisSetupDlg.m_AnalysisStation1[1]	;