Context Navigation

ModbucfgView.cpp

Last change on this file was 14, checked in by marrucho, 11 years ago
xsuc light lecture uniquement
File size: 49.6 KB

Line
1	// ModbucfgView.cpp : implementation of the CModbucfgView class
2	//
3
4	#include "stdafx.h"
5	#include "Modbucfg.h"
6
7	#include "ModbucfgDoc.h"
8	#include "ModbucfgView.h"
9	#include ".\modbucfgview.h"
10
11
12	#ifdef _DEBUG
13	#define new DEBUG_NEW
14	#undef THIS_FILE
15	static char THIS_FILE[] = __FILE__;
16	#endif
17
18	/////////////////////////////////////////////////////////////////////////////
19	// CModbucfgView
20
21	IMPLEMENT_DYNCREATE(CModbucfgView, CFormView)
22
23	BEGIN_MESSAGE_MAP(CModbucfgView, CFormView)
24	//{{AFX_MSG_MAP(CModbucfgView)
25	ON_BN_CLICKED(IDC_CHK_Enable_Poll, OnchkEnablePoll)
26	ON_EN_CHANGE(IDC_EDIT_INTERVAL, OnChangeEditInterval)
27	ON_BN_CLICKED(IDC_CMD_WRITE, OnCmdWrite)
28	//}}AFX_MSG_MAP
29	ON_CBN_SELCHANGE(IDC_CBO_READ_FUNCTION, OnCbnSelchangeCboReadFunction)
30	ON_CBN_SELCHANGE(IDC_CBO_WRITE_FUNCTION, OnCbnSelchangeCboWriteFunction)
31	ON_COMMAND(ID_APP_MEM_MAP, OnAppMemMap)
32	ON_EN_CHANGE(IDC_EDIT_QUANT, OnEnChangeEditQuant)
33	ON_EN_CHANGE(IDC_EDIT_ADDR, OnEnChangeEditAddr)
34	ON_EN_CHANGE(IDC_EDIT_QUANT_2, OnEnChangeEditQuant2)
35	ON_LBN_SELCHANGE(IDC_LIST5, OnLbnSelchangeList5)
36	ON_LBN_SELCHANGE(IDC_LST_VALUES, OnLbnSelchangeLstValues)
37	ON_EN_CHANGE(IDC_EDIT_ADDR_WRI, OnEnChangeEditAddrWri)
38	ON_EN_CHANGE(IDC_EDIT_VALUE, OnEnChangeEditValue)
39	ON_WM_VSCROLL()
40	ON_BN_CLICKED(IDC_CMD_READ, OnCmdRead)
41	// ON_EN_CHANGE(IDC_EDIT16, OnEnChangeEdit16)
42	ON_BN_CLICKED(IDC_BUTTON1, OnBnClickedButton1)
43	ON_BN_CLICKED(IDC_BUTTON2, OnBnClickedButton2)
44	ON_BN_CLICKED(IDC_CMD_WRITE2, OnCmdStart)
45	ON_BN_CLICKED(IDC_CMD_WRITE3, OnCmdStop)
46	ON_BN_CLICKED(IDC_CMD_WRITE4, OnCmdPause)
47	ON_BN_CLICKED(IDC_CMD_WRITE5, OnButtonReprise)
48	END_MESSAGE_MAP()
49
50	/////////////////////////////////////////////////////////////////////////////
51	// CModbucfgView construction/destruction
52
53	CModbucfgView::CModbucfgView()
54	: CFormView(CModbucfgView::IDD)
55	/* , m_edtQuant2(false)
56	, m_edtQuant2(_T(""))*/
57	, m_spinIndex(0)
58	{
59	//{{AFX_DATA_INIT(CModbucfgView)
60	//}}AFX_DATA_INIT
61	// TODO: add construction code here
62
63	}
64
65	CModbucfgView::~CModbucfgView()
66	{
67	}
68
69	void CModbucfgView::DoDataExchange(CDataExchange* pDX)
70	{
71	CFormView::DoDataExchange(pDX);
72	//{{AFX_DATA_MAP(CModbucfgView)
73	DDX_Control(pDX, IDC_CBO_DATA_TYPE, m_cboDataType);
74	DDX_Control(pDX, IDC_EDIT_INTERVAL, m_edtInterval);
75	DDX_Control(pDX, IDC_CHK_Enable_Poll, m_butPollEnable);
76	DDX_Control(pDX, IDC_STAT_STATUS, m_statStatus);
77	DDX_Control(pDX, IDC_STAT_ERROR, m_staError);
78	DDX_Control(pDX, IDC_LST_VALUES, m_lstValues);
79	DDX_Control(pDX, IDC_CBO_WRITE_FUNCTION, m_cboWriteFunctions);
80	DDX_Control(pDX, IDC_CBO_READ_FUNCTION, m_cboReadFunctions);
81	DDX_Control(pDX, IDC_CBO_CONNECTION, m_cboConnections);
82	DDX_Control(pDX, IDC_EDIT_VALUE, m_edtValue);
83	DDX_Control(pDX, IDC_EDIT_QUANT, m_edtQuant);
84	DDX_Control(pDX, IDC_EDIT_DEVICE, m_edtDevice);
85	DDX_Control(pDX, IDC_EDIT_ADDR_WRI, m_edtWriteAddr);
86	DDX_Control(pDX, IDC_EDIT_ADDR, m_edtReadAddr);
87	DDX_Control(pDX, IDC_CMD_WRITE, m_cmdWrite);
88	//}}AFX_DATA_MAP
89	DDX_Control(pDX, IDC_EDIT_QUANT_2, m_edtQuant2);
90	// DDX_Control(pDX, IDC_LIST5, m_list5Values);
91	DDX_Control(pDX, IDC_EDIT6, m_edtIndex);
92	DDX_Text(pDX, IDC_EDIT6, m_spinIndex);
93	DDX_Control(pDX, IDC_EDIT3, m_readEil);
94	DDX_Control(pDX, IDC_EDIT5, m_readSVd);
95	DDX_Control(pDX, IDC_EDIT7, m_readSVfin);
96	DDX_Control(pDX, IDC_EDIT8, m_readSV1);
97	DDX_Control(pDX, IDC_EDIT9, m_readSV2);
98	DDX_Control(pDX, IDC_EDIT10, m_readdtp);
99	DDX_Control(pDX, IDC_EDIT11, m_readdt);
100	DDX_Control(pDX, IDC_EDIT12, m_readdP);
101	DDX_Control(pDX, IDC_EDIT13, m_readdPsecu);
102	DDX_Control(pDX, IDC_EDIT14, m_readSVil);
103	DDX_Control(pDX, IDC_EDIT15, m_readSleil);
104	DDX_Control(pDX, IDC_EDIT16, m_readSTc);
105	DDX_Control(pDX, IDC_EDIT17, m_readNbal_max);
106	DDX_Control(pDX, IDC_EDIT18, m_readFr);
107	DDX_Control(pDX, IDC_EDIT19, m_readN_cur);
108	DDX_Control(pDX, IDC_CMD_READ, m_cmdRead);
109	DDX_Control(pDX, IDC_EDIT4, m_readNil);
110	DDX_Control(pDX, IDC_EDIT20, m_readNil_stat);
111	DDX_Control(pDX, IDC_EDIT21, m_readP_last);
112	DDX_Control(pDX, IDC_EDIT22, m_readN_last);
113	DDX_Control(pDX, IDC_EDIT23, m_readdPil);
114	DDX_Control(pDX, IDC_EDIT24, m_readV_cur);
115	DDX_Control(pDX, IDC_EDIT25, m_readPic);
116	DDX_Control(pDX, IDC_EDIT26, m_readTimer);
117	DDX_Control(pDX, IDC_EDIT27, m_readNbal);
118	DDX_Control(pDX, IDC_EDIT28, m_readP_cde);
119	DDX_Control(pDX, IDC_EDIT29, m_readPp);
120	DDX_Control(pDX, IDC_EDIT30, m_readStat_C_1);
121	DDX_Control(pDX, IDC_EDIT31, m_readStat_C_2);
122	DDX_Control(pDX, IDC_EDIT32, m_readStat_C_3);
123	DDX_Control(pDX, IDC_EDIT33, m_readStat_C_4);
124	DDX_Control(pDX, IDC_EDIT34, m_readStat_C_5);
125	DDX_Control(pDX, IDC_EDIT35, m_readStat_C_6);
126	DDX_Control(pDX, IDC_EDIT36, m_readStat_C_7);
127	DDX_Control(pDX, IDC_EDIT37, m_readStat_C_8);
128	DDX_Control(pDX, IDC_EDIT38, m_readNum_C1a);
129	DDX_Control(pDX, IDC_EDIT39, m_readNum_C1b);
130	DDX_Control(pDX, IDC_EDIT40, m_readNum_C2a);
131	DDX_Control(pDX, IDC_EDIT41, m_readNum_C2b);
132	DDX_Control(pDX, IDC_EDIT42, m_readNum_C3a);
133	DDX_Control(pDX, IDC_EDIT43, m_readNum_C3b);
134	DDX_Control(pDX, IDC_EDIT44, m_readNum_C4a);
135	DDX_Control(pDX, IDC_EDIT45, m_readNum_C4b);
136	DDX_Control(pDX, IDC_EDIT54, m_readN_Seqcond);
137	DDX_Control(pDX, IDC_EDIT57, m_readMAP);
138	DDX_Control(pDX, IDC_EDIT46, m_readTemp_cond_1);
139	DDX_Control(pDX, IDC_EDIT47, m_readTemp_cond_2);
140	DDX_Control(pDX, IDC_EDIT48, m_readTemp_cond_3);
141	DDX_Control(pDX, IDC_EDIT49, m_readTemp_cond_4);
142	DDX_Control(pDX, IDC_EDIT50, m_readTemp_cond_5);
143	DDX_Control(pDX, IDC_EDIT51, m_readTemp_cond_6);
144	DDX_Control(pDX, IDC_EDIT52, m_readTemp_cond_7);
145	DDX_Control(pDX, IDC_EDIT53, m_readTemp_cond_8);
146	DDX_Control(pDX, IDC_EDIT58, m_readStat_C_9);
147	DDX_Control(pDX, IDC_EDIT59, m_readStat_C_10);
148	DDX_Control(pDX, IDC_EDIT60, m_readStat_C_11);
149	DDX_Control(pDX, IDC_EDIT61, m_readStat_C_12);
150	DDX_Control(pDX, IDC_EDIT62, m_readTemp_cond_9);
151	DDX_Control(pDX, IDC_EDIT63, m_readTemp_cond_10);
152	DDX_Control(pDX, IDC_EDIT64, m_readTemp_cond_11);
153	DDX_Control(pDX, IDC_EDIT65, m_readTemp_cond_12);
154	DDX_Control(pDX, IDC_CMD_WRITE2, m_cmdStart);
155	DDX_Control(pDX, IDC_CMD_WRITE3, m_cmdStop);
156	DDX_Control(pDX, IDC_CMD_WRITE4, m_cmdPause);
157	DDX_Control(pDX, IDC_EDIT66, m_readMode);
158	DDX_Control(pDX, IDC_EDIT56, m_readDateD);
159	DDX_Control(pDX, IDC_EDIT55, m_readHeureD);
160	DDX_Control(pDX, IDC_CMD_WRITE5, m_cmdReprise);
161	}
162
163	BOOL CModbucfgView::PreCreateWindow(CREATESTRUCT& cs)
164	{
165	// TODO: Modify the Window class or styles here by modifying
166	// the CREATESTRUCT cs
167
168	return CFormView::PreCreateWindow(cs);
169	}
170
171	/////////////////////////////////////////////////////////////////////////////
172	// CModbucfgView diagnostics
173
174	#ifdef _DEBUG
175	void CModbucfgView::AssertValid() const
176	{
177	CFormView::AssertValid();
178	}
179
180	void CModbucfgView::Dump(CDumpContext& dc) const
181	{
182	CFormView::Dump(dc);
183	}
184
185	CModbucfgDoc* CModbucfgView::GetDocument() // non-debug version is inline
186	{
187	ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CModbucfgDoc)));
188	return (CModbucfgDoc*)m_pDocument;
189	}
190	#endif //_DEBUG
191
192	/////////////////////////////////////////////////////////////////////////////
193	// CModbucfgView message handlers
194
195	void CModbucfgView::OnInitialUpdate()
196	{
197	CFormView::OnInitialUpdate();
198
199	// TODO: Add your specialized code here and/or call the base class
200	LoadControls();
201
202	//Dans le cas d'une CFormView, les ascenseurs apparaissent automatiquement dès que
203	//la surface cliente de la fenêtre devient trop petite par rapport à la surface réelle.
204	//pour ne pas avoir à gérer les ascenseurs, je les supprime: une CFormView hérite de la classe CSCrollView
205	//qui dispose de la fonction SetScaleToFitSize pour adapter la surface de la fenêtre à la taille fenêtrée
206	CRect Rect;
207	GetParentFrame()->GetWindowRect(&Rect);
208	SIZE size;
209	size.cx=Rect.Width();
210	size.cy=Rect.Height();
211	SetScaleToFitSize(size);
212
213	//controle spin
214	CSpinButtonCtrl* pSpin=(CSpinButtonCtrl*)GetDlgItem(IDC_SPIN2);
215	pSpin->SetRange(0,100);//plage du control : 0-100
216	pSpin->SetPos((int)m_spinIndex * 1);//valeur initiale 1
217
218	//tableaux pour les write multiple
219	m_bValueMultiple.SetSize(100);
220	m_sValueMultiple.SetSize(100);
221	m_wValueMultiple.SetSize(100);
222	m_fValueMultiple.SetSize(100);
223	m_dValueMultiple.SetSize(100);
224
225	}
226
227	void CModbucfgView::LoadControls()
228	{
229	CString str;
230	CString sKey;
231	CConnection* pConnection;
232	POSITION pos;
233
234	//Read functions
235	m_cboReadFunctions.AddString(CString("LoopbackTest"));
236	m_cboReadFunctions.AddString(CString("Holding Registers"));
237	m_cboReadFunctions.AddString(CString("Input Registers"));
238	m_cboReadFunctions.AddString(CString("Coil Status"));
239	m_cboReadFunctions.AddString(CString("Discrete Inputs"));
240	m_cboReadFunctions.SetCurSel(1);
241
242	//Write Functions
243	m_cboWriteFunctions.AddString(CString("Single Register"));
244	m_cboWriteFunctions.AddString(CString("Single Coil"));
245	m_cboWriteFunctions.AddString(CString("Multiple Registers"));
246	m_cboWriteFunctions.AddString(CString("Multiple Coils"));
247	m_cboWriteFunctions.SetCurSel(0);
248
249
250	pos = gConnections.GetStartPosition();
251
252	m_cboConnections.ResetContent();
253
254	while (NULL!=pos) {
255	gConnections.GetNextAssoc(pos,sKey,pConnection);
256	m_cboConnections.AddString(sKey);
257	}
258
259	m_cboConnections.SetCurSel(0);
260
261
262	//Default Values
263	str=_T("1");
264	m_edtDevice.SetWindowText(str);
265
266	str=_T("0");
267	m_edtValue.SetWindowText(str);
268	m_edtWriteAddr.SetWindowText(str);
269	m_edtReadAddr.SetWindowText(str);
270
271	str=_T("10");
272	m_edtQuant.SetWindowText(str);
273
274	str=_T("1000");
275	m_edtInterval.SetWindowText(str);
276
277	str=_T("10");
278	m_edtQuant2.SetWindowText(str);
279
280	//Data Type
281	m_cboDataType.AddString(CString("char"));
282	m_cboDataType.AddString(CString("signed - 16"));
283	m_cboDataType.AddString(CString("unsigned - 16"));
284	m_cboDataType.AddString(CString("float - 32"));
285	m_cboDataType.AddString(CString("float - 32 reverse"));
286	m_cboDataType.AddString(CString("double - 64"));
287	m_cboDataType.AddString(CString("double - 64 reverse"));
288	m_cboDataType.SetCurSel(1);
289
290	//associe la variable m_readVacuum à la ressource IDC_LIST2
291	m_readVacuum = (CListCtrl*)GetDlgItem (IDC_LIST2);
292	//
293	m_readVacuum->SetExtendedStyle(LVS_REPORT \| LVS_EX_FULLROWSELECT);
294	//ajout des titres
295	m_readVacuum->InsertColumn(0,_T("Name"),LVCFMT_CENTER,50);
296	m_readVacuum->InsertColumn(1,_T("value"),LVCFMT_CENTER,100);
297	m_readVacuum->SetBkColor(RGB(202,202,255));
298	//nb de lignes
299	// m_readVacuum->SetItemCount(12);
300	//init tableau
301	for (int i=0;i < 12;i++)
302	{
303	str.Format(TEXT("V%d"), i+1);
304	// Insert the item, select every other item.
305	m_readVacuum->InsertItem(LVIF_TEXT\|LVIF_STATE, i, str,
306	(i%2)==0 ? LVIS_SELECTED : 0, LVIS_SELECTED,0, 0);
307	m_readVacuum->SetItemText(i,1,"0");
308	}
309
310	//associe la variable m_readCondParam à la ressource IDC_LIST3
311	m_readCondParam = (CListCtrl*)GetDlgItem (IDC_LIST3);
312	//
313	m_readCondParam->SetExtendedStyle(LVS_REPORT \| LVS_EX_FULLROWSELECT);
314	//ajout des titres
315	m_readCondParam->InsertColumn(0,_T("step number"),LVCFMT_CENTER,40);
316	m_readCondParam->InsertColumn(1,_T("Pi_min"),LVCFMT_CENTER,50);
317	m_readCondParam->InsertColumn(1,_T("Pi_max"),LVCFMT_CENTER,50);
318	m_readCondParam->InsertColumn(1,_T("Tn_max"),LVCFMT_CENTER,50);
319	m_readCondParam->InsertColumn(1,_T("Tp_max"),LVCFMT_CENTER,50);
320	m_readCondParam->InsertColumn(1,_T("Ln"),LVCFMT_CENTER,50);
321	//init tableau
322	for (int i=0;i < 12;i++)
323	{
324	str.Format(TEXT("%d"), i+1);
325	// Insert the item, select every other item.
326	m_readCondParam->InsertItem(LVIF_TEXT\|LVIF_STATE, i, str,
327	(i%2)==0 ? LVIS_SELECTED : 0, LVIS_SELECTED,0, 0);
328	}
329	}
330
331	void CModbucfgView::StartWork()
332	{
333	SCODE sc = ::CoInitializeEx(NULL,COINIT_MULTITHREADED);
334	//SCODE sc = ::CoInitializeEx(NULL,COINIT_APARTMENTTHREADED);
335
336	if (FAILED(sc))
337	{
338	// warn about non-NULL success codes
339	TRACE1("Warning: OleInitialize returned scode = %x",sc);
340	}
341
342	m_dwCount=0;
343	m_dwSum=0;
344	m_dwErrors=0;
345	}
346
347	void CModbucfgView::DoWork()
348	{
349	ldiv_t div_result;
350	float fUpdateSpeed;
351	DWORD dwTime;
352	CString str;
353	WORD nError;
354	static int iFunction=0;
355
356	int iNumLoops=10;
357
358
359	fUpdateSpeed=0.0;
360
361	if ((m_cboReadFunctions.GetCurSel()>=LOOP_BACK_TEST)&&
362	(m_cboReadFunctions.GetCurSel()<=READ_INPUT_STATUS)){
363
364	m_dwCount++;
365	// nError=ExecuteReadFunction(m_cboReadFunctions.GetCurSel(),dwTime,str);
366	nError=ExecuteReadFunction(iFunction++,dwTime,str);
367	if (iFunction==6)iFunction=0;
368	m_dwSum +=dwTime;
369
370	div_result = ldiv(m_dwCount,iNumLoops);
371
372	if (CModbus::ERR_OK!=nError){
373	m_dwErrors++;
374	}
375
376	if (0==div_result.rem){
377	fUpdateSpeed=(float)(iNumLoops*1000)/(float)m_dwSum;
378	m_dwSum=0;
379	}
380	else {
381	fUpdateSpeed=(float)(1*1000)/(float)dwTime;
382	}
383
384	m_staError.SetWindowText(str);
385	str.Format("%d Errors=%d %4.2f(Up./s) ",m_dwCount,m_dwErrors,fUpdateSpeed);
386	m_statStatus.SetWindowText(str);
387	}
388
389
390	}
391
392	void CModbucfgView::EndWork()
393	{
394	::CoUninitialize();
395	}
396
397	void CModbucfgView::OnchkEnablePoll()
398	{
399	CString sText;
400	DWORD dwInterval=0;
401
402	m_edtInterval.GetWindowText(sText);
403	dwInterval=DWORD(atol(sText));
404
405	// if (dwInterval>10000) {
406	if ((dwInterval>10000) \|\| (dwInterval<200)) {
407	AfxMessageBox("Max. is 10000 ms and Min. is 200 ms");
408	dwInterval=10000;
409	sText.Format("%d",dwInterval);
410	m_edtInterval.SetWindowText(sText);
411	return;
412	}
413
414	if (0!=m_butPollEnable.GetCheck()) {
415	if (!IsBusy()) {
416	CreateThread(0,0,NULL,dwInterval);
417	}
418	m_butPollEnable.SetCheck(1);
419	}
420	else {
421	Stop();
422	}
423	}
424
425
426	WORD CModbucfgView::ExecuteReadFunction(int iFunction,DWORD& dwTime, CString& rErrorMessage)
427	{
428	CModbus* pModbus;
429	CShortArray aValues;
430	CByteArray abCoilValues;
431
432	CFloatArray afValues;
433	CDblArray adValues;
434
435	CString str;
436	CString sAux;
437	WORD nError;
438	int i;
439	BOOL bRegisters;
440	DWORD dwStart;
441	CString sKey;
442	CConnection* pConnection =NULL;
443	BYTE byDevice;
444	WORD wQuant;
445	WORD wAddr;
446	int nIndex;
447	int nPreviusCount;
448	int iDataType;
449
450	CListCtrl* vacuum = (CListCtrl*)GetDlgItem (IDC_LIST2);
451	CListCtrl* parameters = (CListCtrl*)GetDlgItem (IDC_LIST3);
452
453	i=m_cboConnections.GetCurSel();
454	if (i<0) {
455	return 0;
456	}
457	else {
458	m_cboConnections.GetLBText(i,sKey);
459
460	if (gConnections.Lookup(sKey,pConnection)) {
461
462	pModbus=pConnection->m_pModbus;
463	}
464	else {
465	ASSERT(FALSE);
466	return 0;
467	}
468	}
469
470	m_edtDevice.GetWindowText(str);
471	byDevice=BYTE(atoi(str));
472
473	switch (iFunction)
474	{
475	case 0:
476	//coils : case READ_OUTPUT_STATUS
477	wQuant=13;
478	abCoilValues.SetSize(wQuant);
479	wAddr=3000;
480	nError=pModbus->ReadOutputStatus(byDevice,wAddr,wQuant, abCoilValues);
481
482	str.Format("%d",abCoilValues[0]);
483	m_readEil.SetWindowText(str);
484	str.Format("%d",abCoilValues[1]);
485	m_readStat_C_1.SetWindowText(str);
486	str.Format("%d",abCoilValues[2]);
487	m_readStat_C_2.SetWindowText(str);
488	str.Format("%d",abCoilValues[3]);
489	m_readStat_C_3.SetWindowText(str);
490	str.Format("%d",abCoilValues[4]);
491	m_readStat_C_4.SetWindowText(str);
492	str.Format("%d",abCoilValues[5]);
493	m_readStat_C_5.SetWindowText(str);
494	str.Format("%d",abCoilValues[6]);
495	m_readStat_C_6.SetWindowText(str);
496	str.Format("%d",abCoilValues[7]);
497	m_readStat_C_7.SetWindowText(str);
498	str.Format("%d",abCoilValues[8]);
499	m_readStat_C_8.SetWindowText(str);
500	str.Format("%d",abCoilValues[9]);
501	m_readStat_C_9.SetWindowText(str);
502	str.Format("%d",abCoilValues[10]);
503	m_readStat_C_10.SetWindowText(str);
504	str.Format("%d",abCoilValues[11]);
505	m_readStat_C_11.SetWindowText(str);
506	str.Format("%d",abCoilValues[12]);
507	m_readStat_C_12.SetWindowText(str);
508	break;
509
510	case 1:
511	//holdings : case READ_OUTPUT_REGISTERS:
512	// iDataType = DATA_UNSIGNED_16;
513	wQuant=125;
514	aValues.SetSize(wQuant);
515	wAddr=2000;
516	nError=pModbus->ReadOutputRegisters(byDevice,wAddr,wQuant, aValues);
517
518	// str.Format("%d",aValues[0]);
519	str.Format("%u",(WORD)aValues[0]);
520	m_readSVd.SetWindowText(str);
521	str.Format("%u",(WORD)aValues[1]);
522	m_readSVfin.SetWindowText(str);
523	str.Format("%u",(WORD)aValues[2]);
524	m_readSV1.SetWindowText(str);
525	str.Format("%u",(WORD)aValues[3]);
526	m_readSV2.SetWindowText(str);
527	str.Format("%u",(WORD)aValues[4]);
528	m_readdtp.SetWindowText(str);
529	str.Format("%u",(WORD)aValues[5]);
530	m_readdt.SetWindowText(str);
531	str.Format("%u",(WORD)aValues[20]);
532	m_readSVil.SetWindowText(str);
533	str.Format("%u",(WORD)aValues[25]);
534	m_readNbal_max.SetWindowText(str);
535	str.Format("%u",(WORD)aValues[26]);
536	m_readFr.SetWindowText(str);
537	str.Format("%u",(WORD)aValues[27]);
538	m_readN_cur.SetWindowText(str);
539
540	/*201011 : voir + bas, si mode!=pulsing griser les boutons start/stop/pause/reprise..
541	//..sinon fonction de RetMAPR
542	switch (aValues[28]){//RetMAPR
543	case 0://conditionnement arreté
544	m_readMAP.SetWindowText("stop");
545	m_cmdStop.EnableWindow(FALSE);//bouton stop
546	m_cmdPause.EnableWindow(FALSE);//bouton pause
547	m_cmdReprise.EnableWindow(FALSE);//bouton reprise
548	m_cmdStart.EnableWindow(TRUE);//bouton start
549	break;
550	case 2: case 3://conditionnement démarré ou repris
551	m_readMAP.SetWindowText("start");
552	m_cmdStart.EnableWindow(FALSE);//bouton start
553	m_cmdReprise.EnableWindow(FALSE);//bouton reprise
554	m_cmdStop.EnableWindow(TRUE);//bouton stop
555	m_cmdPause.EnableWindow(TRUE);//bouton pause
556	break;
557	case 1://conditionnement en pause
558	m_readMAP.SetWindowText("pause");
559	m_cmdPause.EnableWindow(FALSE);//bouton pause
560	m_cmdStart.EnableWindow(FALSE);//bouton start
561	m_cmdReprise.EnableWindow(TRUE);//bouton reprise
562	m_cmdStop.EnableWindow(TRUE);//bouton stop
563	break;
564	}
565	*/
566	switch (aValues[49]){
567	case 0://station en mode init
568	m_readMode.SetWindowText("init");
569	break;
570	case 1://station en mode off
571	m_readMode.SetWindowText("off");
572	break;
573	case 2://station en mode heater
574	m_readMode.SetWindowText("heater");
575	break;
576	case 3://station en mode standby
577	m_readMode.SetWindowText("standby");
578	break;
579	case 4://station en mode pulsing=conditionnement
580	m_readMode.SetWindowText("pulsing");
581	break;
582	case 5://station en mode off
583	m_readMode.SetWindowText("stop");
584	break;
585	}
586	if (aValues[49] != 4)//201011 : on n'est pas ds le mode pulsing
587	{
588	m_cmdStart.EnableWindow(FALSE);//bouton start
589	m_cmdStop.EnableWindow(FALSE);//bouton stop
590	m_cmdPause.EnableWindow(FALSE);//bouton pause
591	m_cmdReprise.EnableWindow(FALSE);//bouton reprise
592	m_readMAP.SetWindowText("stop");
593	}
594	else
595	{//mode pulsing
596	switch (aValues[28]){//RetMAPR
597	case 0://conditionnement arreté
598	m_readMAP.SetWindowText("stop");
599	m_cmdStop.EnableWindow(FALSE);//bouton stop
600	m_cmdPause.EnableWindow(FALSE);//bouton pause
601	m_cmdReprise.EnableWindow(FALSE);//bouton reprise
602	m_cmdStart.EnableWindow(TRUE);//bouton start
603	break;
604	case 2: case 3://conditionnement démarré ou repris
605	m_readMAP.SetWindowText("start");
606	m_cmdStart.EnableWindow(FALSE);//bouton start
607	m_cmdReprise.EnableWindow(FALSE);//bouton reprise
608	m_cmdStop.EnableWindow(TRUE);//bouton stop
609	m_cmdPause.EnableWindow(TRUE);//bouton pause
610	break;
611	case 1://conditionnement en pause
612	m_readMAP.SetWindowText("pause");
613	m_cmdPause.EnableWindow(FALSE);//bouton pause
614	m_cmdStart.EnableWindow(FALSE);//bouton start
615	m_cmdReprise.EnableWindow(TRUE);//bouton reprise
616	m_cmdStop.EnableWindow(TRUE);//bouton stop
617	break;
618	}
619	if (aValues[28] != aValues[48])//message affiché
620	{
621	CString sAux;
622	int nIndex;
623	int nCount;
624	nIndex=m_lstValues.GetCurSel();
625	nCount=m_lstValues.GetCount();
626	m_lstValues.SetRedraw(FALSE);
627	sAux.Format("nI=%d nC=%d,RetMAPR=%d not equal to MAPR=%d",nIndex,nCount,aValues[28],aValues[48]);
628	if (nCount%5)
629	{
630	m_lstValues.SetCurSel(0);
631	}
632	m_lstValues.InsertString(nIndex,sAux);
633	m_lstValues.SetRedraw(TRUE);
634	// m_lstValues.Invalidate(FALSE);
635	}
636	else//pas de message
637	{
638	int nIndex;
639	int nCount;
640	nIndex=m_lstValues.GetCurSel();
641	nCount=m_lstValues.GetCount();
642	for(i=0;i<nCount;++i) {
643	m_lstValues.DeleteString(i);
644	}
645	m_lstValues.SetRedraw(TRUE);
646	// m_lstValues.Invalidate(FALSE);
647	}
648	}//fin mode pulsing
649
650	str.Format("%u",(WORD)aValues[30]);
651	m_readNil.SetWindowText(str);
652	str.Format("%u",(WORD)aValues[31]);
653	m_readNil_stat.SetWindowText(str);
654	str.Format("%u",(WORD)aValues[34]);
655	m_readN_last.SetWindowText(str);
656	str.Format("%u",(WORD)aValues[37]);
657	m_readV_cur.SetWindowText(str);
658	str.Format("%u",((WORD)aValues[40]<<16)+(WORD)aValues[41]);//2 mots de 16 bits
659	m_readTimer.SetWindowText(str);
660	str.Format("%u",(WORD)aValues[42]);
661	m_readNbal.SetWindowText(str);
662	str.Format("%u",(WORD)aValues[47]);
663	m_readN_Seqcond.SetWindowText(str);
664	/*101011 : on se sert de RetMAPR à l'adresse 2028
665	switch (aValues[48]){
666	case 0://conditionnement arreté
667	// str.Format("%d",aValues[48]);
668	m_readMAP.SetWindowText("stop");
669	m_cmdStop.EnableWindow(FALSE);//bouton stop
670	m_cmdPause.EnableWindow(FALSE);//bouton pause
671	m_cmdStart.EnableWindow(TRUE);//bouton start
672	break;
673	case 2://conditionnement démarré
674	m_readMAP.SetWindowText("start");
675	m_cmdStart.EnableWindow(FALSE);//bouton start
676	m_cmdStop.EnableWindow(TRUE);//bouton stop
677	m_cmdPause.EnableWindow(TRUE);//bouton pause
678	break;
679	case 1://conditionnement en pause
680	m_readMAP.SetWindowText("pause");
681	m_cmdPause.EnableWindow(FALSE);//bouton pause
682	m_cmdStart.EnableWindow(TRUE);//bouton start
683	m_cmdStop.EnableWindow(TRUE);//bouton stop
684	break;
685	}
686	*/
687	// str.Format("%d",aValues[49]);
688	// m_readMode.SetWindowText(str);
689	/*201011 : voir + haut, si mode!=pulsing griser les boutons start/stop/pause/reprise..
690	//..sinon fonction de RetMAPR
691	switch (aValues[49]){
692	case 0://station en mode init
693	m_readMode.SetWindowText("init");
694	break;
695	case 1://station en mode off
696	m_readMode.SetWindowText("off");
697	break;
698	case 2://station en mode heater
699	m_readMode.SetWindowText("heater");
700	break;
701	case 3://station en mode standby
702	m_readMode.SetWindowText("standby");
703	break;
704	case 4://station en mode pulsing=conditionnement
705	m_readMode.SetWindowText("pulsing");
706	break;
707	case 5://station en mode off
708	m_readMode.SetWindowText("stop");
709	break;
710	}*/
711	str.Format("%u",(WORD)aValues[50]);
712	m_readNum_C1a.SetWindowText(str);
713	str.Format("%u",(WORD)aValues[51]);
714	m_readNum_C1b.SetWindowText(str);
715	str.Format("%u",(WORD)aValues[52]);
716	m_readNum_C2a.SetWindowText(str);
717	str.Format("%u",(WORD)aValues[53]);
718	m_readNum_C2b.SetWindowText(str);
719	str.Format("%u",(WORD)aValues[54]);
720	m_readNum_C3a.SetWindowText(str);
721	str.Format("%u",(WORD)aValues[55]);
722	m_readNum_C3b.SetWindowText(str);
723	str.Format("%u",(WORD)aValues[56]);
724	m_readNum_C4a.SetWindowText(str);
725	str.Format("%u",(WORD)aValues[57]);
726	m_readNum_C4b.SetWindowText(str);
727	/*
728	str.Format("%u",((WORD)aValues[58]<<16)+(WORD)aValues[59]);//2 mots de 16 bits
729	m_readTemp_cond_1.SetWindowText(str);
730	str.Format("%u",((WORD)aValues[60]<<16)+(WORD)aValues[61]);//2 mots de 16 bits
731	m_readTemp_cond_2.SetWindowText(str);
732	str.Format("%u",((WORD)aValues[62]<<16)+(WORD)aValues[63]);//2 mots de 16 bits
733	m_readTemp_cond_3.SetWindowText(str);
734	str.Format("%u",((WORD)aValues[64]<<16)+(WORD)aValues[65]);//2 mots de 16 bits
735	m_readTemp_cond_4.SetWindowText(str);
736	str.Format("%u",((WORD)aValues[66]<<16)+(WORD)aValues[67]);//2 mots de 16 bits
737	m_readTemp_cond_5.SetWindowText(str);
738	str.Format("%u",((WORD)aValues[68]<<16)+(WORD)aValues[69]);//2 mots de 16 bits
739	m_readTemp_cond_6.SetWindowText(str);
740	str.Format("%u",((WORD)aValues[70]<<16)+(WORD)aValues[71]);//2 mots de 16 bits
741	m_readTemp_cond_7.SetWindowText(str);
742	str.Format("%u",((WORD)aValues[72]<<16)+(WORD)aValues[73]);//2 mots de 16 bits
743	m_readTemp_cond_8.SetWindowText(str);
744	str.Format("%u",((WORD)aValues[74]<<16)+(WORD)aValues[75]);//2 mots de 16 bits
745	m_readTemp_cond_9.SetWindowText(str);
746	str.Format("%u",((WORD)aValues[76]<<16)+(WORD)aValues[77]);//2 mots de 16 bits
747	m_readTemp_cond_10.SetWindowText(str);
748	str.Format("%u",((WORD)aValues[78]<<16)+(WORD)aValues[79]);//2 mots de 16 bits
749	m_readTemp_cond_11.SetWindowText(str);
750	str.Format("%u",((WORD)aValues[80]<<16)+(WORD)aValues[81]);//2 mots de 16 bits
751	m_readTemp_cond_12.SetWindowText(str);
752	*/
753	str.Format("%u",((WORD)aValues[58]));//1 mot de 16 bits
754	m_readTemp_cond_1.SetWindowText(str);
755	str.Format("%u",((WORD)aValues[59]));//1 mot de 16 bits
756	m_readTemp_cond_2.SetWindowText(str);
757	str.Format("%u",((WORD)aValues[60]));//1 mot de 16 bits
758	m_readTemp_cond_3.SetWindowText(str);
759	str.Format("%u",((WORD)aValues[61]));//1 mot de 16 bits
760	m_readTemp_cond_4.SetWindowText(str);
761	str.Format("%u",((WORD)aValues[62]));//1 mot de 16 bits
762	m_readTemp_cond_5.SetWindowText(str);
763	str.Format("%u",((WORD)aValues[63]));//1 mot de 16 bits
764	m_readTemp_cond_6.SetWindowText(str);
765	str.Format("%u",((WORD)aValues[64]));// 1 mot de 16 bits
766	m_readTemp_cond_7.SetWindowText(str);
767	str.Format("%u",((WORD)aValues[65]));//1 mot de 16 bits
768	m_readTemp_cond_8.SetWindowText(str);
769	str.Format("%u",((WORD)aValues[66]));//1 mot de 16 bits
770	m_readTemp_cond_9.SetWindowText(str);
771	str.Format("%u",((WORD)aValues[67]));// mots de 16 bits
772	m_readTemp_cond_10.SetWindowText(str);
773	str.Format("%u",((WORD)aValues[68]));//1 mot de 16 bits
774	m_readTemp_cond_11.SetWindowText(str);
775	str.Format("%u",((WORD)aValues[69]));//1 mot de 16 bits
776	m_readTemp_cond_12.SetWindowText(str);
777
778	break;
779	/* str.Format("%d",aValues[50]);
780	m_readNum_C1a.SetWindowText(str);
781	str.Format("%d",aValues[51]);
782	m_readNum_C1b.SetWindowText(str);
783	str.Format("%d",aValues[52]);
784	m_readNum_C2a.SetWindowText(str);
785	str.Format("%d",aValues[53]);
786	m_readNum_C2b.SetWindowText(str);
787	str.Format("%d",aValues[54]);
788	m_readNum_C3a.SetWindowText(str);
789	str.Format("%d",aValues[55]);
790	m_readNum_C3b.SetWindowText(str);
791	str.Format("%d",aValues[56]);
792	m_readNum_C4a.SetWindowText(str);
793	str.Format("%d",aValues[57]);
794	m_readNum_C4b.SetWindowText(str);
795	str.Format("%d",(aValues[58]<<16)+aValues[59]);//2 mots de 16 bits
796	m_readTemp_cond_1.SetWindowText(str);
797	str.Format("%d",(aValues[60]<<16)+aValues[61]);//2 mots de 16 bits
798	m_readTemp_cond_2.SetWindowText(str);
799	str.Format("%d",(aValues[62]<<16)+aValues[63]);//2 mots de 16 bits
800	m_readTemp_cond_3.SetWindowText(str);
801	str.Format("%d",(aValues[64]<<16)+aValues[65]);//2 mots de 16 bits
802	m_readTemp_cond_4.SetWindowText(str);
803	str.Format("%d",(aValues[66]<<16)+aValues[67]);//2 mots de 16 bits
804	m_readTemp_cond_5.SetWindowText(str);
805	str.Format("%d",(aValues[68]<<16)+aValues[69]);//2 mots de 16 bits
806	m_readTemp_cond_6.SetWindowText(str);
807	str.Format("%d",(aValues[70]<<16)+aValues[71]);//2 mots de 16 bits
808	m_readTemp_cond_7.SetWindowText(str);
809	str.Format("%d",(aValues[72]<<16)+aValues[73]);//2 mots de 16 bits
810	m_readTemp_cond_8.SetWindowText(str);
811	str.Format("%d",(aValues[74]<<16)+aValues[75]);//2 mots de 16 bits
812	m_readTemp_cond_9.SetWindowText(str);
813	str.Format("%d",(aValues[76]<<16)+aValues[77]);//2 mots de 16 bits
814	m_readTemp_cond_10.SetWindowText(str);
815	str.Format("%d",(aValues[78]<<16)+aValues[79]);//2 mots de 16 bits
816	m_readTemp_cond_11.SetWindowText(str);
817	str.Format("%d",(aValues[80]<<16)+aValues[81]);//2 mots de 16 bits
818	m_readTemp_cond_12.SetWindowText(str);
819	break;
820	*/
821
822	case 2:
823	//holdings : case READ_OUTPUT_REGISTERS:
824	// iDataType = DATA_FLOAT;
825	wQuant=17;
826	afValues.SetSize(wQuant);
827	wAddr=2006;
828	//190412:: Normal->Reverse
829	// nError=pModbus->ReadOutputRegisters(byDevice,wAddr,wQuant, afValues);
830	nError=pModbus->ReadOutputRegisters(byDevice,wAddr,wQuant, afValues,CModbus::REAL_REVERSE);
831
832	str.Format("%g",afValues[0]);
833	m_readdP.SetWindowText(str);
834	str.Format("%g",afValues[1]);
835	m_readdPsecu.SetWindowText(str);
836	str.Format("%g",afValues[13]);
837	m_readP_last.SetWindowText(str);
838	str.Format("%g",afValues[16]);
839	m_readPic.SetWindowText(str);
840	break;
841
842	case 3:
843	//holdings : case READ_OUTPUT_REGISTERS:
844	// iDataType = DATA_FLOAT;
845	wQuant=24;
846	afValues.SetSize(wQuant);
847	wAddr=2021;
848	//190412: Normal->Reverse
849	// nError=pModbus->ReadOutputRegisters(byDevice,wAddr,wQuant, afValues);
850	nError=pModbus->ReadOutputRegisters(byDevice,wAddr,wQuant, afValues,CModbus::REAL_REVERSE);
851
852	str.Format("%g",afValues[0]);
853	m_readSleil.SetWindowText(str);
854	str.Format("%g",afValues[1]);
855	m_readSTc.SetWindowText(str);
856	str.Format("%g",afValues[7]);
857	m_readdPil.SetWindowText(str);
858	str.Format("%g",afValues[11]);
859	m_readP_cde.SetWindowText(str);
860	str.Format("%g",afValues[12]);
861	m_readPp.SetWindowText(str);
862	break;
863
864	case 4:
865	//holdings : case READ_OUTPUT_REGISTERS:
866	// iDataType = DATA_FLOAT;
867	wQuant=24;
868	afValues.SetSize(wQuant);
869	wAddr=/2108//2116/2118;//060911
870	//190412: Normal->Reverse
871	// nError=pModbus->ReadOutputRegisters(byDevice,wAddr,wQuant, afValues);
872	nError=pModbus->ReadOutputRegisters(byDevice,wAddr,wQuant, afValues,CModbus::REAL_REVERSE);
873
874	//Pi_max
875	for (int i=0;i < 12;i++)
876	{
877	str.Format("%g",afValues[i]);
878	parameters->SetItemText(i,4,str);
879	}
880	//Pi_min
881	for (int i=12;i < 24;i++)
882	{
883	str.Format("%g",afValues[i]);
884	parameters->SetItemText(i-12,5,str);
885	}
886	break;
887
888	case 5:
889	//holdings : case READ_OUTPUT_REGISTERS:
890	// iDataType = DATA_UNSIGNED_16;
891	wQuant=125;
892	aValues.SetSize(wQuant);
893	wAddr=/2080/2082;//060911
894	nError=pModbus->ReadOutputRegisters(byDevice,wAddr,wQuant, aValues);
895	//Ln
896	for (int i=0;i < 12;i++)
897	{
898	str.Format("%u",(WORD)aValues[i]);
899	parameters->SetItemText(i,1,str);
900	}
901	//Tn_max
902	for (int i=12;i < 24;i++)
903	{
904	str.Format("%u",(WORD)aValues[i]);
905	parameters->SetItemText(i-12,3,str);
906	}
907	//Tp_max : 12 mots de 16 bits ????
908	for (int i=24;i < 36;i++)
909	{
910	str.Format("%u",(WORD)aValues[i]);
911	parameters->SetItemText(i-24,2,str);
912	}
913	//DateHeureD : 6 mots de 16 bits
914	str.Format("%u-%u-%u",(WORD)aValues[84],(WORD)aValues[85],(WORD)aValues[86]);
915	m_readDateD.SetWindowText(str);
916	str.Format("%u:%u:%u",(WORD)aValues[87],(WORD)aValues[88],(WORD)aValues[89]);
917	m_readHeureD.SetWindowText(str);
918	//vacuum
919	// for (int i=90;i < 102;i++)
920	// for (int i=88;i < 100;i++)//060911
921	for (int i=98;i < 110;i++)//101011
922	{
923	str.Format("%u",(WORD)aValues[i]);
924	// vacuum->SetItemText(i-90,1,str);
925	// vacuum->SetItemText(i-88,1,str);
926	vacuum->SetItemText(i-98,1,str);
927	}
928	break;
929	}
930
931	rErrorMessage=pModbus->ErrorMessage(nError);
932	return nError;
933	}
934
935	void CModbucfgView::OnChangeEditInterval()
936	{
937
938	CString sText;
939	DWORD dwInterval=0;
940
941	m_edtInterval.GetWindowText(sText);
942	dwInterval=DWORD(atol(sText));
943
944	// if (dwInterval>10000) {
945	// AfxMessageBox("Max. Interval is 10000 ms");
946	if ((dwInterval>10000) \|\| (dwInterval<200)) {
947	AfxMessageBox("Max. is 10000 ms and Min. is 200 ms");
948	dwInterval=10000;
949	sText.Format("%d",dwInterval);
950	m_edtInterval.SetWindowText(sText);
951	return;
952	}
953
954	SetCycleTime(int(dwInterval));
955	}
956
957	void CModbucfgView::OnCmdWrite()
958	{
959	BYTE byDevice=0;
960	WORD wValue=0;
961	WORD wAddr=0;
962	CModbus* pModbus=GetConnection();
963	WORD nError=CModbus::ERR_OK;
964	CString strValue;
965	CString sVal;
966	CWaitCursor WaitCursor;
967	double dValue=0.0;
968
969	WORD wQuant, wIndex;
970
971	if (NULL==pModbus) {
972	return;
973	}
974
975	m_edtValue.GetWindowText(strValue);
976	sVal= strValue;
977	wValue = (WORD)atoi(strValue);
978
979	m_edtDevice.GetWindowText(strValue);
980	byDevice = (BYTE)atoi(strValue);
981
982	m_edtWriteAddr.GetWindowText(strValue);
983	wAddr = (WORD)atoi(strValue);
984
985	m_edtQuant2.GetWindowText(strValue);
986	wQuant=(BYTE)(atoi(strValue));
987
988	m_edtIndex.GetWindowText(strValue);
989	wIndex=(BYTE)(atoi(strValue));
990
991	switch (m_cboWriteFunctions.GetCurSel()) {
992
993	case PRESET_SINGLE_REGISTER:
994
995	switch(m_cboDataType.GetCurSel()) {
996
997	case DATA_CHAR:
998	sVal.TrimLeft();
999	if (sVal.GetLength()>0) {
1000	nError=pModbus->PresetSingleRegister(byDevice,wAddr,WORD(sVal[0]));
1001	}
1002	break;
1003	case DATA_SIGNED_16:
1004	case DATA_UNSIGNED_16:
1005	if (sVal.GetLength()>0) {
1006	nError=pModbus->PresetSingleRegister(byDevice,wAddr,WORD(atoi(sVal)));
1007	}
1008	break;
1009	case DATA_FLOAT:
1010	nError=pModbus->PresetSingleRegister(byDevice,wAddr,float(atof(sVal)));
1011	break;
1012	case DATA_FLOAT_REVERSE:
1013	nError=pModbus->PresetSingleRegister(byDevice,wAddr,float(atof(sVal)),CModbus::REAL_REVERSE);
1014	break;
1015	case DATA_DOUBLE:
1016	nError=pModbus->PresetSingleRegister(byDevice,wAddr,double(atof(sVal)));
1017
1018	break;
1019	case DATA_DOUBLE_REVERSE:
1020	nError=pModbus->PresetSingleRegister(byDevice,wAddr,double(atof(sVal)),CModbus::REAL_REVERSE);
1021	break;
1022	}
1023	if(nError!=CModbus::ERR_OK){
1024	WaitCursor.Restore();
1025	AfxMessageBox(pModbus->ErrorMessage(nError));
1026	}
1027	break;
1028
1029	case FORCE_SINGLE_COIL:
1030	nError=pModbus->ForceSingleCoil(byDevice,wAddr,(BOOL)wValue);
1031	if(nError!=CModbus::ERR_OK){
1032	WaitCursor.Restore();
1033	AfxMessageBox(pModbus->ErrorMessage(nError));
1034	}
1035	break;
1036
1037	case WRITE_MULTIPLE_REGISTERS:
1038	{
1039	//controle spin
1040	CSpinButtonCtrl* pSpin=(CSpinButtonCtrl*)GetDlgItem(IDC_SPIN2);
1041
1042	switch(m_cboDataType.GetCurSel()) {
1043	case DATA_CHAR:
1044	sVal.TrimLeft();
1045	if (sVal.GetLength()>0) {
1046	m_sValueMultiple.SetAt(wIndex,wValue);
1047	nError=pModbus->PresetMultipleRegisters(byDevice,wAddr,wQuant,m_sValueMultiple);
1048	}
1049	break;
1050	case DATA_SIGNED_16:
1051	case DATA_UNSIGNED_16:
1052	if (sVal.GetLength()>0) {
1053	m_wValueMultiple.SetAt(wIndex,wValue);
1054	nError=pModbus->PresetMultipleRegisters(byDevice,wAddr,wQuant,m_wValueMultiple);
1055	}
1056	break;
1057	case DATA_FLOAT:
1058	m_fValueMultiple.SetAt(wIndex,wValue);
1059	nError=pModbus->PresetMultipleRegisters(byDevice,wAddr,wQuant,m_fValueMultiple);
1060	break;
1061	case DATA_FLOAT_REVERSE:
1062	m_fValueMultiple.SetAt(wIndex,wValue);
1063	nError=pModbus->PresetMultipleRegisters(byDevice,wAddr,wQuant,m_fValueMultiple,CModbus::REAL_REVERSE);
1064	break;
1065	case DATA_DOUBLE:
1066	m_dValueMultiple.SetAt(wIndex,wValue);
1067	nError=pModbus->PresetMultipleRegisters(byDevice,wAddr,wQuant,m_dValueMultiple);
1068	break;
1069	case DATA_DOUBLE_REVERSE:
1070	m_dValueMultiple.SetAt(wIndex,wValue);
1071	nError=pModbus->PresetMultipleRegisters(byDevice,wAddr,wQuant,m_dValueMultiple,CModbus::REAL_REVERSE);
1072	break;
1073	}
1074	if(nError!=CModbus::ERR_OK){
1075	WaitCursor.Restore();
1076	AfxMessageBox(pModbus->ErrorMessage(nError));
1077	}
1078	}
1079	break;
1080
1081	case WRITE_MULTIPLE_COILS:
1082	{
1083	//controle spin
1084	CSpinButtonCtrl* pSpin=(CSpinButtonCtrl*)GetDlgItem(IDC_SPIN2);
1085	// pSpin->SetRange(0,100);//plage du control : 0-100
1086
1087	m_bValueMultiple.SetAt(wIndex,((wValue!=0)?1:0));
1088
1089	nError=pModbus->ForceMultipleCoils(byDevice,wAddr,wQuant,m_bValueMultiple);
1090	if(nError!=CModbus::ERR_OK){
1091	WaitCursor.Restore();
1092	AfxMessageBox(pModbus->ErrorMessage(nError));
1093	}
1094	}
1095	break;
1096
1097	}
1098
1099	}
1100
1101	CModbus* CModbucfgView::GetConnection()
1102	{
1103
1104	int i;
1105	CModbus* pModbus=NULL;
1106	CConnection* pConnection=NULL;
1107	CString sKey;
1108
1109	i=m_cboConnections.GetCurSel();
1110
1111	if (i<0) {
1112	ASSERT(FALSE);
1113	pModbus=NULL;
1114	}
1115	else {
1116	m_cboConnections.GetLBText(i,sKey);
1117
1118	if (gConnections.Lookup(sKey,pConnection)) {
1119
1120	pModbus=pConnection->m_pModbus;
1121	}
1122	else {
1123	ASSERT(FALSE);
1124	pModbus=NULL;
1125	}
1126	}
1127
1128	return pModbus;
1129	}
1130
1131	void CModbucfgView::OnCbnSelchangeCboReadFunction()
1132	{
1133	// TODO : ajoutez ici le code de votre gestionnaire de notification de contrôle
1134	}
1135
1136	void CModbucfgView::OnCbnSelchangeCboWriteFunction()
1137	{
1138	// TODO : ajoutez ici le code de votre gestionnaire de notification de contrôle
1139	}
1140
1141
1142	void CModbucfgView::OnAppMemMap()
1143	{
1144	// TODO : ajoutez ici le code de votre gestionnaire de commande
1145	AfxMessageBox(_T("modbus memory map : \n\n -holding registers adr:0x2000 qty:300\n-coils adr:0x3000 qty:100\n-discrete inputs adr:0x1000 qty:4\n-input registers adr:0x4000 qty:4"));
1146	}
1147
1148	void CModbucfgView::OnEnChangeEditQuant()
1149	{
1150	// TODO : S'il s'agit d'un contrôle RICHEDIT, le contrôle
1151	// n'enverra la notification que si vous substituez la fonction __super::OnInitDialog()
1152	// et l'appel CRichEditCtrl().SetEventMask()
1153	// par l'indicateur ENM_CHANGE assorti de l'opérateur OR dans le masque.
1154
1155	// TODO : Ajoutez ici le code de votre gestionnaire de notification de contrôle
1156	}
1157
1158	void CModbucfgView::OnEnChangeEditAddr()
1159	{
1160	// TODO : S'il s'agit d'un contrôle RICHEDIT, le contrôle
1161	// n'enverra la notification que si vous substituez la fonction __super::OnInitDialog()
1162	// et l'appel CRichEditCtrl().SetEventMask()
1163	// par l'indicateur ENM_CHANGE assorti de l'opérateur OR dans le masque.
1164
1165	// TODO : Ajoutez ici le code de votre gestionnaire de notification de contrôle
1166	}
1167
1168	void CModbucfgView::OnEnChangeEditQuant2()
1169	{
1170	// TODO : S'il s'agit d'un contrôle RICHEDIT, le contrôle
1171	// n'enverra la notification que si vous substituez la fonction __super::OnInitDialog()
1172	// et l'appel CRichEditCtrl().SetEventMask()
1173	// par l'indicateur ENM_CHANGE assorti de l'opérateur OR dans le masque.
1174
1175	// TODO : Ajoutez ici le code de votre gestionnaire de notification de contrôle
1176	}
1177
1178	void CModbucfgView::OnLbnSelchangeList5()
1179	{
1180	// TODO : ajoutez ici le code de votre gestionnaire de notification de contrôle
1181	}
1182
1183	void CModbucfgView::OnLbnSelchangeLstValues()
1184	{
1185	// TODO : ajoutez ici le code de votre gestionnaire de notification de contrôle
1186	}
1187
1188	void CModbucfgView::OnEnChangeEditAddrWri()
1189	{
1190	// TODO : S'il s'agit d'un contrôle RICHEDIT, le contrôle
1191	// n'enverra la notification que si vous substituez la fonction __super::OnInitDialog()
1192	// et l'appel CRichEditCtrl().SetEventMask()
1193	// par l'indicateur ENM_CHANGE assorti de l'opérateur OR dans le masque.
1194
1195	// TODO : Ajoutez ici le code de votre gestionnaire de notification de contrôle
1196	}
1197
1198	void CModbucfgView::OnEnChangeEditValue()
1199	{
1200	// TODO : S'il s'agit d'un contrôle RICHEDIT, le contrôle
1201	// n'enverra la notification que si vous substituez la fonction __super::OnInitDialog()
1202	// et l'appel CRichEditCtrl().SetEventMask()
1203	// par l'indicateur ENM_CHANGE assorti de l'opérateur OR dans le masque.
1204
1205	// TODO : Ajoutez ici le code de votre gestionnaire de notification de contrôle
1206	}
1207
1208
1209
1210	void CModbucfgView::OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
1211	{
1212	// TODO : ajoutez ici le code de votre gestionnaire de messages et/ou les paramètres par défaut des appels
1213
1214	if (nSBCode == SB_ENDSCROLL)
1215	{
1216	return ;//rejeter les messages non validess
1217	}
1218	//treiter uniquement les messagse de défilement de IDC_SPIN2)
1219	if (pScrollBar->GetDlgCtrlID()==IDC_SPIN2)
1220	{
1221	CString strValue;
1222	strValue.Format("%d",(int)nPos);
1223	((CSpinButtonCtrl*)pScrollBar)->GetBuddy()->SetWindowText(strValue);
1224	}
1225
1226	__super::OnVScroll(nSBCode, nPos, pScrollBar);
1227	}
1228
1229
1230	void CModbucfgView::OnCmdRead()
1231	{
1232	ldiv_t div_result;
1233	float fUpdateSpeed;
1234	DWORD dwTime;
1235	CString str;
1236	WORD nError;
1237
1238	int iNumLoops=10;
1239
1240
1241	fUpdateSpeed=0.0;
1242
1243	if ((m_cboReadFunctions.GetCurSel()>=LOOP_BACK_TEST)&&
1244	(m_cboReadFunctions.GetCurSel()<=READ_INPUT_STATUS)){
1245
1246	m_dwCount++;
1247	nError=ExecuteCmdReadFunction(m_cboReadFunctions.GetCurSel(),dwTime,str);
1248	m_dwSum +=dwTime;
1249
1250	div_result = ldiv(m_dwCount,iNumLoops);
1251
1252	if (CModbus::ERR_OK!=nError){
1253	m_dwErrors++;
1254	}
1255
1256	if (0==div_result.rem){
1257	fUpdateSpeed=(float)(iNumLoops*1000)/(float)m_dwSum;
1258	m_dwSum=0;
1259	}
1260	else {
1261	fUpdateSpeed=(float)(1*1000)/(float)dwTime;
1262	}
1263
1264	m_staError.SetWindowText(str);
1265	str.Format("%d Errors=%d %4.2f(Up./s) ",m_dwCount,m_dwErrors,fUpdateSpeed);
1266	m_statStatus.SetWindowText(str);
1267	}
1268
1269	}
1270
1271	WORD CModbucfgView::ExecuteCmdReadFunction(int iFunction,DWORD& dwTime, CString& rErrorMessage)
1272	{
1273	CModbus* pModbus;
1274	CShortArray aValues;
1275	CByteArray abCoilValues;
1276
1277	CFloatArray afValues;
1278	CDblArray adValues;
1279
1280	CString str;
1281	CString sAux;
1282	WORD nError;
1283	int i;
1284	BOOL bRegisters;
1285	DWORD dwStart;
1286	CString sKey;
1287	CConnection* pConnection =NULL;
1288	BYTE byDevice;
1289	WORD wQuant;
1290	WORD wAddr;
1291	int nIndex;
1292	int nPreviusCount;
1293	int iDataType;
1294
1295	i=m_cboConnections.GetCurSel();
1296
1297	iDataType= m_cboDataType.GetCurSel();
1298
1299	if (i<0) {
1300	return 0;
1301	}
1302	else {
1303	m_cboConnections.GetLBText(i,sKey);
1304
1305	if (gConnections.Lookup(sKey,pConnection)) {
1306
1307	pModbus=pConnection->m_pModbus;
1308	}
1309	else {
1310	ASSERT(FALSE);
1311	return 0;
1312	}
1313	}
1314
1315	m_edtDevice.GetWindowText(str);
1316
1317	byDevice=BYTE(atoi(str));
1318
1319	m_edtQuant.GetWindowText(str);
1320	wQuant=BYTE(atoi(str));
1321
1322	m_edtReadAddr.GetWindowText(str);
1323	wAddr=WORD(atoi(str));
1324
1325	switch (iFunction) {
1326
1327	case LOOP_BACK_TEST:
1328	dwStart=::timeGetTime();
1329	nError=pModbus->LoopbackTest(byDevice);
1330	dwTime=::timeGetTime()-dwStart;
1331	str="";
1332	bRegisters=FALSE;
1333	break;
1334
1335	case READ_OUTPUT_REGISTERS:
1336	dwStart=::timeGetTime();
1337	switch (iDataType) {
1338	case DATA_CHAR:
1339	case DATA_SIGNED_16:
1340	case DATA_UNSIGNED_16:
1341	aValues.SetSize(wQuant);
1342	nError=pModbus->ReadOutputRegisters(byDevice,wAddr,wQuant, aValues);
1343	break;
1344	case DATA_FLOAT:
1345	afValues.SetSize(wQuant);
1346	nError=pModbus->ReadOutputRegisters(byDevice,wAddr,wQuant, afValues);
1347	break;
1348	case DATA_FLOAT_REVERSE:
1349	afValues.SetSize(wQuant);
1350	nError=pModbus->ReadOutputRegisters(byDevice,wAddr,wQuant, afValues,CModbus::REAL_REVERSE);
1351	break;
1352	case DATA_DOUBLE:
1353	adValues.SetSize(wQuant);
1354	nError=pModbus->ReadOutputRegisters(byDevice,wAddr,wQuant, adValues);
1355	break;
1356	case DATA_DOUBLE_REVERSE:
1357	adValues.SetSize(wQuant);
1358	nError=pModbus->ReadOutputRegisters(byDevice,wAddr,wQuant, adValues,CModbus::REAL_REVERSE);
1359	break;
1360	}
1361	dwTime=::timeGetTime()-dwStart;
1362	bRegisters=TRUE;
1363	break;
1364
1365	case READ_INPUT_REGISTERS:
1366	dwStart=::timeGetTime();
1367	switch (iDataType) {
1368	case DATA_CHAR:
1369	case DATA_SIGNED_16:
1370	case DATA_UNSIGNED_16:
1371	aValues.SetSize(wQuant);
1372	nError=pModbus->ReadInputRegisters(byDevice,wAddr,wQuant, aValues);
1373	break;
1374	case DATA_FLOAT:
1375	afValues.SetSize(wQuant);
1376	nError=pModbus->ReadInputRegisters(byDevice,wAddr,wQuant, afValues);
1377	break;
1378	case DATA_FLOAT_REVERSE:
1379	afValues.SetSize(wQuant);
1380	nError=pModbus->ReadInputRegisters(byDevice,wAddr,wQuant, afValues,CModbus::REAL_REVERSE);
1381	break;
1382	case DATA_DOUBLE:
1383	adValues.SetSize(wQuant);
1384	nError=pModbus->ReadInputRegisters(byDevice,wAddr,wQuant, adValues);
1385	break;
1386	case DATA_DOUBLE_REVERSE:
1387	adValues.SetSize(wQuant);
1388	nError=pModbus->ReadInputRegisters(byDevice,wAddr,wQuant, adValues,CModbus::REAL_REVERSE);
1389	break;
1390	}
1391	dwTime=::timeGetTime()-dwStart;
1392	bRegisters=TRUE;
1393	break;
1394
1395	case READ_OUTPUT_STATUS:
1396	dwStart=::timeGetTime();
1397	abCoilValues.SetSize(wQuant);
1398	nError=pModbus->ReadOutputStatus(byDevice,wAddr,wQuant, abCoilValues);
1399	dwTime=::timeGetTime()-dwStart;
1400	bRegisters=FALSE;
1401	break;
1402
1403	case READ_INPUT_STATUS:
1404	dwStart=::timeGetTime();
1405	abCoilValues.SetSize(wQuant);
1406	nError=pModbus->ReadInputStatus(byDevice,wAddr,wQuant, abCoilValues);
1407	dwTime=::timeGetTime()-dwStart;
1408	bRegisters=FALSE;
1409	break;
1410	}
1411
1412	nIndex=m_lstValues.GetCurSel();
1413	nPreviusCount=m_lstValues.GetCount();
1414
1415	m_lstValues.SetRedraw(FALSE);
1416
1417	if (bRegisters) {
1418	for(i=0;i<wQuant;++i) {
1419	switch (iDataType) {
1420	case DATA_CHAR:
1421	sAux.Format("[%u]=%c 0x%x",wAddr+i,(char)aValues[i],(WORD)aValues[i]);
1422	break;
1423	case DATA_SIGNED_16:
1424	sAux.Format("[%u]=%d 0x%x",wAddr+i,aValues[i],(WORD)aValues[i]);
1425	break;
1426	case DATA_UNSIGNED_16:
1427	sAux.Format("[%u]=%d 0x%x",wAddr+i,(WORD)aValues[i],(WORD)aValues[i]);
1428	break;
1429	case DATA_FLOAT:
1430	case DATA_FLOAT_REVERSE:
1431	sAux.Format("[%u]=%g ",wAddr+2*i,afValues[i]);
1432	break;
1433	case DATA_DOUBLE:
1434	case DATA_DOUBLE_REVERSE:
1435	sAux.Format("[%u]=%g ",wAddr+4*i,adValues[i]);
1436	break;
1437	}
1438	//sAux.Format("[%u]=%d %d 0x%x ",wAddr+i,aValues[i],(WORD)aValues[i],(WORD)aValues[i]);
1439	m_lstValues.DeleteString(i);
1440	m_lstValues.InsertString(i,sAux);
1441	}
1442	}
1443	else {
1444	for(i=0;i<abCoilValues.GetSize();++i) {
1445	sAux.Format("[%u]=%d ",wAddr+i,abCoilValues[i]);
1446	m_lstValues.DeleteString(i);
1447	m_lstValues.InsertString(i,sAux);
1448	}
1449	}
1450
1451	if (nPreviusCount>wQuant) {
1452	for (i=wQuant;i<nPreviusCount;i++){
1453	m_lstValues.DeleteString(wQuant);
1454	}
1455	}
1456
1457	if ((nIndex>0)&&(nIndex<m_lstValues.GetCount())) {
1458	m_lstValues.SetCurSel(nIndex);
1459	}
1460
1461	m_lstValues.SetRedraw(TRUE);
1462	m_lstValues.Invalidate(FALSE);
1463
1464	rErrorMessage=pModbus->ErrorMessage(nError);
1465	return nError;
1466	}
1467
1468	void CModbucfgView::OnEnChangeEdit16()
1469	{
1470	BYTE byDevice=0;
1471	WORD wAddr=2023;
1472	CModbus* pModbus=GetConnection();
1473	WORD nError=CModbus::ERR_OK;
1474	CString str, sVal;
1475	CWaitCursor WaitCursor;
1476
1477	if (pModbus==NULL)
1478	return;
1479
1480	m_edtDevice.GetWindowText(str);
1481	byDevice = (BYTE)atoi(str);
1482
1483	GetDlgItem(IDC_EDIT16)->GetWindowText(sVal);
1484	AfxMessageBox("CModbucfgView::OnEnChangeEdit16()");
1485	//case DATA_FLOAT:
1486	nError=pModbus->PresetSingleRegister(byDevice,wAddr,float(atof(sVal)));
1487	if(nError!=CModbus::ERR_OK){
1488	WaitCursor.Restore();
1489	AfxMessageBox(pModbus->ErrorMessage(nError));
1490	}
1491	}
1492
1493	void CModbucfgView::OnBnClickedButton1()
1494	{
1495	CString OpenFilter;
1496	OpenFilter = "Text File (.txt)\|.txt\|\|";
1497
1498	//créer l'instance avec le constructeur
1499	CFileDialog FileOpenDialog(
1500	TRUE,//ouverture de la boite de dialogue
1501	NULL,
1502	NULL,
1503	OFN_FILEMUSTEXIST\|OFN_HIDEREADONLY\|OFN_PATHMUSTEXIST,
1504	OpenFilter, // filtre
1505	AfxGetMainWnd()); // la fenetre parent
1506
1507	if(FileOpenDialog.DoModal()==IDOK)//affichage
1508	{// ouverture de fichier avec la structure suivante :
1509	//SVil Sleil STc Nbal_max Fr N_cur N_Seqcond Num_C(8x)
1510	unsigned int wTmpBuf;
1511	float fTmpBuf;
1512	CWordArray writeParamInit_120;
1513	CFloatArray writeParamInit_121;
1514	writeParamInit_120.SetSize(100);//pr les adresses modbus
1515	writeParamInit_121.SetSize(100);
1516	CString str;
1517	FILE* pFile = fopen (FileOpenDialog.GetPathName(), "r");
1518	if(pFile == NULL)
1519	return;
1520	/* ptr au debut du fichier*/
1521	fseek( pFile, 0L, SEEK_SET );
1522	/* lecture a artir du fichier*/
1523	fscanf(pFile,"%d ",&wTmpBuf);
1524	writeParamInit_120.SetAtGrow(0,wTmpBuf);//SVil
1525	fscanf(pFile,"%f ",&fTmpBuf);
1526	writeParamInit_121.SetAtGrow(0,fTmpBuf);//Sleil
1527	fscanf(pFile,"%f ",&fTmpBuf);
1528	writeParamInit_121.SetAtGrow(1,fTmpBuf);//STc
1529	for (int i=3;i<14;i++){//nb de mots ds le fichier
1530	fscanf(pFile,"%d ",&wTmpBuf);
1531	if (i<5)
1532	writeParamInit_120.SetAtGrow(i+2,wTmpBuf);//Nbal_max/Fr
1533	else if (i==5)
1534	writeParamInit_120.SetAtGrow(i+22,wTmpBuf);//NSeq_cond
1535	else if (i>5)
1536	writeParamInit_120.SetAtGrow(i+24,wTmpBuf);//8xNum_C
1537	}
1538	fclose(pFile);
1539
1540	str.Format("SVil=%d, Sleil=%f NSeqcond=%d",writeParamInit_120[0],writeParamInit_121[0],writeParamInit_120[27]);
1541	AfxMessageBox(str);
1542
1543	//copie des buffers
1544	m_wValueMultiple.Copy( writeParamInit_120 );
1545	m_fValueMultiple.Copy( writeParamInit_121 );
1546	}
1547	}
1548
1549	void CModbucfgView::OnBnClickedButton2()
1550	{
1551	BYTE byDevice=0;
1552	WORD wAddr=0;
1553	CString strValue;
1554	CWaitCursor WaitCursor;
1555
1556	WORD wQuant;
1557
1558	m_edtDevice.GetWindowText(strValue);
1559	byDevice = (BYTE)atoi(strValue);
1560
1561	// case DATA_UNSIGNED_16:
1562	CModbus* pModbus=GetConnection();
1563	WORD nError=CModbus::ERR_OK;
1564	if (NULL==pModbus) {
1565	return;
1566	}
1567	wAddr = 2020;
1568	wQuant=38;
1569	nError=pModbus->PresetMultipleRegisters(byDevice,wAddr,wQuant,m_wValueMultiple);
1570
1571	// case DATA_FLOAT:
1572	pModbus=GetConnection();
1573	if (NULL==pModbus) {
1574	return;
1575	}
1576	wAddr = 2021;
1577	wQuant=2;
1578	nError=pModbus->PresetMultipleRegisters(byDevice,wAddr,wQuant,m_fValueMultiple);
1579
1580	if(nError!=CModbus::ERR_OK){
1581	WaitCursor.Restore();
1582	AfxMessageBox(pModbus->ErrorMessage(nError));
1583	}
1584	}
1585
1586
1587	void CModbucfgView::OnCmdStart()
1588	{
1589	BYTE byDevice=0;
1590	WORD wAddr=2048;
1591	CModbus* pModbus=GetConnection();
1592	WORD nError=CModbus::ERR_OK;
1593	CString strValue;
1594	CWaitCursor WaitCursor;
1595
1596	if (NULL==pModbus) {
1597	return;
1598	}
1599
1600	CString modeString;
1601	m_readMode.GetWindowText(modeString);
1602	if (strncmp("PULSING",modeString,8))//on n'est pas en mode conditionnement
1603	{
1604	return;
1605	}
1606
1607	m_edtDevice.GetWindowText(strValue);
1608	byDevice = (BYTE)atoi(strValue);
1609
1610	nError=pModbus->PresetSingleRegister(byDevice,wAddr,WORD(0x2));
1611	if(nError!=CModbus::ERR_OK){
1612	WaitCursor.Restore();
1613	AfxMessageBox(pModbus->ErrorMessage(nError));
1614	}
1615	}
1616
1617	void CModbucfgView::OnCmdStop()
1618	{
1619	BYTE byDevice=0;
1620	WORD wAddr=2048;
1621	CModbus* pModbus=GetConnection();
1622	WORD nError=CModbus::ERR_OK;
1623	CString strValue;
1624	CWaitCursor WaitCursor;
1625
1626	if (NULL==pModbus) {
1627	return;
1628	}
1629
1630	CString modeString;
1631	m_readMode.GetWindowText(modeString);
1632	if (strncmp("PULSING",modeString,8))//on n'est pas en mode conditionnement
1633	{
1634	return;
1635	}
1636
1637	m_edtDevice.GetWindowText(strValue);
1638	byDevice = (BYTE)atoi(strValue);
1639
1640	nError=pModbus->PresetSingleRegister(byDevice,wAddr,WORD(0x0));
1641	if(nError!=CModbus::ERR_OK){
1642	WaitCursor.Restore();
1643	AfxMessageBox(pModbus->ErrorMessage(nError));
1644	}
1645	}
1646
1647	void CModbucfgView::OnCmdPause()
1648	{
1649	BYTE byDevice=0;
1650	WORD wAddr=2048;
1651	CModbus* pModbus=GetConnection();
1652	WORD nError=CModbus::ERR_OK;
1653	CString strValue;
1654	CWaitCursor WaitCursor;
1655
1656	if (NULL==pModbus) {
1657	return;
1658	}
1659
1660	CString modeString;
1661	m_readMode.GetWindowText(modeString);
1662	if (strncmp("PULSING",modeString,8))//on n'est pas en mode conditionnement
1663	{
1664	return;
1665	}
1666
1667	m_edtDevice.GetWindowText(strValue);
1668	byDevice = (BYTE)atoi(strValue);
1669
1670	nError=pModbus->PresetSingleRegister(byDevice,wAddr,WORD(0x1));
1671	if(nError!=CModbus::ERR_OK){
1672	WaitCursor.Restore();
1673	AfxMessageBox(pModbus->ErrorMessage(nError));
1674	}
1675	}
1676
1677	void CModbucfgView::OnButtonReprise()
1678	{
1679	BYTE byDevice=0;
1680	WORD wAddr=2048;
1681	CModbus* pModbus=GetConnection();
1682	WORD nError=CModbus::ERR_OK;
1683	CString strValue;
1684	CWaitCursor WaitCursor;
1685
1686	if (NULL==pModbus) {
1687	return;
1688	}
1689
1690	CString modeString;
1691	m_readMode.GetWindowText(modeString);
1692	if (strncmp("PULSING",modeString,8))//on n'est pas en mode conditionnement
1693	{
1694	return;
1695	}
1696
1697	m_edtDevice.GetWindowText(strValue);
1698	byDevice = (BYTE)atoi(strValue);
1699
1700	nError=pModbus->PresetSingleRegister(byDevice,wAddr,WORD(0x3));
1701	if(nError!=CModbus::ERR_OK){
1702	WaitCursor.Restore();
1703	AfxMessageBox(pModbus->ErrorMessage(nError));
1704	}
1705	}

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: trunk/XSUCL/ModbucfgView.cpp

Download in other formats: