source: trunk/XSUCL/ModbucfgView.cpp@ 45

Last change on this file since 45 was 14, checked in by marrucho, 12 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
15static char THIS_FILE[] = __FILE__;
16#endif
17
18/////////////////////////////////////////////////////////////////////////////
19// CModbucfgView
20
21IMPLEMENT_DYNCREATE(CModbucfgView, CFormView)
22
23BEGIN_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)
48END_MESSAGE_MAP()
49
50/////////////////////////////////////////////////////////////////////////////
51// CModbucfgView construction/destruction
52
53CModbucfgView::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
65CModbucfgView::~CModbucfgView()
66{
67}
68
69void 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
163BOOL 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
175void CModbucfgView::AssertValid() const
176{
177 CFormView::AssertValid();
178}
179
180void CModbucfgView::Dump(CDumpContext& dc) const
181{
182 CFormView::Dump(dc);
183}
184
185CModbucfgDoc* 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
195void 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
227void 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
331void 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
347void 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
392void CModbucfgView::EndWork()
393{
394 ::CoUninitialize();
395}
396
397void 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
426WORD 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
935void 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
957void 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
1101CModbus* 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
1131void CModbucfgView::OnCbnSelchangeCboReadFunction()
1132{
1133 // TODO : ajoutez ici le code de votre gestionnaire de notification de contrôle
1134}
1135
1136void CModbucfgView::OnCbnSelchangeCboWriteFunction()
1137{
1138 // TODO : ajoutez ici le code de votre gestionnaire de notification de contrôle
1139}
1140
1141
1142void 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
1148void 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
1158void 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
1168void 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
1178void CModbucfgView::OnLbnSelchangeList5()
1179{
1180 // TODO : ajoutez ici le code de votre gestionnaire de notification de contrôle
1181}
1182
1183void CModbucfgView::OnLbnSelchangeLstValues()
1184{
1185 // TODO : ajoutez ici le code de votre gestionnaire de notification de contrôle
1186}
1187
1188void 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
1198void 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
1210void 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
1230void 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
1271WORD 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
1468void 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
1493void 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
1549void 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
1587void 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
1617void 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
1647void 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
1677void 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.