1 /****************************************************************************
2
3 (c) SYSTEC electronic GmbH, D-07973 Greiz, August-Bebel-Str. 29
4 www.systec-electronic.com
5
6 Project: openPOWERLINK
7
8 Description: source file for error handler module
9
10 License:
11
12 Redistribution and use in source and binary forms, with or without
13 modification, are permitted provided that the following conditions
14 are met:
15
16 1. Redistributions of source code must retain the above copyright
17 notice, this list of conditions and the following disclaimer.
18
19 2. Redistributions in binary form must reproduce the above copyright
20 notice, this list of conditions and the following disclaimer in the
21 documentation and/or other materials provided with the distribution.
22
23 3. Neither the name of SYSTEC electronic GmbH nor the names of its
24 contributors may be used to endorse or promote products derived
25 from this software without prior written permission. For written
26 permission, please contact info@systec-electronic.com.
27
28 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
29 "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
30 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
31 FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
32 COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
33 INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
34 BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
35 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
36 CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
37 LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
38 ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
39 POSSIBILITY OF SUCH DAMAGE.
40
41 Severability Clause:
42
43 If a provision of this License is or becomes illegal, invalid or
44 unenforceable in any jurisdiction, that shall not affect:
45 1. the validity or enforceability in that jurisdiction of any other
46 provision of this License; or
47 2. the validity or enforceability in other jurisdictions of that or
48 any other provision of this License.
49
50 -------------------------------------------------------------------------
51
52 $RCSfile: EplErrorHandlerk.c,v $
53
54 $Author: D.Krueger $
55
56 $Revision: 1.9 $ $Date: 2008/10/17 15:32:32 $
57
58 $State: Exp $
59
60 Build Environment:
61 GCC V3.4
62
63 -------------------------------------------------------------------------
64
65 Revision History:
66
67 2006/10/02 d.k.: start of the implementation
68
69 ****************************************************************************/
70
71 #include "kernel/EplErrorHandlerk.h"
72 #include "EplNmt.h"
73 #include "kernel/EplEventk.h"
74 #include "kernel/EplObdk.h" // function prototyps of the EplOBD-Modul
75 #include "kernel/EplDllk.h"
76
77 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_DLLK)) != 0)
78
79 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDK)) == 0)
80 #error "EPL ErrorHandler module needs EPL module OBDK!"
81 #endif
82
83 /***************************************************************************/
84 /* */
85 /* */
86 /* G L O B A L D E F I N I T I O N S */
87 /* */
88 /* */
89 /***************************************************************************/
90
91 //---------------------------------------------------------------------------
92 // const defines
93 //---------------------------------------------------------------------------
94
95 //---------------------------------------------------------------------------
96 // local types
97 //---------------------------------------------------------------------------
98
99 typedef struct {
100 DWORD m_dwCumulativeCnt; // subindex 1
101 DWORD m_dwThresholdCnt; // subindex 2
102 DWORD m_dwThreshold; // subindex 3
103
104 } tEplErrorHandlerkErrorCounter;
105
106 typedef struct {
107 tEplErrorHandlerkErrorCounter m_CnLossSoc; // object 0x1C0B
108 tEplErrorHandlerkErrorCounter m_CnLossPreq; // object 0x1C0D
109 tEplErrorHandlerkErrorCounter m_CnCrcErr; // object 0x1C0F
110 unsigned long m_ulDllErrorEvents;
111
112 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
113 tEplErrorHandlerkErrorCounter m_MnCrcErr; // object 0x1C00
114 tEplErrorHandlerkErrorCounter m_MnCycTimeExceed; // object 0x1C02
115 DWORD m_adwMnCnLossPresCumCnt[254]; // object 0x1C07
116 DWORD m_adwMnCnLossPresThrCnt[254]; // object 0x1C08
117 DWORD m_adwMnCnLossPresThreshold[254]; // object 0x1C09
118 BOOL m_afMnCnLossPresEvent[254];
119 #endif
120
121 } tEplErrorHandlerkInstance;
122
123 //---------------------------------------------------------------------------
124 // modul globale vars
125 //---------------------------------------------------------------------------
126
127 static tEplErrorHandlerkInstance EplErrorHandlerkInstance_g;
128
129 //---------------------------------------------------------------------------
130 // local function prototypes
131 //---------------------------------------------------------------------------
132
133 static tEplKernel EplErrorHandlerkLinkErrorCounter(tEplErrorHandlerkErrorCounter
134 * pErrorCounter_p,
135 unsigned int uiIndex_p);
136
137 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
138 static tEplKernel EplErrorHandlerkLinkArray(DWORD * pdwValue_p,
139 unsigned int uiValueCount_p,
140 unsigned int uiIndex_p);
141 #endif
142
143 /***************************************************************************/
144 /* */
145 /* */
146 /* C L A S S <Epl-Kernelspace-Error-Handler> */
147 /* */
148 /* */
149 /***************************************************************************/
150 //
151 // Description:
152 //
153 //
154 /***************************************************************************/
155
156 //=========================================================================//
157 // //
158 // P U B L I C F U N C T I O N S //
159 // //
160 //=========================================================================//
161
162 //---------------------------------------------------------------------------
163 //
164 // Function: EplErrorHandlerkInit
165 //
166 // Description: function initialize the first instance
167 //
168 //
169 //
170 // Parameters:
171 //
172 //
173 // Returns: tEpKernel = errorcode
174 //
175 //
176 // State:
177 //
178 //---------------------------------------------------------------------------
EplErrorHandlerkInit(void)179 tEplKernel PUBLIC EplErrorHandlerkInit(void)
180 {
181 tEplKernel Ret;
182
183 Ret = EplErrorHandlerkAddInstance();
184
185 return Ret;
186
187 }
188
189 //---------------------------------------------------------------------------
190 //
191 // Function: EplErrorHandlerkAddInstance
192 //
193 // Description: function add one more instance
194 //
195 //
196 //
197 // Parameters:
198 //
199 //
200 // Returns: tEpKernel = errorcode
201 //
202 //
203 // State:
204 //
205 //---------------------------------------------------------------------------
EplErrorHandlerkAddInstance(void)206 tEplKernel PUBLIC EplErrorHandlerkAddInstance(void)
207 {
208 tEplKernel Ret;
209
210 Ret = kEplSuccessful;
211
212 // reset only event variable,
213 // all other instance members are reset by OD or may keep their current value
214 // d.k.: this is necessary for the cumulative counters, which shall not be reset
215 EplErrorHandlerkInstance_g.m_ulDllErrorEvents = 0;
216
217 // link counters to OD
218 // $$$ d.k. if OD resides in userspace, fetch pointer to shared memory,
219 // which shall have the same structure as the instance (needs to be declared globally).
220 // Other idea: error counter shall belong to the process image
221 // (reset of counters by SDO write are a little bit tricky).
222
223 Ret =
224 EplErrorHandlerkLinkErrorCounter(&EplErrorHandlerkInstance_g.
225 m_CnLossSoc, 0x1C0B);
226 if (Ret != kEplSuccessful) {
227 goto Exit;
228 }
229
230 Ret =
231 EplErrorHandlerkLinkErrorCounter(&EplErrorHandlerkInstance_g.
232 m_CnLossPreq, 0x1C0D);
233 // ignore return code, because object 0x1C0D is conditional
234
235 Ret =
236 EplErrorHandlerkLinkErrorCounter(&EplErrorHandlerkInstance_g.
237 m_CnCrcErr, 0x1C0F);
238 if (Ret != kEplSuccessful) {
239 goto Exit;
240 }
241 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
242 Ret =
243 EplErrorHandlerkLinkErrorCounter(&EplErrorHandlerkInstance_g.
244 m_MnCrcErr, 0x1C00);
245 if (Ret != kEplSuccessful) {
246 goto Exit;
247 }
248
249 Ret =
250 EplErrorHandlerkLinkErrorCounter(&EplErrorHandlerkInstance_g.
251 m_MnCycTimeExceed, 0x1C02);
252 if (Ret != kEplSuccessful) {
253 goto Exit;
254 }
255
256 Ret =
257 EplErrorHandlerkLinkArray(EplErrorHandlerkInstance_g.
258 m_adwMnCnLossPresCumCnt,
259 tabentries(EplErrorHandlerkInstance_g.
260 m_adwMnCnLossPresCumCnt),
261 0x1C07);
262 if (Ret != kEplSuccessful) {
263 goto Exit;
264 }
265
266 Ret =
267 EplErrorHandlerkLinkArray(EplErrorHandlerkInstance_g.
268 m_adwMnCnLossPresThrCnt,
269 tabentries(EplErrorHandlerkInstance_g.
270 m_adwMnCnLossPresThrCnt),
271 0x1C08);
272 if (Ret != kEplSuccessful) {
273 goto Exit;
274 }
275
276 Ret =
277 EplErrorHandlerkLinkArray(EplErrorHandlerkInstance_g.
278 m_adwMnCnLossPresThreshold,
279 tabentries(EplErrorHandlerkInstance_g.
280 m_adwMnCnLossPresThreshold),
281 0x1C09);
282 if (Ret != kEplSuccessful) {
283 goto Exit;
284 }
285 #endif
286
287 Exit:
288 return Ret;
289
290 }
291
292 //---------------------------------------------------------------------------
293 //
294 // Function: EplErrorHandlerkDelInstance
295 //
296 // Description: function delete instance an free the bufferstructure
297 //
298 //
299 //
300 // Parameters:
301 //
302 //
303 // Returns: tEpKernel = errorcode
304 //
305 //
306 // State:
307 //
308 //---------------------------------------------------------------------------
EplErrorHandlerkDelInstance()309 tEplKernel PUBLIC EplErrorHandlerkDelInstance()
310 {
311 tEplKernel Ret;
312
313 Ret = kEplSuccessful;
314
315 return Ret;
316
317 }
318
319 //---------------------------------------------------------------------------
320 //
321 // Function: EplErrorHandlerkProcess
322 //
323 // Description: processes error events from DLL
324 //
325 //
326 //
327 // Parameters: pEvent_p = pointer to event-structur from buffer
328 //
329 //
330 // Returns: tEpKernel = errorcode
331 //
332 //
333 // State:
334 //
335 //---------------------------------------------------------------------------
EplErrorHandlerkProcess(tEplEvent * pEvent_p)336 tEplKernel PUBLIC EplErrorHandlerkProcess(tEplEvent * pEvent_p)
337 {
338 tEplKernel Ret;
339 unsigned long ulDllErrorEvents;
340 tEplEvent Event;
341 tEplNmtEvent NmtEvent;
342
343 Ret = kEplSuccessful;
344
345 // check m_EventType
346 switch (pEvent_p->m_EventType) {
347 case kEplEventTypeDllError:
348 {
349 tEplErrorHandlerkEvent *pErrHandlerEvent =
350 (tEplErrorHandlerkEvent *) pEvent_p->m_pArg;
351
352 ulDllErrorEvents = pErrHandlerEvent->m_ulDllErrorEvents;
353
354 // check the several error events
355 if ((EplErrorHandlerkInstance_g.m_CnLossSoc.
356 m_dwThreshold > 0)
357 && ((ulDllErrorEvents & EPL_DLL_ERR_CN_LOSS_SOC) != 0)) { // loss of SoC event occured
358 // increment cumulative counter by 1
359 EplErrorHandlerkInstance_g.m_CnLossSoc.
360 m_dwCumulativeCnt++;
361 // increment threshold counter by 8
362 EplErrorHandlerkInstance_g.m_CnLossSoc.
363 m_dwThresholdCnt += 8;
364 if (EplErrorHandlerkInstance_g.m_CnLossSoc.m_dwThresholdCnt >= EplErrorHandlerkInstance_g.m_CnLossSoc.m_dwThreshold) { // threshold is reached
365 // $$$ d.k.: generate error history entry E_DLL_LOSS_SOC_TH
366
367 // post event to NMT state machine
368 NmtEvent = kEplNmtEventNmtCycleError;
369 Event.m_EventSink = kEplEventSinkNmtk;
370 Event.m_EventType =
371 kEplEventTypeNmtEvent;
372 Event.m_pArg = &NmtEvent;
373 Event.m_uiSize = sizeof(NmtEvent);
374 Ret = EplEventkPost(&Event);
375 }
376 EplErrorHandlerkInstance_g.m_ulDllErrorEvents |=
377 EPL_DLL_ERR_CN_LOSS_SOC;
378 }
379
380 if ((EplErrorHandlerkInstance_g.m_CnLossPreq.
381 m_dwThreshold > 0)
382 && ((ulDllErrorEvents & EPL_DLL_ERR_CN_LOSS_PREQ) != 0)) { // loss of PReq event occured
383 // increment cumulative counter by 1
384 EplErrorHandlerkInstance_g.m_CnLossPreq.
385 m_dwCumulativeCnt++;
386 // increment threshold counter by 8
387 EplErrorHandlerkInstance_g.m_CnLossPreq.
388 m_dwThresholdCnt += 8;
389 if (EplErrorHandlerkInstance_g.m_CnLossPreq.m_dwThresholdCnt >= EplErrorHandlerkInstance_g.m_CnLossPreq.m_dwThreshold) { // threshold is reached
390 // $$$ d.k.: generate error history entry E_DLL_LOSS_PREQ_TH
391
392 // post event to NMT state machine
393 NmtEvent = kEplNmtEventNmtCycleError;
394 Event.m_EventSink = kEplEventSinkNmtk;
395 Event.m_EventType =
396 kEplEventTypeNmtEvent;
397 Event.m_pArg = &NmtEvent;
398 Event.m_uiSize = sizeof(NmtEvent);
399 Ret = EplEventkPost(&Event);
400 }
401 }
402
403 if ((EplErrorHandlerkInstance_g.m_CnLossPreq.
404 m_dwThresholdCnt > 0)
405 && ((ulDllErrorEvents & EPL_DLL_ERR_CN_RECVD_PREQ) != 0)) { // PReq correctly received
406 // decrement threshold counter by 1
407 EplErrorHandlerkInstance_g.m_CnLossPreq.
408 m_dwThresholdCnt--;
409 }
410
411 if ((EplErrorHandlerkInstance_g.m_CnCrcErr.
412 m_dwThreshold > 0)
413 && ((ulDllErrorEvents & EPL_DLL_ERR_CN_CRC) != 0)) { // CRC error event occured
414 // increment cumulative counter by 1
415 EplErrorHandlerkInstance_g.m_CnCrcErr.
416 m_dwCumulativeCnt++;
417 // increment threshold counter by 8
418 EplErrorHandlerkInstance_g.m_CnCrcErr.
419 m_dwThresholdCnt += 8;
420 if (EplErrorHandlerkInstance_g.m_CnCrcErr.m_dwThresholdCnt >= EplErrorHandlerkInstance_g.m_CnCrcErr.m_dwThreshold) { // threshold is reached
421 // $$$ d.k.: generate error history entry E_DLL_CRC_TH
422
423 // post event to NMT state machine
424 NmtEvent = kEplNmtEventNmtCycleError;
425 Event.m_EventSink = kEplEventSinkNmtk;
426 Event.m_EventType =
427 kEplEventTypeNmtEvent;
428 Event.m_pArg = &NmtEvent;
429 Event.m_uiSize = sizeof(NmtEvent);
430 Ret = EplEventkPost(&Event);
431 }
432 EplErrorHandlerkInstance_g.m_ulDllErrorEvents |=
433 EPL_DLL_ERR_CN_CRC;
434 }
435
436 if ((ulDllErrorEvents & EPL_DLL_ERR_INVALID_FORMAT) != 0) { // invalid format error occured (only direct reaction)
437 // $$$ d.k.: generate error history entry E_DLL_INVALID_FORMAT
438 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
439 if (pErrHandlerEvent->m_NmtState >= kEplNmtMsNotActive) { // MN is active
440 if (pErrHandlerEvent->m_uiNodeId != 0) {
441 tEplHeartbeatEvent
442 HeartbeatEvent;
443
444 // remove node from isochronous phase
445 Ret =
446 EplDllkDeleteNode
447 (pErrHandlerEvent->
448 m_uiNodeId);
449
450 // inform NmtMnu module about state change, which shall send NMT command ResetNode to this CN
451 HeartbeatEvent.m_uiNodeId =
452 pErrHandlerEvent->
453 m_uiNodeId;
454 HeartbeatEvent.m_NmtState =
455 kEplNmtCsNotActive;
456 HeartbeatEvent.m_wErrorCode =
457 EPL_E_DLL_INVALID_FORMAT;
458 Event.m_EventSink =
459 kEplEventSinkNmtMnu;
460 Event.m_EventType =
461 kEplEventTypeHeartbeat;
462 Event.m_uiSize =
463 sizeof(HeartbeatEvent);
464 Event.m_pArg = &HeartbeatEvent;
465 Ret = EplEventkPost(&Event);
466 }
467 // $$$ and else should lead to InternComError
468 } else
469 #endif
470 { // CN is active
471 // post event to NMT state machine
472 NmtEvent = kEplNmtEventInternComError;
473 Event.m_EventSink = kEplEventSinkNmtk;
474 Event.m_EventType =
475 kEplEventTypeNmtEvent;
476 Event.m_pArg = &NmtEvent;
477 Event.m_uiSize = sizeof(NmtEvent);
478 Ret = EplEventkPost(&Event);
479 }
480 }
481 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
482 if ((EplErrorHandlerkInstance_g.m_MnCrcErr.
483 m_dwThreshold > 0)
484 && ((ulDllErrorEvents & EPL_DLL_ERR_MN_CRC) != 0)) { // CRC error event occured
485 // increment cumulative counter by 1
486 EplErrorHandlerkInstance_g.m_MnCrcErr.
487 m_dwCumulativeCnt++;
488 // increment threshold counter by 8
489 EplErrorHandlerkInstance_g.m_MnCrcErr.
490 m_dwThresholdCnt += 8;
491 if (EplErrorHandlerkInstance_g.m_MnCrcErr.m_dwThresholdCnt >= EplErrorHandlerkInstance_g.m_MnCrcErr.m_dwThreshold) { // threshold is reached
492 // $$$ d.k.: generate error history entry E_DLL_CRC_TH
493
494 // post event to NMT state machine
495 NmtEvent = kEplNmtEventNmtCycleError;
496 Event.m_EventSink = kEplEventSinkNmtk;
497 Event.m_EventType =
498 kEplEventTypeNmtEvent;
499 Event.m_pArg = &NmtEvent;
500 Event.m_uiSize = sizeof(NmtEvent);
501 Ret = EplEventkPost(&Event);
502 }
503 EplErrorHandlerkInstance_g.m_ulDllErrorEvents |=
504 EPL_DLL_ERR_MN_CRC;
505 }
506
507 if ((EplErrorHandlerkInstance_g.m_MnCycTimeExceed.
508 m_dwThreshold > 0)
509 && ((ulDllErrorEvents & EPL_DLL_ERR_MN_CYCTIMEEXCEED) != 0)) { // cycle time exceeded event occured
510 // increment cumulative counter by 1
511 EplErrorHandlerkInstance_g.m_MnCycTimeExceed.
512 m_dwCumulativeCnt++;
513 // increment threshold counter by 8
514 EplErrorHandlerkInstance_g.m_MnCycTimeExceed.
515 m_dwThresholdCnt += 8;
516 if (EplErrorHandlerkInstance_g.m_MnCycTimeExceed.m_dwThresholdCnt >= EplErrorHandlerkInstance_g.m_MnCycTimeExceed.m_dwThreshold) { // threshold is reached
517 // $$$ d.k.: generate error history entry E_DLL_CYCLE_EXCEED_TH
518
519 // post event to NMT state machine
520 NmtEvent = kEplNmtEventNmtCycleError;
521 Event.m_EventSink = kEplEventSinkNmtk;
522 Event.m_EventType =
523 kEplEventTypeNmtEvent;
524 Event.m_pArg = &NmtEvent;
525 Event.m_uiSize = sizeof(NmtEvent);
526 Ret = EplEventkPost(&Event);
527 }
528 // $$$ d.k.: else generate error history entry E_DLL_CYCLE_EXCEED
529 EplErrorHandlerkInstance_g.m_ulDllErrorEvents |=
530 EPL_DLL_ERR_MN_CYCTIMEEXCEED;
531 }
532
533 if ((ulDllErrorEvents & EPL_DLL_ERR_MN_CN_LOSS_PRES) != 0) { // CN loss PRes event occured
534 unsigned int uiNodeId;
535
536 uiNodeId = pErrHandlerEvent->m_uiNodeId - 1;
537 if ((uiNodeId <
538 tabentries(EplErrorHandlerkInstance_g.
539 m_adwMnCnLossPresCumCnt))
540 && (EplErrorHandlerkInstance_g.
541 m_adwMnCnLossPresThreshold[uiNodeId] >
542 0)) {
543 // increment cumulative counter by 1
544 EplErrorHandlerkInstance_g.
545 m_adwMnCnLossPresCumCnt[uiNodeId]++;
546 // increment threshold counter by 8
547 EplErrorHandlerkInstance_g.
548 m_adwMnCnLossPresThrCnt[uiNodeId] +=
549 8;
550 if (EplErrorHandlerkInstance_g.
551 m_adwMnCnLossPresThrCnt[uiNodeId]
552 >= EplErrorHandlerkInstance_g.m_adwMnCnLossPresThreshold[uiNodeId]) { // threshold is reached
553 tEplHeartbeatEvent
554 HeartbeatEvent;
555
556 // $$$ d.k.: generate error history entry E_DLL_LOSS_PRES_TH
557
558 // remove node from isochronous phase
559 Ret =
560 EplDllkDeleteNode
561 (pErrHandlerEvent->
562 m_uiNodeId);
563
564 // inform NmtMnu module about state change, which shall send NMT command ResetNode to this CN
565 HeartbeatEvent.m_uiNodeId =
566 pErrHandlerEvent->
567 m_uiNodeId;
568 HeartbeatEvent.m_NmtState =
569 kEplNmtCsNotActive;
570 HeartbeatEvent.m_wErrorCode =
571 EPL_E_DLL_LOSS_PRES_TH;
572 Event.m_EventSink =
573 kEplEventSinkNmtMnu;
574 Event.m_EventType =
575 kEplEventTypeHeartbeat;
576 Event.m_uiSize =
577 sizeof(HeartbeatEvent);
578 Event.m_pArg = &HeartbeatEvent;
579 Ret = EplEventkPost(&Event);
580 }
581 EplErrorHandlerkInstance_g.
582 m_afMnCnLossPresEvent[uiNodeId] =
583 TRUE;
584 }
585 }
586 #endif
587
588 break;
589 }
590
591 // NMT event
592 case kEplEventTypeNmtEvent:
593 {
594 if ((*(tEplNmtEvent *) pEvent_p->m_pArg) == kEplNmtEventDllCeSoa) { // SoA event of CN -> decrement threshold counters
595
596 if ((EplErrorHandlerkInstance_g.m_ulDllErrorEvents & EPL_DLL_ERR_CN_LOSS_SOC) == 0) { // decrement loss of SoC threshold counter, because it didn't occur last cycle
597 if (EplErrorHandlerkInstance_g.
598 m_CnLossSoc.m_dwThresholdCnt > 0) {
599 EplErrorHandlerkInstance_g.
600 m_CnLossSoc.
601 m_dwThresholdCnt--;
602 }
603 }
604
605 if ((EplErrorHandlerkInstance_g.m_ulDllErrorEvents & EPL_DLL_ERR_CN_CRC) == 0) { // decrement CRC threshold counter, because it didn't occur last cycle
606 if (EplErrorHandlerkInstance_g.
607 m_CnCrcErr.m_dwThresholdCnt > 0) {
608 EplErrorHandlerkInstance_g.
609 m_CnCrcErr.
610 m_dwThresholdCnt--;
611 }
612 }
613 }
614 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
615 else if ((*(tEplNmtEvent *) pEvent_p->m_pArg) == kEplNmtEventDllMeSoaSent) { // SoA event of MN -> decrement threshold counters
616 tEplDllkNodeInfo *pIntNodeInfo;
617 unsigned int uiNodeId;
618
619 Ret = EplDllkGetFirstNodeInfo(&pIntNodeInfo);
620 if (Ret != kEplSuccessful) {
621 break;
622 }
623 // iterate through node info structure list
624 while (pIntNodeInfo != NULL) {
625 uiNodeId = pIntNodeInfo->m_uiNodeId - 1;
626 if (uiNodeId <
627 tabentries
628 (EplErrorHandlerkInstance_g.
629 m_adwMnCnLossPresCumCnt)) {
630 if (EplErrorHandlerkInstance_g.
631 m_afMnCnLossPresEvent
632 [uiNodeId] == FALSE) {
633 if (EplErrorHandlerkInstance_g.m_adwMnCnLossPresThrCnt[uiNodeId] > 0) {
634 EplErrorHandlerkInstance_g.
635 m_adwMnCnLossPresThrCnt
636 [uiNodeId]--;
637 }
638 } else {
639 EplErrorHandlerkInstance_g.
640 m_afMnCnLossPresEvent
641 [uiNodeId] = FALSE;
642 }
643 }
644 pIntNodeInfo =
645 pIntNodeInfo->m_pNextNodeInfo;
646 }
647
648 if ((EplErrorHandlerkInstance_g.m_ulDllErrorEvents & EPL_DLL_ERR_MN_CRC) == 0) { // decrement CRC threshold counter, because it didn't occur last cycle
649 if (EplErrorHandlerkInstance_g.
650 m_MnCrcErr.m_dwThresholdCnt > 0) {
651 EplErrorHandlerkInstance_g.
652 m_MnCrcErr.
653 m_dwThresholdCnt--;
654 }
655 }
656
657 if ((EplErrorHandlerkInstance_g.m_ulDllErrorEvents & EPL_DLL_ERR_MN_CYCTIMEEXCEED) == 0) { // decrement cycle exceed threshold counter, because it didn't occur last cycle
658 if (EplErrorHandlerkInstance_g.
659 m_MnCycTimeExceed.m_dwThresholdCnt >
660 0) {
661 EplErrorHandlerkInstance_g.
662 m_MnCycTimeExceed.
663 m_dwThresholdCnt--;
664 }
665 }
666 }
667 #endif
668
669 // reset error events
670 EplErrorHandlerkInstance_g.m_ulDllErrorEvents = 0L;
671
672 break;
673 }
674
675 // unknown type
676 default:
677 {
678 }
679
680 } // end of switch(pEvent_p->m_EventType)
681
682 return Ret;
683
684 }
685
686 //=========================================================================//
687 // //
688 // P R I V A T E F U N C T I O N S //
689 // //
690 //=========================================================================//
691
692 //---------------------------------------------------------------------------
693 //
694 // Function: EplErrorHandlerkLinkErrorCounter
695 //
696 // Description: link specified error counter structure to OD entry
697 //
698 // Parameters: pErrorCounter_p = pointer to error counter structure
699 // uiIndex_p = OD index
700 //
701 // Returns: tEplKernel = error code
702 //
703 //
704 // State:
705 //
706 //---------------------------------------------------------------------------
707
EplErrorHandlerkLinkErrorCounter(tEplErrorHandlerkErrorCounter * pErrorCounter_p,unsigned int uiIndex_p)708 static tEplKernel EplErrorHandlerkLinkErrorCounter(tEplErrorHandlerkErrorCounter
709 * pErrorCounter_p,
710 unsigned int uiIndex_p)
711 {
712 tEplKernel Ret = kEplSuccessful;
713 tEplVarParam VarParam;
714
715 VarParam.m_pData = &pErrorCounter_p->m_dwCumulativeCnt;
716 VarParam.m_Size = sizeof(DWORD);
717 VarParam.m_uiIndex = uiIndex_p;
718 VarParam.m_uiSubindex = 0x01;
719 VarParam.m_ValidFlag = kVarValidAll;
720 Ret = EplObdDefineVar(&VarParam);
721 if (Ret != kEplSuccessful) {
722 goto Exit;
723 }
724
725 VarParam.m_pData = &pErrorCounter_p->m_dwThresholdCnt;
726 VarParam.m_Size = sizeof(DWORD);
727 VarParam.m_uiIndex = uiIndex_p;
728 VarParam.m_uiSubindex = 0x02;
729 VarParam.m_ValidFlag = kVarValidAll;
730 Ret = EplObdDefineVar(&VarParam);
731 if (Ret != kEplSuccessful) {
732 goto Exit;
733 }
734
735 VarParam.m_pData = &pErrorCounter_p->m_dwThreshold;
736 VarParam.m_Size = sizeof(DWORD);
737 VarParam.m_uiIndex = uiIndex_p;
738 VarParam.m_uiSubindex = 0x03;
739 VarParam.m_ValidFlag = kVarValidAll;
740 Ret = EplObdDefineVar(&VarParam);
741 if (Ret != kEplSuccessful) {
742 goto Exit;
743 }
744
745 Exit:
746 return Ret;
747 }
748
749 //---------------------------------------------------------------------------
750 //
751 // Function: EplErrorHandlerkLinkErrorCounter
752 //
753 // Description: link specified error counter structure to OD entry
754 //
755 // Parameters: pErrorCounter_p = pointer to error counter structure
756 // uiIndex_p = OD index
757 //
758 // Returns: tEplKernel = error code
759 //
760 //
761 // State:
762 //
763 //---------------------------------------------------------------------------
764
765 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
EplErrorHandlerkLinkArray(DWORD * pdwValue_p,unsigned int uiValueCount_p,unsigned int uiIndex_p)766 static tEplKernel EplErrorHandlerkLinkArray(DWORD * pdwValue_p,
767 unsigned int uiValueCount_p,
768 unsigned int uiIndex_p)
769 {
770 tEplKernel Ret = kEplSuccessful;
771 tEplVarParam VarParam;
772 tEplObdSize EntrySize;
773 BYTE bIndexEntries;
774
775 EntrySize = (tEplObdSize) sizeof(bIndexEntries);
776 Ret = EplObdReadEntry(uiIndex_p,
777 0x00, (void GENERIC *)&bIndexEntries, &EntrySize);
778
779 if ((Ret != kEplSuccessful) || (bIndexEntries == 0x00)) {
780 // Object doesn't exist or invalid entry number
781 Ret = kEplObdIndexNotExist;
782 goto Exit;
783 }
784
785 if (bIndexEntries < uiValueCount_p) {
786 uiValueCount_p = bIndexEntries;
787 }
788
789 VarParam.m_Size = sizeof(DWORD);
790 VarParam.m_uiIndex = uiIndex_p;
791 VarParam.m_ValidFlag = kVarValidAll;
792
793 for (VarParam.m_uiSubindex = 0x01;
794 VarParam.m_uiSubindex <= uiValueCount_p; VarParam.m_uiSubindex++) {
795 VarParam.m_pData = pdwValue_p;
796 Ret = EplObdDefineVar(&VarParam);
797 if (Ret != kEplSuccessful) {
798 goto Exit;
799 }
800 pdwValue_p++;
801 }
802
803 Exit:
804 return Ret;
805 }
806 #endif //(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
807
808 #endif //(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_DLLK)) != 0)
809
810 // EOF
811