aiaodlg.cpp

《WinCE.NET嵌入式工业用控制器及自动控制系统设计》的源代码

// AIAODlg.cpp : implementation file
//

#include "stdafx.h"
#include "Demo8000.h"
#include "AIAODlg.h"
#include "com_sub.h" 

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

/////////////////////////////////////////////////////////////////////////////
// CAIAODlg dialog


CAIAODlg::CAIAODlg(CWnd* pParent /*=NULL*/)
	: CDialog(CAIAODlg::IDD, pParent)
{
	//{{AFX_DATA_INIT(CAIAODlg)
	m_bh = 0.0f;
	m_bl = 0.0f;
	m_fl = 0.0f;
	m_h_limit = 0.0f;
	m_hh_limit = 0.0f;
	m_init = 0.0f;
	m_l_limit = 0.0f;
	m_dead = 0.0f;
	m_ll_limit = 0.0f;
	m_addr = _T("");
	m_rh = 0.0f;
	m_rl = 0.0f;
	m_curr = 0.0f;
	//}}AFX_DATA_INIT
}

CAIAODlg::CAIAODlg(int type, int addr, CWnd* pParent /*=NULL*/)
	: CDialog(CAIAODlg::IDD, pParent)
{
	int addr_1;

	m_type= type;
	m_idx= addr;
	switch(type)
	{
	case AI_BARE_TYPE:
		m_addr.Format(_T("Input Register, Modbus Address: %d"), AI_BARE_PTR*2+m_idx*2+300001);
		m_rh= Reg.AI_RH[m_idx];
		m_rl= Reg.AI_RL[m_idx];
		m_bh= Reg.AI_BH[m_idx];
		m_bl= Reg.AI_BL[m_idx];
		m_fl= Reg.AI_FL[m_idx];
		m_hh_limit= Reg.AI_HH[m_idx];
		m_h_limit= Reg.AI_H[m_idx];
		m_l_limit= Reg.AI_L[m_idx];
		m_ll_limit= Reg.AI_LL[m_idx];
		m_dead= Reg.AI_DEAD[m_idx];
		m_init= Reg.AI_INIT[m_idx];
		m_curr= Reg.AI_ENG[m_idx];
		break;
	case AO_BARE_TYPE:
		m_addr.Format(_T("Holding Register, Modbus Address: %d"), AO_BARE_PTR*2+m_idx*2+400001);
		m_rh= Reg.AO_RH[m_idx];
		m_rl= Reg.AO_RL[m_idx];
		m_bh= Reg.AO_BH[m_idx];
		m_bl= Reg.AO_BL[m_idx];
		m_fl= Reg.AO_FL[m_idx];
		m_hh_limit= Reg.AO_HH[m_idx];
		m_h_limit= Reg.AO_H[m_idx];
		m_l_limit= Reg.AO_L[m_idx];
		m_ll_limit= Reg.AO_LL[m_idx];
		m_dead= Reg.AO_DEAD[m_idx];
		m_init= Reg.AO_INIT[m_idx];
		m_curr= Reg.AO_ENG[m_idx];
		break;
	case AI_SOFT_TYPE:
		addr_1= m_idx + ED_MAX;
		m_addr.Format(_T("Input Register Soft, Modbus Address: %d"), AI_SOFT_PTR*2+m_idx*2+300001);
		m_rh= 0.0;
		m_rl= 0.0;
		m_bh= 0.0;
		m_bl= 0.0;
		m_fl= 0.0;
		m_hh_limit= Reg.AI_HH[addr_1];
		m_h_limit= Reg.AI_H[addr_1];
		m_l_limit= Reg.AI_L[addr_1];
		m_ll_limit= Reg.AI_LL[addr_1];
		m_dead= Reg.AI_DEAD[addr_1];
		m_init= Reg.AI_INIT[addr_1];
		m_curr= Reg.AI_SOFT[m_idx];
		break;
	case AO_SOFT_TYPE:
		addr_1= m_idx + ED_MAX;
		m_addr.Format(_T("Holding Register Soft, Modbus Address: %d"), AO_SOFT_PTR*2+m_idx*2+400001);
		m_rh= 0.0;
		m_rl= 0.0;
		m_bh= 0.0;
		m_bl= 0.0;
		m_fl= 0.0;
		m_hh_limit= Reg.AO_HH[addr_1];
		m_h_limit= Reg.AO_H[addr_1];
		m_l_limit= Reg.AO_L[addr_1];
		m_ll_limit= Reg.AO_LL[addr_1];
		m_dead= Reg.AO_DEAD[addr_1];
		m_init= Reg.AO_INIT[addr_1];
		m_curr= Reg.AO_SOFT[m_idx];
		break;
	}
}


void CAIAODlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CAIAODlg)
	DDX_Control(pDX, IDC_RL_TEXT, m_rl_text);
	DDX_Control(pDX, IDC_RH_TEXT, m_rh_text);
	DDX_Control(pDX, IDC_FL_TEXT, m_fl_text);
	DDX_Control(pDX, IDC_BL_TEXT, m_bl_text);
	DDX_Control(pDX, IDC_BH_TEXT, m_bh_text);
	DDX_Control(pDX, IDC_RL, m_rl_ctrl);
	DDX_Control(pDX, IDC_RH, m_rh_ctrl);
	DDX_Control(pDX, IDC_FL, m_fl_ctrl);
	DDX_Control(pDX, IDC_BL, m_bl_ctrl);
	DDX_Control(pDX, IDC_BH, m_bh_ctrl);
	DDX_Text(pDX, IDC_BH, m_bh);
	DDX_Text(pDX, IDC_BL, m_bl);
	DDX_Text(pDX, IDC_FL, m_fl);
	DDV_MinMaxFloat(pDX, m_fl, 0.f, 1.f);
	DDX_Text(pDX, IDC_H_LIMIT, m_h_limit);
	DDX_Text(pDX, IDC_HH_LIMIT, m_hh_limit);
	DDX_Text(pDX, IDC_INIT_VALUE, m_init);
	DDX_Text(pDX, IDC_L_LIMIT, m_l_limit);
	DDX_Text(pDX, IDC_DEAD_ZONE, m_dead);
	DDV_MinMaxFloat(pDX, m_dead, 0.f, 0.1f);
	DDX_Text(pDX, IDC_LL_LIMIT, m_ll_limit);
	DDX_Text(pDX, IDC_MODBUS_ADDR, m_addr);
	DDX_Text(pDX, IDC_RH, m_rh);
	DDX_Text(pDX, IDC_RL, m_rl);
	DDX_Text(pDX, IDC_CURRENT_VALUE, m_curr);
	//}}AFX_DATA_MAP
}


BEGIN_MESSAGE_MAP(CAIAODlg, CDialog)
	//{{AFX_MSG_MAP(CAIAODlg)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CAIAODlg message handlers

BOOL CAIAODlg::OnInitDialog() 
{
	CDialog::OnInitDialog();
	
	// TODO: Add extra initialization here

	switch(m_type)
	{
	case AI_BARE_TYPE:
		break;
	case AO_BARE_TYPE:
		break;
	case AI_SOFT_TYPE:
		m_bh_ctrl.ShowWindow(false);
		m_bl_ctrl.ShowWindow(false);
		m_rh_ctrl.ShowWindow(false);
		m_rl_ctrl.ShowWindow(false);
		m_fl_ctrl.ShowWindow(false);
		m_bh_text.ShowWindow(false);
		m_bl_text.ShowWindow(false);
		m_rh_text.ShowWindow(false);
		m_rl_text.ShowWindow(false);
		m_fl_text.ShowWindow(false);
		break;
	case AO_SOFT_TYPE:
		m_bh_ctrl.ShowWindow(false);
		m_bl_ctrl.ShowWindow(false);
		m_rh_ctrl.ShowWindow(false);
		m_rl_ctrl.ShowWindow(false);
		m_fl_ctrl.ShowWindow(false);
		m_bh_text.ShowWindow(false);
		m_bl_text.ShowWindow(false);
		m_rh_text.ShowWindow(false);
		m_rl_text.ShowWindow(false);
		m_fl_text.ShowWindow(false);
		break;
	}
	
	UpdateData( FALSE );
	return TRUE;  // return TRUE unless you set the focus to a control
	              // EXCEPTION: OCX Property Pages should return FALSE
}

void CAIAODlg::OnOK() 
{
	// TODO: Add extra validation here
	UpdateData(TRUE);	

	if(m_rh< m_rl)
	{
		AfxMessageBox(_T("Range High is less then Range Low"));
		return;
	}
	if(m_bh< m_bl)
	{
		AfxMessageBox(_T("Bare High is less then Bare Low"));
		return;
	}
	if(m_hh_limit< m_h_limit)
	{
		AfxMessageBox(_T("ALarm High High Limit is less then Alarm High Limit"));
		return;
	}
	if(m_ll_limit> m_l_limit)
	{
		AfxMessageBox(_T("ALarm Low Low Limit is great then Alarm Low Limit"));
		return;
	}
	if(m_l_limit> m_h_limit)
	{
		AfxMessageBox(_T("ALarm Low Limit is great then Alarm High Limit"));
		return;
	}

	int addr_1;
	switch(m_type)
	{
	case AI_BARE_TYPE:
		Reg.AI_RH[m_idx]= m_rh;
		Reg.AI_RL[m_idx]= m_rl;
		Reg.AI_BH[m_idx]= m_bh;
		Reg.AI_BL[m_idx]= m_bl;
		Reg.AI_FL[m_idx]= m_fl;
		Reg.AI_HH[m_idx]= m_hh_limit;
		Reg.AI_H[m_idx]= m_h_limit;
		Reg.AI_L[m_idx]= m_l_limit;
		Reg.AI_LL[m_idx]= m_ll_limit;
		Reg.AI_DEAD[m_idx]= m_dead;
		Reg.AI_INIT[m_idx]= m_init;
		Reg.AI_ENG[m_idx]= m_curr;
		break;
	case AO_BARE_TYPE:
		Reg.AO_RH[m_idx]= m_rh;
		Reg.AO_RL[m_idx]= m_rl;
		Reg.AO_BH[m_idx]= m_bh;
		Reg.AO_BL[m_idx]= m_bl;
		Reg.AO_FL[m_idx]= m_fl;
		Reg.AO_HH[m_idx]= m_hh_limit;
		Reg.AO_H[m_idx]= m_h_limit;
		Reg.AO_L[m_idx]= m_l_limit;
		Reg.AO_LL[m_idx]= m_ll_limit;
		Reg.AO_DEAD[m_idx]= m_dead;
		Reg.AO_INIT[m_idx]= m_init;
		if(m_curr != Reg.AO_ENG[m_idx])
		{
			Reg.AO_ENG[m_idx]= m_curr;
			set_AODO_output(AO_TYPE_ENG, m_idx, m_curr);
		}
		break;
	case AI_SOFT_TYPE:
		addr_1= m_idx + ED_MAX;
		Reg.AI_HH[addr_1]= m_hh_limit;
		Reg.AI_H[addr_1]= m_h_limit;
		Reg.AI_L[addr_1]= m_l_limit;
		Reg.AI_LL[addr_1]= m_ll_limit;
		Reg.AI_DEAD[addr_1]= m_dead;
		Reg.AI_INIT[addr_1]= m_init;
		Reg.AI_SOFT[m_idx]= m_curr;
		break;
	case AO_SOFT_TYPE:
		addr_1= m_idx + ED_MAX;
		Reg.AO_HH[addr_1]= m_hh_limit;
		Reg.AO_H[addr_1]= m_h_limit;
		Reg.AO_L[addr_1]= m_l_limit;
		Reg.AO_LL[addr_1]= m_ll_limit;
		Reg.AO_DEAD[addr_1]= m_dead;
		Reg.AO_INIT[addr_1]= m_init;
		Reg.AO_SOFT[m_idx]= m_curr;
		break;
	}

	CDialog::OnOK();
}