?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
added 2.6.29.6 aldebaran kernel
[nao-ulib.git] / kernel / 2.6.29.6-aldebaran-rt / drivers / staging / epl / EplNmtMnu.c
blob4ed0b6ce487c8820e8064d5a9a9c360bb509625f
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 NMT-MN-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: EplNmtMnu.c,v $
53
54 $Author: D.Krueger $
55
56 $Revision: 1.18 $ $Date: 2008/11/19 09:52:24 $
57
58 $State: Exp $
59
60 Build Environment:
61 GCC V3.4
62
63 -------------------------------------------------------------------------
64
65 Revision History:
66
67 2006/06/09 k.t.: start of the implementation
68
69 ****************************************************************************/
70
71 #include "user/EplNmtMnu.h"
72 #include "user/EplTimeru.h"
73 #include "user/EplIdentu.h"
74 #include "user/EplStatusu.h"
75 #include "user/EplObdu.h"
76 #include "user/EplDlluCal.h"
77 #include "Benchmark.h"
78
79 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
80
81 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDU)) == 0) && (EPL_OBD_USE_KERNEL == FALSE)
82 #error "EPL NmtMnu module needs EPL module OBDU or OBDK!"
83 #endif
84
85 //=========================================================================//
86 // //
87 // P R I V A T E D E F I N I T I O N S //
88 // //
89 //=========================================================================//
90
91 //---------------------------------------------------------------------------
92 // const defines
93 //---------------------------------------------------------------------------
94
95 // TracePoint support for realtime-debugging
96 #ifdef _DBG_TRACE_POINTS_
97 void PUBLIC TgtDbgSignalTracePoint(BYTE bTracePointNumber_p);
98 void PUBLIC TgtDbgPostTraceValue(DWORD dwTraceValue_p);
99 #define TGT_DBG_SIGNAL_TRACE_POINT(p) TgtDbgSignalTracePoint(p)
100 #define TGT_DBG_POST_TRACE_VALUE(v) TgtDbgPostTraceValue(v)
101 #else
102 #define TGT_DBG_SIGNAL_TRACE_POINT(p)
103 #define TGT_DBG_POST_TRACE_VALUE(v)
104 #endif
105 #define EPL_NMTMNU_DBG_POST_TRACE_VALUE(Event_p, uiNodeId_p, wErrorCode_p) \
106 TGT_DBG_POST_TRACE_VALUE((kEplEventSinkNmtMnu << 28) | (Event_p << 24) \
107 | (uiNodeId_p << 16) | wErrorCode_p)
108
109 // defines for flags in node info structure
110 #define EPL_NMTMNU_NODE_FLAG_ISOCHRON 0x0001 // CN is being accessed isochronously
111 #define EPL_NMTMNU_NODE_FLAG_NOT_SCANNED 0x0002 // CN was not scanned once -> decrement SignalCounter and reset flag
112 #define EPL_NMTMNU_NODE_FLAG_HALTED 0x0004 // boot process for this CN is halted
113 #define EPL_NMTMNU_NODE_FLAG_NMT_CMD_ISSUED 0x0008 // NMT command was just issued, wrong NMT states will be tolerated
114 #define EPL_NMTMNU_NODE_FLAG_COUNT_STATREQ 0x0300 // counter for StatusRequest timer handle
115 #define EPL_NMTMNU_NODE_FLAG_COUNT_LONGER 0x0C00 // counter for longer timeouts timer handle
116 #define EPL_NMTMNU_NODE_FLAG_INC_STATREQ 0x0100 // increment for StatusRequest timer handle
117 #define EPL_NMTMNU_NODE_FLAG_INC_LONGER 0x0400 // increment for longer timeouts timer handle
118 // These counters will be incremented at every timer start
119 // and copied to timerarg. When the timer event occures
120 // both will be compared and if unequal the timer event
121 // will be discarded, because it is an old one.
122
123 // defines for timer arguments to draw a distinction between serveral events
124 #define EPL_NMTMNU_TIMERARG_NODE_MASK 0x000000FFL // mask that contains the node-ID
125 #define EPL_NMTMNU_TIMERARG_IDENTREQ 0x00010000L // timer event is for IdentRequest
126 #define EPL_NMTMNU_TIMERARG_STATREQ 0x00020000L // timer event is for StatusRequest
127 #define EPL_NMTMNU_TIMERARG_LONGER 0x00040000L // timer event is for longer timeouts
128 #define EPL_NMTMNU_TIMERARG_STATE_MON 0x00080000L // timer event for StatusRequest to monitor execution of NMT state changes
129 #define EPL_NMTMNU_TIMERARG_COUNT_SR 0x00000300L // counter for StatusRequest
130 #define EPL_NMTMNU_TIMERARG_COUNT_LO 0x00000C00L // counter for longer timeouts
131 // The counters must have the same position as in the node flags above.
132
133 #define EPL_NMTMNU_SET_FLAGS_TIMERARG_STATREQ(pNodeInfo_p, uiNodeId_p, TimerArg_p) \
134 pNodeInfo_p->m_wFlags = \
135 ((pNodeInfo_p->m_wFlags + EPL_NMTMNU_NODE_FLAG_INC_STATREQ) \
136 & EPL_NMTMNU_NODE_FLAG_COUNT_STATREQ) \
137 | (pNodeInfo_p->m_wFlags & ~EPL_NMTMNU_NODE_FLAG_COUNT_STATREQ); \
138 TimerArg_p.m_ulArg = EPL_NMTMNU_TIMERARG_STATREQ | uiNodeId_p | \
139 (pNodeInfo_p->m_wFlags & EPL_NMTMNU_NODE_FLAG_COUNT_STATREQ); \
140 TimerArg_p.m_EventSink = kEplEventSinkNmtMnu;
141
142 #define EPL_NMTMNU_SET_FLAGS_TIMERARG_IDENTREQ(pNodeInfo_p, uiNodeId_p, TimerArg_p) \
143 pNodeInfo_p->m_wFlags = \
144 ((pNodeInfo_p->m_wFlags + EPL_NMTMNU_NODE_FLAG_INC_STATREQ) \
145 & EPL_NMTMNU_NODE_FLAG_COUNT_STATREQ) \
146 | (pNodeInfo_p->m_wFlags & ~EPL_NMTMNU_NODE_FLAG_COUNT_STATREQ); \
147 TimerArg_p.m_ulArg = EPL_NMTMNU_TIMERARG_IDENTREQ | uiNodeId_p | \
148 (pNodeInfo_p->m_wFlags & EPL_NMTMNU_NODE_FLAG_COUNT_STATREQ); \
149 TimerArg_p.m_EventSink = kEplEventSinkNmtMnu;
150
151 #define EPL_NMTMNU_SET_FLAGS_TIMERARG_LONGER(pNodeInfo_p, uiNodeId_p, TimerArg_p) \
152 pNodeInfo_p->m_wFlags = \
153 ((pNodeInfo_p->m_wFlags + EPL_NMTMNU_NODE_FLAG_INC_LONGER) \
154 & EPL_NMTMNU_NODE_FLAG_COUNT_LONGER) \
155 | (pNodeInfo_p->m_wFlags & ~EPL_NMTMNU_NODE_FLAG_COUNT_LONGER); \
156 TimerArg_p.m_ulArg = EPL_NMTMNU_TIMERARG_LONGER | uiNodeId_p | \
157 (pNodeInfo_p->m_wFlags & EPL_NMTMNU_NODE_FLAG_COUNT_LONGER); \
158 TimerArg_p.m_EventSink = kEplEventSinkNmtMnu;
159
160 #define EPL_NMTMNU_SET_FLAGS_TIMERARG_STATE_MON(pNodeInfo_p, uiNodeId_p, TimerArg_p) \
161 pNodeInfo_p->m_wFlags = \
162 ((pNodeInfo_p->m_wFlags + EPL_NMTMNU_NODE_FLAG_INC_STATREQ) \
163 & EPL_NMTMNU_NODE_FLAG_COUNT_STATREQ) \
164 | (pNodeInfo_p->m_wFlags & ~EPL_NMTMNU_NODE_FLAG_COUNT_STATREQ); \
165 TimerArg_p.m_ulArg = EPL_NMTMNU_TIMERARG_STATE_MON | uiNodeId_p | \
166 (pNodeInfo_p->m_wFlags & EPL_NMTMNU_NODE_FLAG_COUNT_STATREQ); \
167 TimerArg_p.m_EventSink = kEplEventSinkNmtMnu;
168
169 // defines for global flags
170 #define EPL_NMTMNU_FLAG_HALTED 0x0001 // boot process is halted
171 #define EPL_NMTMNU_FLAG_APP_INFORMED 0x0002 // application was informed about possible NMT state change
172
173 // return pointer to node info structure for specified node ID
174 // d.k. may be replaced by special (hash) function if node ID array is smaller than 254
175 #define EPL_NMTMNU_GET_NODEINFO(uiNodeId_p) (&EplNmtMnuInstance_g.m_aNodeInfo[uiNodeId_p - 1])
176
177 //---------------------------------------------------------------------------
178 // local types
179 //---------------------------------------------------------------------------
180
181 typedef enum {
182 kEplNmtMnuIntNodeEventNoIdentResponse = 0x00,
183 kEplNmtMnuIntNodeEventIdentResponse = 0x01,
184 kEplNmtMnuIntNodeEventBoot = 0x02,
185 kEplNmtMnuIntNodeEventExecReset = 0x03,
186 kEplNmtMnuIntNodeEventConfigured = 0x04,
187 kEplNmtMnuIntNodeEventNoStatusResponse = 0x05,
188 kEplNmtMnuIntNodeEventStatusResponse = 0x06,
189 kEplNmtMnuIntNodeEventHeartbeat = 0x07,
190 kEplNmtMnuIntNodeEventNmtCmdSent = 0x08,
191 kEplNmtMnuIntNodeEventTimerIdentReq = 0x09,
192 kEplNmtMnuIntNodeEventTimerStatReq = 0x0A,
193 kEplNmtMnuIntNodeEventTimerStateMon = 0x0B,
194 kEplNmtMnuIntNodeEventTimerLonger = 0x0C,
195 kEplNmtMnuIntNodeEventError = 0x0D,
196
197 } tEplNmtMnuIntNodeEvent;
198
199 typedef enum {
200 kEplNmtMnuNodeStateUnknown = 0x00,
201 kEplNmtMnuNodeStateIdentified = 0x01,
202 kEplNmtMnuNodeStateResetConf = 0x02, // CN reset after configuration update
203 kEplNmtMnuNodeStateConfigured = 0x03, // BootStep1 completed
204 kEplNmtMnuNodeStateReadyToOp = 0x04, // BootStep2 completed
205 kEplNmtMnuNodeStateComChecked = 0x05, // Communication checked successfully
206 kEplNmtMnuNodeStateOperational = 0x06, // CN is in NMT state OPERATIONAL
207
208 } tEplNmtMnuNodeState;
209
210 typedef struct {
211 tEplTimerHdl m_TimerHdlStatReq; // timer to delay StatusRequests and IdentRequests
212 tEplTimerHdl m_TimerHdlLonger; // 2nd timer for NMT command EnableReadyToOp and CheckCommunication
213 tEplNmtMnuNodeState m_NodeState; // internal node state (kind of sub state of NMT state)
214 DWORD m_dwNodeCfg; // subindex from 0x1F81
215 WORD m_wFlags; // flags: CN is being accessed isochronously
216
217 } tEplNmtMnuNodeInfo;
218
219 typedef struct {
220 tEplNmtMnuNodeInfo m_aNodeInfo[EPL_NMT_MAX_NODE_ID];
221 tEplTimerHdl m_TimerHdlNmtState; // timeout for stay in NMT state
222 unsigned int m_uiMandatorySlaveCount;
223 unsigned int m_uiSignalSlaveCount;
224 unsigned long m_ulStatusRequestDelay; // in [ms] (object 0x1006 * EPL_C_NMT_STATREQ_CYCLE)
225 unsigned long m_ulTimeoutReadyToOp; // in [ms] (object 0x1F89/5)
226 unsigned long m_ulTimeoutCheckCom; // in [ms] (object 0x1006 * MultiplexedCycleCount)
227 WORD m_wFlags; // global flags
228 DWORD m_dwNmtStartup; // object 0x1F80 NMT_StartUp_U32
229 tEplNmtMnuCbNodeEvent m_pfnCbNodeEvent;
230 tEplNmtMnuCbBootEvent m_pfnCbBootEvent;
231
232 } tEplNmtMnuInstance;
233
234 //---------------------------------------------------------------------------
235 // local vars
236 //---------------------------------------------------------------------------
237
238 static tEplNmtMnuInstance EplNmtMnuInstance_g;
239
240 //---------------------------------------------------------------------------
241 // local function prototypes
242 //---------------------------------------------------------------------------
243
244 static tEplKernel PUBLIC EplNmtMnuCbNmtRequest(tEplFrameInfo * pFrameInfo_p);
245
246 static tEplKernel PUBLIC EplNmtMnuCbIdentResponse(unsigned int uiNodeId_p,
247 tEplIdentResponse *
248 pIdentResponse_p);
249
250 static tEplKernel PUBLIC EplNmtMnuCbStatusResponse(unsigned int uiNodeId_p,
251 tEplStatusResponse *
252 pStatusResponse_p);
253
254 static tEplKernel EplNmtMnuCheckNmtState(unsigned int uiNodeId_p,
255 tEplNmtMnuNodeInfo * pNodeInfo_p,
256 tEplNmtState NodeNmtState_p,
257 WORD wErrorCode_p,
258 tEplNmtState LocalNmtState_p);
259
260 static tEplKernel EplNmtMnuStartBootStep1(void);
261
262 static tEplKernel EplNmtMnuStartBootStep2(void);
263
264 static tEplKernel EplNmtMnuStartCheckCom(void);
265
266 static tEplKernel EplNmtMnuNodeBootStep2(unsigned int uiNodeId_p,
267 tEplNmtMnuNodeInfo * pNodeInfo_p);
268
269 static tEplKernel EplNmtMnuNodeCheckCom(unsigned int uiNodeId_p,
270 tEplNmtMnuNodeInfo * pNodeInfo_p);
271
272 static tEplKernel EplNmtMnuStartNodes(void);
273
274 static tEplKernel EplNmtMnuProcessInternalEvent(unsigned int uiNodeId_p,
275 tEplNmtState NodeNmtState_p,
276 WORD wErrorCode_p,
277 tEplNmtMnuIntNodeEvent
278 NodeEvent_p);
279
280 static tEplKernel EplNmtMnuReset(void);
281
282 //=========================================================================//
283 // //
284 // P U B L I C F U N C T I O N S //
285 // //
286 //=========================================================================//
287
288 //---------------------------------------------------------------------------
289 //
290 // Function: EplNmtMnuInit
291 //
292 // Description: init first instance of the module
293 //
294 //
295 //
296 // Parameters:
297 //
298 //
299 // Returns: tEplKernel = errorcode
300 //
301 //
302 // State:
303 //
304 //---------------------------------------------------------------------------
305
306 tEplKernel EplNmtMnuInit(tEplNmtMnuCbNodeEvent pfnCbNodeEvent_p,
307 tEplNmtMnuCbBootEvent pfnCbBootEvent_p)
308 {
309 tEplKernel Ret;
310
311 Ret = EplNmtMnuAddInstance(pfnCbNodeEvent_p, pfnCbBootEvent_p);
312
313 return Ret;
314 }
315
316 //---------------------------------------------------------------------------
317 //
318 // Function: EplNmtMnuAddInstance
319 //
320 // Description: init other instances of the module
321 //
322 //
323 //
324 // Parameters:
325 //
326 //
327 // Returns: tEplKernel = errorcode
328 //
329 //
330 // State:
331 //
332 //---------------------------------------------------------------------------
333
334 tEplKernel EplNmtMnuAddInstance(tEplNmtMnuCbNodeEvent pfnCbNodeEvent_p,
335 tEplNmtMnuCbBootEvent pfnCbBootEvent_p)
336 {
337 tEplKernel Ret;
338
339 Ret = kEplSuccessful;
340
341 // reset instance structure
342 EPL_MEMSET(&EplNmtMnuInstance_g, 0, sizeof(EplNmtMnuInstance_g));
343
344 if ((pfnCbNodeEvent_p == NULL) || (pfnCbBootEvent_p == NULL)) {
345 Ret = kEplNmtInvalidParam;
346 goto Exit;
347 }
348 EplNmtMnuInstance_g.m_pfnCbNodeEvent = pfnCbNodeEvent_p;
349 EplNmtMnuInstance_g.m_pfnCbBootEvent = pfnCbBootEvent_p;
350
351 // initialize StatusRequest delay
352 EplNmtMnuInstance_g.m_ulStatusRequestDelay = 5000L;
353
354 // register NmtMnResponse callback function
355 Ret =
356 EplDlluCalRegAsndService(kEplDllAsndNmtRequest,
357 EplNmtMnuCbNmtRequest,
358 kEplDllAsndFilterLocal);
359
360 Exit:
361 return Ret;
362
363 }
364
365 //---------------------------------------------------------------------------
366 //
367 // Function: EplNmtMnuDelInstance
368 //
369 // Description: delete instance
370 //
371 //
372 //
373 // Parameters:
374 //
375 //
376 // Returns: tEplKernel = errorcode
377 //
378 //
379 // State:
380 //
381 //---------------------------------------------------------------------------
382
383 tEplKernel EplNmtMnuDelInstance()
384 {
385 tEplKernel Ret;
386
387 Ret = kEplSuccessful;
388
389 // deregister NmtMnResponse callback function
390 Ret =
391 EplDlluCalRegAsndService(kEplDllAsndNmtRequest, NULL,
392 kEplDllAsndFilterNone);
393
394 Ret = EplNmtMnuReset();
395
396 return Ret;
397
398 }
399
400 //---------------------------------------------------------------------------
401 //
402 // Function: EplNmtMnuSendNmtCommandEx
403 //
404 // Description: sends the specified NMT command to the specified node.
405 //
406 // Parameters: uiNodeId_p = node ID to which the NMT command will be sent
407 // NmtCommand_p = NMT command
408 //
409 // Returns: tEplKernel = error code
410 //
411 // State:
412 //
413 //---------------------------------------------------------------------------
414
415 tEplKernel EplNmtMnuSendNmtCommandEx(unsigned int uiNodeId_p,
416 tEplNmtCommand NmtCommand_p,
417 void *pNmtCommandData_p,
418 unsigned int uiDataSize_p)
419 {
420 tEplKernel Ret = kEplSuccessful;
421 tEplFrameInfo FrameInfo;
422 BYTE abBuffer[EPL_C_DLL_MINSIZE_NMTCMDEXT];
423 tEplFrame *pFrame = (tEplFrame *) abBuffer;
424 BOOL fSoftDeleteNode = FALSE;
425
426 if ((uiNodeId_p == 0) || (uiNodeId_p > EPL_C_ADR_BROADCAST)) { // invalid node ID specified
427 Ret = kEplInvalidNodeId;
428 goto Exit;
429 }
430
431 if ((pNmtCommandData_p != NULL)
432 && (uiDataSize_p >
433 (EPL_C_DLL_MINSIZE_NMTCMDEXT - EPL_C_DLL_MINSIZE_NMTCMD))) {
434 Ret = kEplNmtInvalidParam;
435 goto Exit;
436 }
437 // $$$ d.k. may be check in future versions if the caller wants to perform prohibited state transitions
438 // the CN should not perform these transitions, but the expected NMT state will be changed and never fullfilled.
439
440 // build frame
441 EPL_MEMSET(pFrame, 0x00, sizeof(abBuffer));
442 AmiSetByteToLe(&pFrame->m_le_bDstNodeId, (BYTE) uiNodeId_p);
443 AmiSetByteToLe(&pFrame->m_Data.m_Asnd.m_le_bServiceId,
444 (BYTE) kEplDllAsndNmtCommand);
445 AmiSetByteToLe(&pFrame->m_Data.m_Asnd.m_Payload.m_NmtCommandService.
446 m_le_bNmtCommandId, (BYTE) NmtCommand_p);
447 if ((pNmtCommandData_p != NULL) && (uiDataSize_p > 0)) { // copy command data to frame
448 EPL_MEMCPY(&pFrame->m_Data.m_Asnd.m_Payload.m_NmtCommandService.
449 m_le_abNmtCommandData[0], pNmtCommandData_p,
450 uiDataSize_p);
451 }
452 // build info structure
453 FrameInfo.m_NetTime.m_dwNanoSec = 0;
454 FrameInfo.m_NetTime.m_dwSec = 0;
455 FrameInfo.m_pFrame = pFrame;
456 FrameInfo.m_uiFrameSize = sizeof(abBuffer);
457
458 // send NMT-Request
459 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_DLLU)) != 0)
460 Ret = EplDlluCalAsyncSend(&FrameInfo, // pointer to frameinfo
461 kEplDllAsyncReqPrioNmt); // priority
462 #endif
463 if (Ret != kEplSuccessful) {
464 goto Exit;
465 }
466
467 EPL_DBGLVL_NMTMN_TRACE2("NMTCmd(%02X->%02X)\n", NmtCommand_p,
468 uiNodeId_p);
469
470 switch (NmtCommand_p) {
471 case kEplNmtCmdStartNode:
472 case kEplNmtCmdEnterPreOperational2:
473 case kEplNmtCmdEnableReadyToOperate:
474 {
475 // nothing left to do,
476 // because any further processing is done
477 // when the NMT command is actually sent
478 goto Exit;
479 }
480
481 case kEplNmtCmdStopNode:
482 {
483 fSoftDeleteNode = TRUE;
484 break;
485 }
486
487 case kEplNmtCmdResetNode:
488 case kEplNmtCmdResetCommunication:
489 case kEplNmtCmdResetConfiguration:
490 case kEplNmtCmdSwReset:
491 {
492 break;
493 }
494
495 default:
496 goto Exit;
497 }
498
499 // remove CN from isochronous phase;
500 // This must be done here and not when NMT command is actually sent
501 // because it will be too late and may cause unwanted errors
502 if (uiNodeId_p != EPL_C_ADR_BROADCAST) {
503 if (fSoftDeleteNode == FALSE) { // remove CN immediately from isochronous phase
504 Ret = EplDlluCalDeleteNode(uiNodeId_p);
505 } else { // remove CN from isochronous phase softly
506 Ret = EplDlluCalSoftDeleteNode(uiNodeId_p);
507 }
508 } else { // do it for all active CNs
509 for (uiNodeId_p = 1;
510 uiNodeId_p <= tabentries(EplNmtMnuInstance_g.m_aNodeInfo);
511 uiNodeId_p++) {
512 if ((EPL_NMTMNU_GET_NODEINFO(uiNodeId_p)->
513 m_dwNodeCfg & (EPL_NODEASSIGN_NODE_IS_CN |
514 EPL_NODEASSIGN_NODE_EXISTS)) != 0) {
515 if (fSoftDeleteNode == FALSE) { // remove CN immediately from isochronous phase
516 Ret = EplDlluCalDeleteNode(uiNodeId_p);
517 } else { // remove CN from isochronous phase softly
518 Ret =
519 EplDlluCalSoftDeleteNode
520 (uiNodeId_p);
521 }
522 }
523 }
524 }
525
526 Exit:
527 return Ret;
528 }
529
530 //---------------------------------------------------------------------------
531 //
532 // Function: EplNmtMnuSendNmtCommand
533 //
534 // Description: sends the specified NMT command to the specified node.
535 //
536 // Parameters: uiNodeId_p = node ID to which the NMT command will be sent
537 // NmtCommand_p = NMT command
538 //
539 // Returns: tEplKernel = error code
540 //
541 // State:
542 //
543 //---------------------------------------------------------------------------
544
545 tEplKernel EplNmtMnuSendNmtCommand(unsigned int uiNodeId_p,
546 tEplNmtCommand NmtCommand_p)
547 {
548 tEplKernel Ret = kEplSuccessful;
549
550 Ret = EplNmtMnuSendNmtCommandEx(uiNodeId_p, NmtCommand_p, NULL, 0);
551
552 //Exit:
553 return Ret;
554 }
555
556 //---------------------------------------------------------------------------
557 //
558 // Function: EplNmtMnuTriggerStateChange
559 //
560 // Description: triggers the specified node command for the specified node.
561 //
562 // Parameters: uiNodeId_p = node ID for which the node command will be executed
563 // NodeCommand_p = node command
564 //
565 // Returns: tEplKernel = error code
566 //
567 // State:
568 //
569 //---------------------------------------------------------------------------
570
571 tEplKernel EplNmtMnuTriggerStateChange(unsigned int uiNodeId_p,
572 tEplNmtNodeCommand NodeCommand_p)
573 {
574 tEplKernel Ret = kEplSuccessful;
575 tEplNmtMnuIntNodeEvent NodeEvent;
576 tEplObdSize ObdSize;
577 BYTE bNmtState;
578 WORD wErrorCode = EPL_E_NO_ERROR;
579
580 if ((uiNodeId_p == 0) || (uiNodeId_p >= EPL_C_ADR_BROADCAST)) {
581 Ret = kEplInvalidNodeId;
582 goto Exit;
583 }
584
585 switch (NodeCommand_p) {
586 case kEplNmtNodeCommandBoot:
587 {
588 NodeEvent = kEplNmtMnuIntNodeEventBoot;
589 break;
590 }
591
592 case kEplNmtNodeCommandConfOk:
593 {
594 NodeEvent = kEplNmtMnuIntNodeEventConfigured;
595 break;
596 }
597
598 case kEplNmtNodeCommandConfErr:
599 {
600 NodeEvent = kEplNmtMnuIntNodeEventError;
601 wErrorCode = EPL_E_NMT_BPO1_CF_VERIFY;
602 break;
603 }
604
605 case kEplNmtNodeCommandConfReset:
606 {
607 NodeEvent = kEplNmtMnuIntNodeEventExecReset;
608 break;
609 }
610
611 default:
612 { // invalid node command
613 goto Exit;
614 }
615 }
616
617 // fetch current NMT state
618 ObdSize = 1;
619 Ret = EplObduReadEntry(0x1F8E, uiNodeId_p, &bNmtState, &ObdSize);
620 if (Ret != kEplSuccessful) {
621 goto Exit;
622 }
623
624 Ret = EplNmtMnuProcessInternalEvent(uiNodeId_p,
625 (tEplNmtState) (bNmtState |
626 EPL_NMT_TYPE_CS),
627 wErrorCode, NodeEvent);
628
629 Exit:
630 return Ret;
631 }
632
633 //---------------------------------------------------------------------------
634 //
635 // Function: EplNmtMnuCbNmtStateChange
636 //
637 // Description: callback function for NMT state changes
638 //
639 // Parameters: NmtStateChange_p = NMT state change event
640 //
641 // Returns: tEplKernel = error code
642 //
643 //
644 // State:
645 //
646 //---------------------------------------------------------------------------
647
648 tEplKernel PUBLIC EplNmtMnuCbNmtStateChange(tEplEventNmtStateChange
649 NmtStateChange_p)
650 {
651 tEplKernel Ret = kEplSuccessful;
652
653 // do work which must be done in that state
654 switch (NmtStateChange_p.m_NewNmtState) {
655 // EPL stack is not running
656 /* case kEplNmtGsOff:
657 break;
658
659 // first init of the hardware
660 case kEplNmtGsInitialising:
661 break;
662
663 // init of the manufacturer-specific profile area and the
664 // standardised device profile area
665 case kEplNmtGsResetApplication:
666 {
667 break;
668 }
669
670 // init of the communication profile area
671 case kEplNmtGsResetCommunication:
672 {
673 break;
674 }
675 */
676 // build the configuration with infos from OD
677 case kEplNmtGsResetConfiguration:
678 {
679 DWORD dwTimeout;
680 tEplObdSize ObdSize;
681
682 // read object 0x1F80 NMT_StartUp_U32
683 ObdSize = 4;
684 Ret =
685 EplObduReadEntry(0x1F80, 0,
686 &EplNmtMnuInstance_g.
687 m_dwNmtStartup, &ObdSize);
688 if (Ret != kEplSuccessful) {
689 break;
690 }
691 // compute StatusReqDelay = object 0x1006 * EPL_C_NMT_STATREQ_CYCLE
692 ObdSize = sizeof(dwTimeout);
693 Ret = EplObduReadEntry(0x1006, 0, &dwTimeout, &ObdSize);
694 if (Ret != kEplSuccessful) {
695 break;
696 }
697 if (dwTimeout != 0L) {
698 EplNmtMnuInstance_g.m_ulStatusRequestDelay =
699 dwTimeout * EPL_C_NMT_STATREQ_CYCLE / 1000L;
700 if (EplNmtMnuInstance_g.
701 m_ulStatusRequestDelay == 0L) {
702 EplNmtMnuInstance_g.m_ulStatusRequestDelay = 1L; // at least 1 ms
703 }
704 // $$$ fetch and use MultiplexedCycleCount from OD
705 EplNmtMnuInstance_g.m_ulTimeoutCheckCom =
706 dwTimeout * EPL_C_NMT_STATREQ_CYCLE / 1000L;
707 if (EplNmtMnuInstance_g.m_ulTimeoutCheckCom ==
708 0L) {
709 EplNmtMnuInstance_g.m_ulTimeoutCheckCom = 1L; // at least 1 ms
710 }
711 }
712 // fetch ReadyToOp Timeout from OD
713 ObdSize = sizeof(dwTimeout);
714 Ret = EplObduReadEntry(0x1F89, 5, &dwTimeout, &ObdSize);
715 if (Ret != kEplSuccessful) {
716 break;
717 }
718 if (dwTimeout != 0L) {
719 // convert [us] to [ms]
720 dwTimeout /= 1000L;
721 if (dwTimeout == 0L) {
722 dwTimeout = 1L; // at least 1 ms
723 }
724 EplNmtMnuInstance_g.m_ulTimeoutReadyToOp =
725 dwTimeout;
726 } else {
727 EplNmtMnuInstance_g.m_ulTimeoutReadyToOp = 0L;
728 }
729 break;
730 }
731 /*
732 //-----------------------------------------------------------
733 // CN part of the state machine
734
735 // node liste for EPL-Frames and check timeout
736 case kEplNmtCsNotActive:
737 {
738 break;
739 }
740
741 // node process only async frames
742 case kEplNmtCsPreOperational1:
743 {
744 break;
745 }
746
747 // node process isochronus and asynchronus frames
748 case kEplNmtCsPreOperational2:
749 {
750 break;
751 }
752
753 // node should be configured und application is ready
754 case kEplNmtCsReadyToOperate:
755 {
756 break;
757 }
758
759 // normal work state
760 case kEplNmtCsOperational:
761 {
762 break;
763 }
764
765 // node stopped by MN
766 // -> only process asynchronus frames
767 case kEplNmtCsStopped:
768 {
769 break;
770 }
771
772 // no EPL cycle
773 // -> normal ethernet communication
774 case kEplNmtCsBasicEthernet:
775 {
776 break;
777 }
778 */
779 //-----------------------------------------------------------
780 // MN part of the state machine
781
782 // node listens for EPL-Frames and check timeout
783 case kEplNmtMsNotActive:
784 {
785 break;
786 }
787
788 // node processes only async frames
789 case kEplNmtMsPreOperational1:
790 {
791 DWORD dwTimeout;
792 tEplTimerArg TimerArg;
793 tEplObdSize ObdSize;
794 tEplEvent Event;
795
796 // clear global flags, e.g. reenable boot process
797 EplNmtMnuInstance_g.m_wFlags = 0;
798
799 // reset IdentResponses and running IdentRequests and StatusRequests
800 Ret = EplIdentuReset();
801 Ret = EplStatusuReset();
802
803 // reset timers
804 Ret = EplNmtMnuReset();
805
806 // 2008/11/18 d.k. reset internal node info is not necessary,
807 // because timer flags are important and other
808 // things are reset by EplNmtMnuStartBootStep1().
809 /*
810 EPL_MEMSET(EplNmtMnuInstance_g.m_aNodeInfo,
811 0,
812 sizeof (EplNmtMnuInstance_g.m_aNodeInfo));
813 */
814
815 // inform DLL about NMT state change,
816 // so that it can clear the asynchonous queues and start the reduced cycle
817 Event.m_EventSink = kEplEventSinkDllk;
818 Event.m_EventType = kEplEventTypeDllkStartReducedCycle;
819 EPL_MEMSET(&Event.m_NetTime, 0x00,
820 sizeof(Event.m_NetTime));
821 Event.m_pArg = NULL;
822 Event.m_uiSize = 0;
823 Ret = EplEventuPost(&Event);
824 if (Ret != kEplSuccessful) {
825 break;
826 }
827 // reset all nodes
828 // d.k.: skip this step if was just done before, e.g. because of a ResetNode command from a diagnostic node
829 if (NmtStateChange_p.m_NmtEvent ==
830 kEplNmtEventTimerMsPreOp1) {
831 BENCHMARK_MOD_07_TOGGLE(9);
832
833 EPL_NMTMNU_DBG_POST_TRACE_VALUE(0,
834 EPL_C_ADR_BROADCAST,
835 kEplNmtCmdResetNode);
836
837 Ret =
838 EplNmtMnuSendNmtCommand(EPL_C_ADR_BROADCAST,
839 kEplNmtCmdResetNode);
840 if (Ret != kEplSuccessful) {
841 break;
842 }
843 }
844 // start network scan
845 Ret = EplNmtMnuStartBootStep1();
846
847 // start timer for 0x1F89/2 MNTimeoutPreOp1_U32
848 ObdSize = sizeof(dwTimeout);
849 Ret = EplObduReadEntry(0x1F89, 2, &dwTimeout, &ObdSize);
850 if (Ret != kEplSuccessful) {
851 break;
852 }
853 if (dwTimeout != 0L) {
854 dwTimeout /= 1000L;
855 if (dwTimeout == 0L) {
856 dwTimeout = 1L; // at least 1 ms
857 }
858 TimerArg.m_EventSink = kEplEventSinkNmtMnu;
859 TimerArg.m_ulArg = 0;
860 Ret =
861 EplTimeruModifyTimerMs(&EplNmtMnuInstance_g.
862 m_TimerHdlNmtState,
863 dwTimeout, TimerArg);
864 }
865 break;
866 }
867
868 // node processes isochronous and asynchronous frames
869 case kEplNmtMsPreOperational2:
870 {
871 // add identified CNs to isochronous phase
872 // send EnableReadyToOp to all identified CNs
873 Ret = EplNmtMnuStartBootStep2();
874
875 // wait for NMT state change of CNs
876 break;
877 }
878
879 // node should be configured und application is ready
880 case kEplNmtMsReadyToOperate:
881 {
882 // check if PRes of CNs are OK
883 // d.k. that means wait CycleLength * MultiplexCycleCount (i.e. start timer)
884 // because Dllk checks PRes of CNs automatically in ReadyToOp
885 Ret = EplNmtMnuStartCheckCom();
886 break;
887 }
888
889 // normal work state
890 case kEplNmtMsOperational:
891 {
892 // send StartNode to CNs
893 // wait for NMT state change of CNs
894 Ret = EplNmtMnuStartNodes();
895 break;
896 }
897
898 // no EPL cycle
899 // -> normal ethernet communication
900 case kEplNmtMsBasicEthernet:
901 {
902 break;
903 }
904
905 default:
906 {
907 // TRACE0("EplNmtMnuCbNmtStateChange(): unhandled NMT state\n");
908 }
909 }
910
911 return Ret;
912 }
913
914 //---------------------------------------------------------------------------
915 //
916 // Function: EplNmtMnuCbCheckEvent
917 //
918 // Description: callback funktion for NMT events before they are actually executed.
919 // The EPL API layer must forward NMT events from NmtCnu module.
920 // This module will reject some NMT commands while MN.
921 //
922 // Parameters: NmtEvent_p = outstanding NMT event for approval
923 //
924 // Returns: tEplKernel = error code
925 // kEplReject = reject the NMT event
926 //
927 // State:
928 //
929 //---------------------------------------------------------------------------
930
931 tEplKernel PUBLIC EplNmtMnuCbCheckEvent(tEplNmtEvent NmtEvent_p)
932 {
933 tEplKernel Ret = kEplSuccessful;
934
935 return Ret;
936 }
937
938 //---------------------------------------------------------------------------
939 //
940 // Function: EplNmtuProcessEvent
941 //
942 // Description: processes events from event queue
943 //
944 // Parameters: pEvent_p = pointer to event
945 //
946 // Returns: tEplKernel = errorcode
947 //
948 // State:
949 //
950 //---------------------------------------------------------------------------
951
952 EPLDLLEXPORT tEplKernel PUBLIC EplNmtMnuProcessEvent(tEplEvent * pEvent_p)
953 {
954 tEplKernel Ret;
955
956 Ret = kEplSuccessful;
957
958 // process event
959 switch (pEvent_p->m_EventType) {
960 // timer event
961 case kEplEventTypeTimer:
962 {
963 tEplTimerEventArg *pTimerEventArg =
964 (tEplTimerEventArg *) pEvent_p->m_pArg;
965 unsigned int uiNodeId;
966
967 uiNodeId =
968 (unsigned int)(pTimerEventArg->
969 m_ulArg &
970 EPL_NMTMNU_TIMERARG_NODE_MASK);
971 if (uiNodeId != 0) {
972 tEplObdSize ObdSize;
973 BYTE bNmtState;
974 tEplNmtMnuNodeInfo *pNodeInfo;
975
976 pNodeInfo = EPL_NMTMNU_GET_NODEINFO(uiNodeId);
977
978 ObdSize = 1;
979 Ret =
980 EplObduReadEntry(0x1F8E, uiNodeId,
981 &bNmtState, &ObdSize);
982 if (Ret != kEplSuccessful) {
983 break;
984 }
985
986 if ((pTimerEventArg->
987 m_ulArg & EPL_NMTMNU_TIMERARG_IDENTREQ) !=
988 0L) {
989 if ((pNodeInfo->
990 m_wFlags &
991 EPL_NMTMNU_NODE_FLAG_COUNT_STATREQ)
992 != (pTimerEventArg->m_ulArg & EPL_NMTMNU_TIMERARG_COUNT_SR)) { // this is an old (already deleted or modified) timer
993 // but not the current timer
994 // so discard it
995 EPL_NMTMNU_DBG_POST_TRACE_VALUE
996 (kEplNmtMnuIntNodeEventTimerIdentReq,
997 uiNodeId,
998 ((pNodeInfo->
999 m_NodeState << 8)
1000 | 0xFF));
1001
1002 break;
1003 }
1004 /*
1005 EPL_NMTMNU_DBG_POST_TRACE_VALUE(kEplNmtMnuIntNodeEventTimerIdentReq,
1006 uiNodeId,
1007 ((pNodeInfo->m_NodeState << 8)
1008 | 0x80
1009 | ((pNodeInfo->m_wFlags & EPL_NMTMNU_NODE_FLAG_COUNT_STATREQ) >> 6)
1010 | ((pTimerEventArg->m_ulArg & EPL_NMTMNU_TIMERARG_COUNT_SR) >> 8)));
1011 */
1012 Ret =
1013 EplNmtMnuProcessInternalEvent
1014 (uiNodeId,
1015 (tEplNmtState) (bNmtState |
1016 EPL_NMT_TYPE_CS),
1017 EPL_E_NO_ERROR,
1018 kEplNmtMnuIntNodeEventTimerIdentReq);
1019 }
1020
1021 else if ((pTimerEventArg->
1022 m_ulArg & EPL_NMTMNU_TIMERARG_STATREQ)
1023 != 0L) {
1024 if ((pNodeInfo->
1025 m_wFlags &
1026 EPL_NMTMNU_NODE_FLAG_COUNT_STATREQ)
1027 != (pTimerEventArg->m_ulArg & EPL_NMTMNU_TIMERARG_COUNT_SR)) { // this is an old (already deleted or modified) timer
1028 // but not the current timer
1029 // so discard it
1030 EPL_NMTMNU_DBG_POST_TRACE_VALUE
1031 (kEplNmtMnuIntNodeEventTimerStatReq,
1032 uiNodeId,
1033 ((pNodeInfo->
1034 m_NodeState << 8)
1035 | 0xFF));
1036
1037 break;
1038 }
1039 /*
1040 EPL_NMTMNU_DBG_POST_TRACE_VALUE(kEplNmtMnuIntNodeEventTimerStatReq,
1041 uiNodeId,
1042 ((pNodeInfo->m_NodeState << 8)
1043 | 0x80
1044 | ((pNodeInfo->m_wFlags & EPL_NMTMNU_NODE_FLAG_COUNT_STATREQ) >> 6)
1045 | ((pTimerEventArg->m_ulArg & EPL_NMTMNU_TIMERARG_COUNT_SR) >> 8)));
1046 */
1047 Ret =
1048 EplNmtMnuProcessInternalEvent
1049 (uiNodeId,
1050 (tEplNmtState) (bNmtState |
1051 EPL_NMT_TYPE_CS),
1052 EPL_E_NO_ERROR,
1053 kEplNmtMnuIntNodeEventTimerStatReq);
1054 }
1055
1056 else if ((pTimerEventArg->
1057 m_ulArg &
1058 EPL_NMTMNU_TIMERARG_STATE_MON) !=
1059 0L) {
1060 if ((pNodeInfo->
1061 m_wFlags &
1062 EPL_NMTMNU_NODE_FLAG_COUNT_STATREQ)
1063 != (pTimerEventArg->m_ulArg & EPL_NMTMNU_TIMERARG_COUNT_SR)) { // this is an old (already deleted or modified) timer
1064 // but not the current timer
1065 // so discard it
1066 EPL_NMTMNU_DBG_POST_TRACE_VALUE
1067 (kEplNmtMnuIntNodeEventTimerStateMon,
1068 uiNodeId,
1069 ((pNodeInfo->
1070 m_NodeState << 8)
1071 | 0xFF));
1072
1073 break;
1074 }
1075 /*
1076 EPL_NMTMNU_DBG_POST_TRACE_VALUE(kEplNmtMnuIntNodeEventTimerStatReq,
1077 uiNodeId,
1078 ((pNodeInfo->m_NodeState << 8)
1079 | 0x80
1080 | ((pNodeInfo->m_wFlags & EPL_NMTMNU_NODE_FLAG_COUNT_STATREQ) >> 6)
1081 | ((pTimerEventArg->m_ulArg & EPL_NMTMNU_TIMERARG_COUNT_SR) >> 8)));
1082 */
1083 Ret =
1084 EplNmtMnuProcessInternalEvent
1085 (uiNodeId,
1086 (tEplNmtState) (bNmtState |
1087 EPL_NMT_TYPE_CS),
1088 EPL_E_NO_ERROR,
1089 kEplNmtMnuIntNodeEventTimerStateMon);
1090 }
1091
1092 else if ((pTimerEventArg->
1093 m_ulArg & EPL_NMTMNU_TIMERARG_LONGER)
1094 != 0L) {
1095 if ((pNodeInfo->
1096 m_wFlags &
1097 EPL_NMTMNU_NODE_FLAG_COUNT_LONGER)
1098 != (pTimerEventArg->m_ulArg & EPL_NMTMNU_TIMERARG_COUNT_LO)) { // this is an old (already deleted or modified) timer
1099 // but not the current timer
1100 // so discard it
1101 EPL_NMTMNU_DBG_POST_TRACE_VALUE
1102 (kEplNmtMnuIntNodeEventTimerLonger,
1103 uiNodeId,
1104 ((pNodeInfo->
1105 m_NodeState << 8)
1106 | 0xFF));
1107
1108 break;
1109 }
1110 /*
1111 EPL_NMTMNU_DBG_POST_TRACE_VALUE(kEplNmtMnuIntNodeEventTimerLonger,
1112 uiNodeId,
1113 ((pNodeInfo->m_NodeState << 8)
1114 | 0x80
1115 | ((pNodeInfo->m_wFlags & EPL_NMTMNU_NODE_FLAG_COUNT_LONGER) >> 6)
1116 | ((pTimerEventArg->m_ulArg & EPL_NMTMNU_TIMERARG_COUNT_LO) >> 8)));
1117 */
1118 Ret =
1119 EplNmtMnuProcessInternalEvent
1120 (uiNodeId,
1121 (tEplNmtState) (bNmtState |
1122 EPL_NMT_TYPE_CS),
1123 EPL_E_NO_ERROR,
1124 kEplNmtMnuIntNodeEventTimerLonger);
1125 }
1126
1127 } else { // global timer event
1128 }
1129 break;
1130 }
1131
1132 case kEplEventTypeHeartbeat:
1133 {
1134 tEplHeartbeatEvent *pHeartbeatEvent =
1135 (tEplHeartbeatEvent *) pEvent_p->m_pArg;
1136
1137 Ret =
1138 EplNmtMnuProcessInternalEvent(pHeartbeatEvent->
1139 m_uiNodeId,
1140 pHeartbeatEvent->
1141 m_NmtState,
1142 pHeartbeatEvent->
1143 m_wErrorCode,
1144 kEplNmtMnuIntNodeEventHeartbeat);
1145 break;
1146 }
1147
1148 case kEplEventTypeNmtMnuNmtCmdSent:
1149 {
1150 tEplFrame *pFrame = (tEplFrame *) pEvent_p->m_pArg;
1151 unsigned int uiNodeId;
1152 tEplNmtCommand NmtCommand;
1153 BYTE bNmtState;
1154
1155 uiNodeId = AmiGetByteFromLe(&pFrame->m_le_bDstNodeId);
1156 NmtCommand =
1157 (tEplNmtCommand) AmiGetByteFromLe(&pFrame->m_Data.
1158 m_Asnd.m_Payload.
1159 m_NmtCommandService.
1160 m_le_bNmtCommandId);
1161
1162 switch (NmtCommand) {
1163 case kEplNmtCmdStartNode:
1164 bNmtState =
1165 (BYTE) (kEplNmtCsOperational & 0xFF);
1166 break;
1167
1168 case kEplNmtCmdStopNode:
1169 bNmtState = (BYTE) (kEplNmtCsStopped & 0xFF);
1170 break;
1171
1172 case kEplNmtCmdEnterPreOperational2:
1173 bNmtState =
1174 (BYTE) (kEplNmtCsPreOperational2 & 0xFF);
1175 break;
1176
1177 case kEplNmtCmdEnableReadyToOperate:
1178 // d.k. do not change expected node state, because of DS 1.0.0 7.3.1.2.1 Plain NMT State Command
1179 // and because node may not change NMT state within EPL_C_NMT_STATE_TOLERANCE
1180 bNmtState =
1181 (BYTE) (kEplNmtCsPreOperational2 & 0xFF);
1182 break;
1183
1184 case kEplNmtCmdResetNode:
1185 case kEplNmtCmdResetCommunication:
1186 case kEplNmtCmdResetConfiguration:
1187 case kEplNmtCmdSwReset:
1188 bNmtState = (BYTE) (kEplNmtCsNotActive & 0xFF);
1189 // EplNmtMnuProcessInternalEvent() sets internal node state to kEplNmtMnuNodeStateUnknown
1190 // after next unresponded IdentRequest/StatusRequest
1191 break;
1192
1193 default:
1194 goto Exit;
1195 }
1196
1197 // process as internal event which update expected NMT state in OD
1198 if (uiNodeId != EPL_C_ADR_BROADCAST) {
1199 Ret = EplNmtMnuProcessInternalEvent(uiNodeId,
1200 (tEplNmtState)
1201 (bNmtState |
1202 EPL_NMT_TYPE_CS),
1203 0,
1204 kEplNmtMnuIntNodeEventNmtCmdSent);
1205
1206 } else { // process internal event for all active nodes (except myself)
1207
1208 for (uiNodeId = 1;
1209 uiNodeId <=
1210 tabentries(EplNmtMnuInstance_g.
1211 m_aNodeInfo); uiNodeId++) {
1212 if ((EPL_NMTMNU_GET_NODEINFO(uiNodeId)->
1213 m_dwNodeCfg &
1214 (EPL_NODEASSIGN_NODE_IS_CN |
1215 EPL_NODEASSIGN_NODE_EXISTS)) !=
1216 0) {
1217 Ret =
1218 EplNmtMnuProcessInternalEvent
1219 (uiNodeId,
1220 (tEplNmtState) (bNmtState |
1221 EPL_NMT_TYPE_CS),
1222 0,
1223 kEplNmtMnuIntNodeEventNmtCmdSent);
1224
1225 if (Ret != kEplSuccessful) {
1226 goto Exit;
1227 }
1228 }
1229 }
1230 }
1231
1232 break;
1233 }
1234
1235 default:
1236 {
1237 Ret = kEplNmtInvalidEvent;
1238 }
1239
1240 }
1241
1242 Exit:
1243 return Ret;
1244 }
1245
1246 //---------------------------------------------------------------------------
1247 //
1248 // Function: EplNmtMnuGetRunningTimerStatReq
1249 //
1250 // Description: returns a bit field with running StatReq timers
1251 // just for debugging purposes
1252 //
1253 // Parameters: (none)
1254 //
1255 // Returns: tEplKernel = error code
1256 //
1257 // State:
1258 //
1259 //---------------------------------------------------------------------------
1260
1261 tEplKernel PUBLIC EplNmtMnuGetDiagnosticInfo(unsigned int
1262 *puiMandatorySlaveCount_p,
1263 unsigned int
1264 *puiSignalSlaveCount_p,
1265 WORD * pwFlags_p)
1266 {
1267 tEplKernel Ret = kEplSuccessful;
1268
1269 if ((puiMandatorySlaveCount_p == NULL)
1270 || (puiSignalSlaveCount_p == NULL)
1271 || (pwFlags_p == NULL)) {
1272 Ret = kEplNmtInvalidParam;
1273 goto Exit;
1274 }
1275
1276 *puiMandatorySlaveCount_p = EplNmtMnuInstance_g.m_uiMandatorySlaveCount;
1277 *puiSignalSlaveCount_p = EplNmtMnuInstance_g.m_uiSignalSlaveCount;
1278 *pwFlags_p = EplNmtMnuInstance_g.m_wFlags;
1279
1280 Exit:
1281 return Ret;
1282 }
1283
1284 //---------------------------------------------------------------------------
1285 //
1286 // Function: EplNmtMnuGetRunningTimerStatReq
1287 //
1288 // Description: returns a bit field with running StatReq timers
1289 // just for debugging purposes
1290 //
1291 // Parameters: (none)
1292 //
1293 // Returns: tEplKernel = error code
1294 //
1295 // State:
1296 //
1297 //---------------------------------------------------------------------------
1298 /*
1299 DWORD EplNmtMnuGetRunningTimerStatReq(void)
1300 {
1301 tEplKernel Ret = kEplSuccessful;
1302 unsigned int uiIndex;
1303 tEplNmtMnuNodeInfo* pNodeInfo;
1304
1305 pNodeInfo = EplNmtMnuInstance_g.m_aNodeInfo;
1306 for (uiIndex = 1; uiIndex <= tabentries(EplNmtMnuInstance_g.m_aNodeInfo); uiIndex++, pNodeInfo++)
1307 {
1308 if (pNodeInfo->m_NodeState == kEplNmtMnuNodeStateConfigured)
1309 {
1310 // reset flag "scanned once"
1311 pNodeInfo->m_wFlags &= ~EPL_NMTMNU_NODE_FLAG_SCANNED;
1312
1313 Ret = EplNmtMnuNodeBootStep2(uiIndex, pNodeInfo);
1314 if (Ret != kEplSuccessful)
1315 {
1316 goto Exit;
1317 }
1318 EplNmtMnuInstance_g.m_uiSignalSlaveCount++;
1319 // signal slave counter shall be decremented if StatusRequest was sent once to a CN
1320 // mandatory slave counter shall be decremented if mandatory CN is ReadyToOp
1321 }
1322 }
1323
1324 Exit:
1325 return Ret;
1326 }
1327 */
1328
1329 //=========================================================================//
1330 // //
1331 // P R I V A T E F U N C T I O N S //
1332 // //
1333 //=========================================================================//
1334
1335 //---------------------------------------------------------------------------
1336 //
1337 // Function: EplNmtMnuCbNmtRequest
1338 //
1339 // Description: callback funktion for NmtRequest
1340 //
1341 // Parameters: pFrameInfo_p = Frame with the NmtRequest
1342 //
1343 // Returns: tEplKernel = error code
1344 //
1345 //
1346 // State:
1347 //
1348 //---------------------------------------------------------------------------
1349
1350 static tEplKernel PUBLIC EplNmtMnuCbNmtRequest(tEplFrameInfo * pFrameInfo_p)
1351 {
1352 tEplKernel Ret = kEplSuccessful;
1353
1354 // $$$ perform NMTRequest
1355 return Ret;
1356 }
1357
1358 //---------------------------------------------------------------------------
1359 //
1360 // Function: EplNmtMnuCbIdentResponse
1361 //
1362 // Description: callback funktion for IdentResponse
1363 //
1364 // Parameters: uiNodeId_p = node ID for which IdentReponse was received
1365 // pIdentResponse_p = pointer to IdentResponse
1366 // is NULL if node did not answer
1367 //
1368 // Returns: tEplKernel = error code
1369 //
1370 // State:
1371 //
1372 //---------------------------------------------------------------------------
1373
1374 static tEplKernel PUBLIC EplNmtMnuCbIdentResponse(unsigned int uiNodeId_p,
1375 tEplIdentResponse *
1376 pIdentResponse_p)
1377 {
1378 tEplKernel Ret = kEplSuccessful;
1379
1380 if (pIdentResponse_p == NULL) { // node did not answer
1381 Ret = EplNmtMnuProcessInternalEvent(uiNodeId_p, kEplNmtCsNotActive, EPL_E_NMT_NO_IDENT_RES, // was EPL_E_NO_ERROR
1382 kEplNmtMnuIntNodeEventNoIdentResponse);
1383 } else { // node answered IdentRequest
1384 tEplObdSize ObdSize;
1385 DWORD dwDevType;
1386 WORD wErrorCode = EPL_E_NO_ERROR;
1387 tEplNmtState NmtState =
1388 (tEplNmtState) (AmiGetByteFromLe
1389 (&pIdentResponse_p->
1390 m_le_bNmtStatus) | EPL_NMT_TYPE_CS);
1391
1392 // check IdentResponse $$$ move to ProcessIntern, because this function may be called also if CN
1393
1394 // check DeviceType (0x1F84)
1395 ObdSize = 4;
1396 Ret =
1397 EplObduReadEntry(0x1F84, uiNodeId_p, &dwDevType, &ObdSize);
1398 if (Ret != kEplSuccessful) {
1399 goto Exit;
1400 }
1401 if (dwDevType != 0L) { // actually compare it with DeviceType from IdentResponse
1402 if (AmiGetDwordFromLe(&pIdentResponse_p->m_le_dwDeviceType) != dwDevType) { // wrong DeviceType
1403 NmtState = kEplNmtCsNotActive;
1404 wErrorCode = EPL_E_NMT_BPO1_DEVICE_TYPE;
1405 }
1406 }
1407
1408 Ret = EplNmtMnuProcessInternalEvent(uiNodeId_p,
1409 NmtState,
1410 wErrorCode,
1411 kEplNmtMnuIntNodeEventIdentResponse);
1412 }
1413
1414 Exit:
1415 return Ret;
1416 }
1417
1418 //---------------------------------------------------------------------------
1419 //
1420 // Function: EplNmtMnuCbStatusResponse
1421 //
1422 // Description: callback funktion for StatusResponse
1423 //
1424 // Parameters: uiNodeId_p = node ID for which IdentReponse was received
1425 // pIdentResponse_p = pointer to IdentResponse
1426 // is NULL if node did not answer
1427 //
1428 // Returns: tEplKernel = error code
1429 //
1430 // State:
1431 //
1432 //---------------------------------------------------------------------------
1433
1434 static tEplKernel PUBLIC EplNmtMnuCbStatusResponse(unsigned int uiNodeId_p,
1435 tEplStatusResponse *
1436 pStatusResponse_p)
1437 {
1438 tEplKernel Ret = kEplSuccessful;
1439
1440 if (pStatusResponse_p == NULL) { // node did not answer
1441 Ret = EplNmtMnuProcessInternalEvent(uiNodeId_p, kEplNmtCsNotActive, EPL_E_NMT_NO_STATUS_RES, // was EPL_E_NO_ERROR
1442 kEplNmtMnuIntNodeEventNoStatusResponse);
1443 } else { // node answered StatusRequest
1444 Ret = EplNmtMnuProcessInternalEvent(uiNodeId_p,
1445 (tEplNmtState)
1446 (AmiGetByteFromLe
1447 (&pStatusResponse_p->
1448 m_le_bNmtStatus) |
1449 EPL_NMT_TYPE_CS),
1450 EPL_E_NO_ERROR,
1451 kEplNmtMnuIntNodeEventStatusResponse);
1452 }
1453
1454 return Ret;
1455 }
1456
1457 //---------------------------------------------------------------------------
1458 //
1459 // Function: EplNmtMnuStartBootStep1
1460 //
1461 // Description: starts BootStep1
1462 //
1463 // Parameters: (none)
1464 //
1465 // Returns: tEplKernel = error code
1466 //
1467 // State:
1468 //
1469 //---------------------------------------------------------------------------
1470
1471 static tEplKernel EplNmtMnuStartBootStep1(void)
1472 {
1473 tEplKernel Ret = kEplSuccessful;
1474 unsigned int uiSubIndex;
1475 unsigned int uiLocalNodeId;
1476 DWORD dwNodeCfg;
1477 tEplObdSize ObdSize;
1478
1479 // $$$ d.k.: save current time for 0x1F89/2 MNTimeoutPreOp1_U32
1480
1481 // start network scan
1482 EplNmtMnuInstance_g.m_uiMandatorySlaveCount = 0;
1483 EplNmtMnuInstance_g.m_uiSignalSlaveCount = 0;
1484 // check 0x1F81
1485 uiLocalNodeId = EplObduGetNodeId();
1486 for (uiSubIndex = 1; uiSubIndex <= 254; uiSubIndex++) {
1487 ObdSize = 4;
1488 Ret =
1489 EplObduReadEntry(0x1F81, uiSubIndex, &dwNodeCfg, &ObdSize);
1490 if (Ret != kEplSuccessful) {
1491 goto Exit;
1492 }
1493 if (uiSubIndex != uiLocalNodeId) {
1494 // reset flags "not scanned" and "isochronous"
1495 EPL_NMTMNU_GET_NODEINFO(uiSubIndex)->m_wFlags &=
1496 ~(EPL_NMTMNU_NODE_FLAG_ISOCHRON |
1497 EPL_NMTMNU_NODE_FLAG_NOT_SCANNED);
1498
1499 if (uiSubIndex == EPL_C_ADR_DIAG_DEF_NODE_ID) { // diagnostic node must be scanned by MN in any case
1500 dwNodeCfg |=
1501 (EPL_NODEASSIGN_NODE_IS_CN |
1502 EPL_NODEASSIGN_NODE_EXISTS);
1503 // and it must be isochronously accessed
1504 dwNodeCfg &= ~EPL_NODEASSIGN_ASYNCONLY_NODE;
1505 }
1506 // save node config in local node info structure
1507 EPL_NMTMNU_GET_NODEINFO(uiSubIndex)->m_dwNodeCfg =
1508 dwNodeCfg;
1509 EPL_NMTMNU_GET_NODEINFO(uiSubIndex)->m_NodeState =
1510 kEplNmtMnuNodeStateUnknown;
1511
1512 if ((dwNodeCfg & (EPL_NODEASSIGN_NODE_IS_CN | EPL_NODEASSIGN_NODE_EXISTS)) != 0) { // node is configured as CN
1513 // identify the node
1514 Ret =
1515 EplIdentuRequestIdentResponse(uiSubIndex,
1516 EplNmtMnuCbIdentResponse);
1517 if (Ret != kEplSuccessful) {
1518 goto Exit;
1519 }
1520 // set flag "not scanned"
1521 EPL_NMTMNU_GET_NODEINFO(uiSubIndex)->m_wFlags |=
1522 EPL_NMTMNU_NODE_FLAG_NOT_SCANNED;
1523 EplNmtMnuInstance_g.m_uiSignalSlaveCount++;
1524 // signal slave counter shall be decremented if IdentRequest was sent once to a CN
1525
1526 if ((dwNodeCfg & EPL_NODEASSIGN_MANDATORY_CN) != 0) { // node is a mandatory CN
1527 EplNmtMnuInstance_g.
1528 m_uiMandatorySlaveCount++;
1529 // mandatory slave counter shall be decremented if mandatory CN was configured successfully
1530 }
1531 }
1532 } else { // subindex of MN
1533 if ((dwNodeCfg & (EPL_NODEASSIGN_MN_PRES | EPL_NODEASSIGN_NODE_EXISTS)) != 0) { // MN shall send PRes
1534 tEplDllNodeInfo DllNodeInfo;
1535
1536 EPL_MEMSET(&DllNodeInfo, 0,
1537 sizeof(DllNodeInfo));
1538 DllNodeInfo.m_uiNodeId = uiLocalNodeId;
1539
1540 Ret = EplDlluCalAddNode(&DllNodeInfo);
1541 }
1542 }
1543 }
1544
1545 Exit:
1546 return Ret;
1547 }
1548
1549 //---------------------------------------------------------------------------
1550 //
1551 // Function: EplNmtMnuStartBootStep2
1552 //
1553 // Description: starts BootStep2.
1554 // That means add nodes to isochronous phase and send
1555 // NMT EnableReadyToOp.
1556 //
1557 // Parameters: (none)
1558 //
1559 // Returns: tEplKernel = error code
1560 //
1561 // State:
1562 //
1563 //---------------------------------------------------------------------------
1564
1565 static tEplKernel EplNmtMnuStartBootStep2(void)
1566 {
1567 tEplKernel Ret = kEplSuccessful;
1568 unsigned int uiIndex;
1569 tEplNmtMnuNodeInfo *pNodeInfo;
1570
1571 if ((EplNmtMnuInstance_g.m_wFlags & EPL_NMTMNU_FLAG_HALTED) == 0) { // boot process is not halted
1572 // add nodes to isochronous phase and send NMT EnableReadyToOp
1573 EplNmtMnuInstance_g.m_uiMandatorySlaveCount = 0;
1574 EplNmtMnuInstance_g.m_uiSignalSlaveCount = 0;
1575 // reset flag that application was informed about possible state change
1576 EplNmtMnuInstance_g.m_wFlags &= ~EPL_NMTMNU_FLAG_APP_INFORMED;
1577
1578 pNodeInfo = EplNmtMnuInstance_g.m_aNodeInfo;
1579 for (uiIndex = 1;
1580 uiIndex <= tabentries(EplNmtMnuInstance_g.m_aNodeInfo);
1581 uiIndex++, pNodeInfo++) {
1582 if (pNodeInfo->m_NodeState ==
1583 kEplNmtMnuNodeStateConfigured) {
1584 Ret =
1585 EplNmtMnuNodeBootStep2(uiIndex, pNodeInfo);
1586 if (Ret != kEplSuccessful) {
1587 goto Exit;
1588 }
1589 // set flag "not scanned"
1590 pNodeInfo->m_wFlags |=
1591 EPL_NMTMNU_NODE_FLAG_NOT_SCANNED;
1592
1593 EplNmtMnuInstance_g.m_uiSignalSlaveCount++;
1594 // signal slave counter shall be decremented if StatusRequest was sent once to a CN
1595
1596 if ((pNodeInfo->m_dwNodeCfg & EPL_NODEASSIGN_MANDATORY_CN) != 0) { // node is a mandatory CN
1597 EplNmtMnuInstance_g.
1598 m_uiMandatorySlaveCount++;
1599 }
1600 // mandatory slave counter shall be decremented if mandatory CN is ReadyToOp
1601 }
1602 }
1603 }
1604
1605 Exit:
1606 return Ret;
1607 }
1608
1609 //---------------------------------------------------------------------------
1610 //
1611 // Function: EplNmtMnuNodeBootStep2
1612 //
1613 // Description: starts BootStep2 for the specified node.
1614 // This means the CN is added to isochronous phase if not
1615 // async-only and it gets the NMT command EnableReadyToOp.
1616 // The CN must be in node state Configured, when it enters
1617 // BootStep2. When BootStep2 finishes, the CN is in node state
1618 // ReadyToOp.
1619 // If TimeoutReadyToOp in object 0x1F89/5 is configured,
1620 // TimerHdlLonger will be started with this timeout.
1621 //
1622 // Parameters: uiNodeId_p = node ID
1623 // pNodeInfo_p = pointer to internal node info structure
1624 //
1625 // Returns: tEplKernel = error code
1626 //
1627 // State:
1628 //
1629 //---------------------------------------------------------------------------
1630
1631 static tEplKernel EplNmtMnuNodeBootStep2(unsigned int uiNodeId_p,
1632 tEplNmtMnuNodeInfo * pNodeInfo_p)
1633 {
1634 tEplKernel Ret = kEplSuccessful;
1635 tEplDllNodeInfo DllNodeInfo;
1636 DWORD dwNodeCfg;
1637 tEplObdSize ObdSize;
1638 tEplTimerArg TimerArg;
1639
1640 dwNodeCfg = pNodeInfo_p->m_dwNodeCfg;
1641 if ((dwNodeCfg & EPL_NODEASSIGN_ASYNCONLY_NODE) == 0) { // add node to isochronous phase
1642 DllNodeInfo.m_uiNodeId = uiNodeId_p;
1643 ObdSize = 4;
1644 Ret =
1645 EplObduReadEntry(0x1F92, uiNodeId_p,
1646 &DllNodeInfo.m_dwPresTimeout, &ObdSize);
1647 if (Ret != kEplSuccessful) {
1648 goto Exit;
1649 }
1650
1651 ObdSize = 2;
1652 Ret =
1653 EplObduReadEntry(0x1F8B, uiNodeId_p,
1654 &DllNodeInfo.m_wPreqPayloadLimit,
1655 &ObdSize);
1656 if (Ret != kEplSuccessful) {
1657 goto Exit;
1658 }
1659
1660 ObdSize = 2;
1661 Ret =
1662 EplObduReadEntry(0x1F8D, uiNodeId_p,
1663 &DllNodeInfo.m_wPresPayloadLimit,
1664 &ObdSize);
1665 if (Ret != kEplSuccessful) {
1666 goto Exit;
1667 }
1668
1669 pNodeInfo_p->m_wFlags |= EPL_NMTMNU_NODE_FLAG_ISOCHRON;
1670
1671 Ret = EplDlluCalAddNode(&DllNodeInfo);
1672 if (Ret != kEplSuccessful) {
1673 goto Exit;
1674 }
1675
1676 }
1677
1678 EPL_NMTMNU_DBG_POST_TRACE_VALUE(0,
1679 uiNodeId_p,
1680 kEplNmtCmdEnableReadyToOperate);
1681
1682 Ret =
1683 EplNmtMnuSendNmtCommand(uiNodeId_p, kEplNmtCmdEnableReadyToOperate);
1684 if (Ret != kEplSuccessful) {
1685 goto Exit;
1686 }
1687
1688 if (EplNmtMnuInstance_g.m_ulTimeoutReadyToOp != 0L) { // start timer
1689 // when the timer expires the CN must be ReadyToOp
1690 EPL_NMTMNU_SET_FLAGS_TIMERARG_LONGER(pNodeInfo_p, uiNodeId_p,
1691 TimerArg);
1692 // TimerArg.m_EventSink = kEplEventSinkNmtMnu;
1693 // TimerArg.m_ulArg = EPL_NMTMNU_TIMERARG_LONGER | uiNodeId_p;
1694 Ret =
1695 EplTimeruModifyTimerMs(&pNodeInfo_p->m_TimerHdlLonger,
1696 EplNmtMnuInstance_g.
1697 m_ulTimeoutReadyToOp, TimerArg);
1698 }
1699
1700 Exit:
1701 return Ret;
1702 }
1703
1704 //---------------------------------------------------------------------------
1705 //
1706 // Function: EplNmtMnuStartCheckCom
1707 //
1708 // Description: starts CheckCommunication
1709 //
1710 // Parameters: (none)
1711 //
1712 // Returns: tEplKernel = error code
1713 //
1714 // State:
1715 //
1716 //---------------------------------------------------------------------------
1717
1718 static tEplKernel EplNmtMnuStartCheckCom(void)
1719 {
1720 tEplKernel Ret = kEplSuccessful;
1721 unsigned int uiIndex;
1722 tEplNmtMnuNodeInfo *pNodeInfo;
1723
1724 if ((EplNmtMnuInstance_g.m_wFlags & EPL_NMTMNU_FLAG_HALTED) == 0) { // boot process is not halted
1725 // wait some time and check that no communication error occurs
1726 EplNmtMnuInstance_g.m_uiMandatorySlaveCount = 0;
1727 EplNmtMnuInstance_g.m_uiSignalSlaveCount = 0;
1728 // reset flag that application was informed about possible state change
1729 EplNmtMnuInstance_g.m_wFlags &= ~EPL_NMTMNU_FLAG_APP_INFORMED;
1730
1731 pNodeInfo = EplNmtMnuInstance_g.m_aNodeInfo;
1732 for (uiIndex = 1;
1733 uiIndex <= tabentries(EplNmtMnuInstance_g.m_aNodeInfo);
1734 uiIndex++, pNodeInfo++) {
1735 if (pNodeInfo->m_NodeState ==
1736 kEplNmtMnuNodeStateReadyToOp) {
1737 Ret = EplNmtMnuNodeCheckCom(uiIndex, pNodeInfo);
1738 if (Ret == kEplReject) { // timer was started
1739 // wait until it expires
1740 if ((pNodeInfo->m_dwNodeCfg & EPL_NODEASSIGN_MANDATORY_CN) != 0) { // node is a mandatory CN
1741 EplNmtMnuInstance_g.
1742 m_uiMandatorySlaveCount++;
1743 }
1744 } else if (Ret != kEplSuccessful) {
1745 goto Exit;
1746 }
1747 // set flag "not scanned"
1748 pNodeInfo->m_wFlags |=
1749 EPL_NMTMNU_NODE_FLAG_NOT_SCANNED;
1750
1751 EplNmtMnuInstance_g.m_uiSignalSlaveCount++;
1752 // signal slave counter shall be decremented if timeout elapsed and regardless of an error
1753 // mandatory slave counter shall be decremented if timeout elapsed and no error occured
1754 }
1755 }
1756 }
1757
1758 Ret = kEplSuccessful;
1759
1760 Exit:
1761 return Ret;
1762 }
1763
1764 //---------------------------------------------------------------------------
1765 //
1766 // Function: EplNmtMnuNodeCheckCom
1767 //
1768 // Description: checks communication of the specified node.
1769 // That means wait some time and if no error occured everything
1770 // is OK.
1771 //
1772 // Parameters: uiNodeId_p = node ID
1773 // pNodeInfo_p = pointer to internal node info structure
1774 //
1775 // Returns: tEplKernel = error code
1776 //
1777 // State:
1778 //
1779 //---------------------------------------------------------------------------
1780
1781 static tEplKernel EplNmtMnuNodeCheckCom(unsigned int uiNodeId_p,
1782 tEplNmtMnuNodeInfo * pNodeInfo_p)
1783 {
1784 tEplKernel Ret = kEplSuccessful;
1785 DWORD dwNodeCfg;
1786 tEplTimerArg TimerArg;
1787
1788 dwNodeCfg = pNodeInfo_p->m_dwNodeCfg;
1789 if (((dwNodeCfg & EPL_NODEASSIGN_ASYNCONLY_NODE) == 0)
1790 && (EplNmtMnuInstance_g.m_ulTimeoutCheckCom != 0L)) { // CN is not async-only and timeout for CheckCom was set
1791
1792 // check communication,
1793 // that means wait some time and if no error occured everything is OK;
1794
1795 // start timer (when the timer expires the CN must be still ReadyToOp)
1796 EPL_NMTMNU_SET_FLAGS_TIMERARG_LONGER(pNodeInfo_p, uiNodeId_p,
1797 TimerArg);
1798 // TimerArg.m_EventSink = kEplEventSinkNmtMnu;
1799 // TimerArg.m_ulArg = EPL_NMTMNU_TIMERARG_LONGER | uiNodeId_p;
1800 Ret =
1801 EplTimeruModifyTimerMs(&pNodeInfo_p->m_TimerHdlLonger,
1802 EplNmtMnuInstance_g.
1803 m_ulTimeoutCheckCom, TimerArg);
1804
1805 // update mandatory slave counter, because timer was started
1806 if (Ret == kEplSuccessful) {
1807 Ret = kEplReject;
1808 }
1809 } else { // timer was not started
1810 // assume everything is OK
1811 pNodeInfo_p->m_NodeState = kEplNmtMnuNodeStateComChecked;
1812 }
1813
1814 //Exit:
1815 return Ret;
1816 }
1817
1818 //---------------------------------------------------------------------------
1819 //
1820 // Function: EplNmtMnuStartNodes
1821 //
1822 // Description: really starts all nodes which are ReadyToOp and CheckCom did not fail
1823 //
1824 // Parameters: (none)
1825 //
1826 // Returns: tEplKernel = error code
1827 //
1828 // State:
1829 //
1830 //---------------------------------------------------------------------------
1831
1832 static tEplKernel EplNmtMnuStartNodes(void)
1833 {
1834 tEplKernel Ret = kEplSuccessful;
1835 unsigned int uiIndex;
1836 tEplNmtMnuNodeInfo *pNodeInfo;
1837
1838 if ((EplNmtMnuInstance_g.m_wFlags & EPL_NMTMNU_FLAG_HALTED) == 0) { // boot process is not halted
1839 // send NMT command Start Node
1840 EplNmtMnuInstance_g.m_uiMandatorySlaveCount = 0;
1841 EplNmtMnuInstance_g.m_uiSignalSlaveCount = 0;
1842 // reset flag that application was informed about possible state change
1843 EplNmtMnuInstance_g.m_wFlags &= ~EPL_NMTMNU_FLAG_APP_INFORMED;
1844
1845 pNodeInfo = EplNmtMnuInstance_g.m_aNodeInfo;
1846 for (uiIndex = 1;
1847 uiIndex <= tabentries(EplNmtMnuInstance_g.m_aNodeInfo);
1848 uiIndex++, pNodeInfo++) {
1849 if (pNodeInfo->m_NodeState ==
1850 kEplNmtMnuNodeStateComChecked) {
1851 if ((EplNmtMnuInstance_g.
1852 m_dwNmtStartup & EPL_NMTST_STARTALLNODES)
1853 == 0) {
1854 EPL_NMTMNU_DBG_POST_TRACE_VALUE(0,
1855 uiIndex,
1856 kEplNmtCmdStartNode);
1857
1858 Ret =
1859 EplNmtMnuSendNmtCommand(uiIndex,
1860 kEplNmtCmdStartNode);
1861 if (Ret != kEplSuccessful) {
1862 goto Exit;
1863 }
1864 }
1865
1866 if ((pNodeInfo->m_dwNodeCfg & EPL_NODEASSIGN_MANDATORY_CN) != 0) { // node is a mandatory CN
1867 EplNmtMnuInstance_g.
1868 m_uiMandatorySlaveCount++;
1869 }
1870 // set flag "not scanned"
1871 pNodeInfo->m_wFlags |=
1872 EPL_NMTMNU_NODE_FLAG_NOT_SCANNED;
1873
1874 EplNmtMnuInstance_g.m_uiSignalSlaveCount++;
1875 // signal slave counter shall be decremented if StatusRequest was sent once to a CN
1876 // mandatory slave counter shall be decremented if mandatory CN is OPERATIONAL
1877 }
1878 }
1879
1880 // $$$ inform application if EPL_NMTST_NO_STARTNODE is set
1881
1882 if ((EplNmtMnuInstance_g.
1883 m_dwNmtStartup & EPL_NMTST_STARTALLNODES) != 0) {
1884 EPL_NMTMNU_DBG_POST_TRACE_VALUE(0, EPL_C_ADR_BROADCAST,
1885 kEplNmtCmdStartNode);
1886
1887 Ret =
1888 EplNmtMnuSendNmtCommand(EPL_C_ADR_BROADCAST,
1889 kEplNmtCmdStartNode);
1890 if (Ret != kEplSuccessful) {
1891 goto Exit;
1892 }
1893 }
1894 }
1895
1896 Exit:
1897 return Ret;
1898 }
1899
1900 //---------------------------------------------------------------------------
1901 //
1902 // Function: EplNmtMnuProcessInternalEvent
1903 //
1904 // Description: processes internal node events
1905 //
1906 // Parameters: uiNodeId_p = node ID
1907 // NodeNmtState_p = NMT state of CN
1908 // NodeEvent_p = occured events
1909 //
1910 // Returns: tEplKernel = error code
1911 //
1912 //
1913 // State:
1914 //
1915 //---------------------------------------------------------------------------
1916
1917 static tEplKernel EplNmtMnuProcessInternalEvent(unsigned int uiNodeId_p,
1918 tEplNmtState NodeNmtState_p,
1919 WORD wErrorCode_p,
1920 tEplNmtMnuIntNodeEvent
1921 NodeEvent_p)
1922 {
1923 tEplKernel Ret = kEplSuccessful;
1924 tEplNmtState NmtState;
1925 tEplNmtMnuNodeInfo *pNodeInfo;
1926 tEplTimerArg TimerArg;
1927
1928 pNodeInfo = EPL_NMTMNU_GET_NODEINFO(uiNodeId_p);
1929 NmtState = EplNmtuGetNmtState();
1930 if (NmtState <= kEplNmtMsNotActive) { // MN is not active
1931 goto Exit;
1932 }
1933
1934 switch (NodeEvent_p) {
1935 case kEplNmtMnuIntNodeEventIdentResponse:
1936 {
1937 BYTE bNmtState;
1938
1939 EPL_NMTMNU_DBG_POST_TRACE_VALUE(NodeEvent_p,
1940 uiNodeId_p,
1941 pNodeInfo->m_NodeState);
1942
1943 if (pNodeInfo->m_NodeState !=
1944 kEplNmtMnuNodeStateResetConf) {
1945 pNodeInfo->m_NodeState =
1946 kEplNmtMnuNodeStateIdentified;
1947 }
1948 // reset flags ISOCHRON and NMT_CMD_ISSUED
1949 pNodeInfo->m_wFlags &= ~(EPL_NMTMNU_NODE_FLAG_ISOCHRON
1950 |
1951 EPL_NMTMNU_NODE_FLAG_NMT_CMD_ISSUED);
1952
1953 if ((NmtState == kEplNmtMsPreOperational1)
1954 &&
1955 ((pNodeInfo->
1956 m_wFlags & EPL_NMTMNU_NODE_FLAG_NOT_SCANNED) !=
1957 0)) {
1958 // decrement only signal slave count
1959 EplNmtMnuInstance_g.m_uiSignalSlaveCount--;
1960 pNodeInfo->m_wFlags &=
1961 ~EPL_NMTMNU_NODE_FLAG_NOT_SCANNED;
1962 }
1963 // update object 0x1F8F NMT_MNNodeExpState_AU8 to PreOp1 (even if local state >= PreOp2)
1964 bNmtState = (BYTE) (kEplNmtCsPreOperational1 & 0xFF);
1965 Ret =
1966 EplObduWriteEntry(0x1F8F, uiNodeId_p, &bNmtState,
1967 1);
1968
1969 // check NMT state of CN
1970 Ret =
1971 EplNmtMnuCheckNmtState(uiNodeId_p, pNodeInfo,
1972 NodeNmtState_p, wErrorCode_p,
1973 NmtState);
1974 if (Ret != kEplSuccessful) {
1975 if (Ret == kEplReject) {
1976 Ret = kEplSuccessful;
1977 }
1978 break;
1979 }
1980 // request StatusResponse immediately,
1981 // because we want a fast boot-up of CNs
1982 Ret =
1983 EplStatusuRequestStatusResponse(uiNodeId_p,
1984 EplNmtMnuCbStatusResponse);
1985 if (Ret != kEplSuccessful) {
1986 EPL_NMTMNU_DBG_POST_TRACE_VALUE(NodeEvent_p,
1987 uiNodeId_p,
1988 Ret);
1989
1990 if (Ret == kEplInvalidOperation) { // the only situation when this should happen is, when
1991 // StatusResponse was already requested from within
1992 // the StatReq timer event.
1993 // so ignore this error.
1994 Ret = kEplSuccessful;
1995 } else {
1996 break;
1997 }
1998 }
1999
2000 if (pNodeInfo->m_NodeState !=
2001 kEplNmtMnuNodeStateResetConf) {
2002 // inform application
2003 Ret =
2004 EplNmtMnuInstance_g.
2005 m_pfnCbNodeEvent(uiNodeId_p,
2006 kEplNmtNodeEventFound,
2007 NodeNmtState_p,
2008 EPL_E_NO_ERROR,
2009 (pNodeInfo->
2010 m_dwNodeCfg &
2011 EPL_NODEASSIGN_MANDATORY_CN)
2012 != 0);
2013 if (Ret == kEplReject) { // interrupt boot process on user request
2014 EPL_NMTMNU_DBG_POST_TRACE_VALUE
2015 (NodeEvent_p, uiNodeId_p,
2016 ((pNodeInfo->m_NodeState << 8)
2017 | Ret));
2018
2019 Ret = kEplSuccessful;
2020 break;
2021 } else if (Ret != kEplSuccessful) {
2022 EPL_NMTMNU_DBG_POST_TRACE_VALUE
2023 (NodeEvent_p, uiNodeId_p,
2024 ((pNodeInfo->m_NodeState << 8)
2025 | Ret));
2026
2027 break;
2028 }
2029 }
2030 // continue BootStep1
2031 }
2032
2033 case kEplNmtMnuIntNodeEventBoot:
2034 {
2035
2036 // $$$ check identification (vendor ID, product code, revision no, serial no)
2037
2038 if (pNodeInfo->m_NodeState ==
2039 kEplNmtMnuNodeStateIdentified) {
2040 // $$$ check software
2041
2042 // check/start configuration
2043 // inform application
2044 Ret =
2045 EplNmtMnuInstance_g.
2046 m_pfnCbNodeEvent(uiNodeId_p,
2047 kEplNmtNodeEventCheckConf,
2048 NodeNmtState_p,
2049 EPL_E_NO_ERROR,
2050 (pNodeInfo->
2051 m_dwNodeCfg &
2052 EPL_NODEASSIGN_MANDATORY_CN)
2053 != 0);
2054 if (Ret == kEplReject) { // interrupt boot process on user request
2055 EPL_NMTMNU_DBG_POST_TRACE_VALUE
2056 (kEplNmtMnuIntNodeEventBoot,
2057 uiNodeId_p,
2058 ((pNodeInfo->m_NodeState << 8)
2059 | Ret));
2060
2061 Ret = kEplSuccessful;
2062 break;
2063 } else if (Ret != kEplSuccessful) {
2064 EPL_NMTMNU_DBG_POST_TRACE_VALUE
2065 (kEplNmtMnuIntNodeEventBoot,
2066 uiNodeId_p,
2067 ((pNodeInfo->m_NodeState << 8)
2068 | Ret));
2069
2070 break;
2071 }
2072 } else if (pNodeInfo->m_NodeState != kEplNmtMnuNodeStateResetConf) { // wrong CN state
2073 // ignore event
2074 break;
2075 }
2076 // $$$ d.k.: currently we assume configuration is OK
2077
2078 // continue BootStep1
2079 }
2080
2081 case kEplNmtMnuIntNodeEventConfigured:
2082 {
2083 if ((pNodeInfo->m_NodeState !=
2084 kEplNmtMnuNodeStateIdentified)
2085 && (pNodeInfo->m_NodeState != kEplNmtMnuNodeStateResetConf)) { // wrong CN state
2086 // ignore event
2087 break;
2088 }
2089
2090 pNodeInfo->m_NodeState = kEplNmtMnuNodeStateConfigured;
2091
2092 if (NmtState == kEplNmtMsPreOperational1) {
2093 if ((pNodeInfo->m_dwNodeCfg & EPL_NODEASSIGN_MANDATORY_CN) != 0) { // decrement mandatory CN counter
2094 EplNmtMnuInstance_g.
2095 m_uiMandatorySlaveCount--;
2096 }
2097 } else {
2098 // put optional node to next step (BootStep2)
2099 Ret =
2100 EplNmtMnuNodeBootStep2(uiNodeId_p,
2101 pNodeInfo);
2102 }
2103 break;
2104 }
2105
2106 case kEplNmtMnuIntNodeEventNoIdentResponse:
2107 {
2108 if ((NmtState == kEplNmtMsPreOperational1)
2109 &&
2110 ((pNodeInfo->
2111 m_wFlags & EPL_NMTMNU_NODE_FLAG_NOT_SCANNED) !=
2112 0)) {
2113 // decrement only signal slave count
2114 EplNmtMnuInstance_g.m_uiSignalSlaveCount--;
2115 pNodeInfo->m_wFlags &=
2116 ~EPL_NMTMNU_NODE_FLAG_NOT_SCANNED;
2117 }
2118
2119 if (pNodeInfo->m_NodeState !=
2120 kEplNmtMnuNodeStateResetConf) {
2121 pNodeInfo->m_NodeState =
2122 kEplNmtMnuNodeStateUnknown;
2123 }
2124 // $$$ d.k. check start time for 0x1F89/2 MNTimeoutPreOp1_U32
2125 // $$$ d.k. check individual timeout 0x1F89/6 MNIdentificationTimeout_U32
2126 // if mandatory node and timeout elapsed -> halt boot procedure
2127 // trigger IdentRequest again (if >= PreOp2, after delay)
2128 if (NmtState >= kEplNmtMsPreOperational2) { // start timer
2129 EPL_NMTMNU_SET_FLAGS_TIMERARG_IDENTREQ
2130 (pNodeInfo, uiNodeId_p, TimerArg);
2131 // TimerArg.m_EventSink = kEplEventSinkNmtMnu;
2132 // TimerArg.m_ulArg = EPL_NMTMNU_TIMERARG_IDENTREQ | uiNodeId_p;
2133 /*
2134 EPL_NMTMNU_DBG_POST_TRACE_VALUE(kEplNmtMnuIntNodeEventNoIdentResponse,
2135 uiNodeId_p,
2136 ((pNodeInfo->m_NodeState << 8)
2137 | 0x80
2138 | ((pNodeInfo->m_wFlags & EPL_NMTMNU_NODE_FLAG_COUNT_STATREQ) >> 6)
2139 | ((TimerArg.m_ulArg & EPL_NMTMNU_TIMERARG_COUNT_SR) >> 8)));
2140 */
2141 Ret =
2142 EplTimeruModifyTimerMs(&pNodeInfo->
2143 m_TimerHdlStatReq,
2144 EplNmtMnuInstance_g.
2145 m_ulStatusRequestDelay,
2146 TimerArg);
2147 } else { // trigger IdentRequest immediately
2148 Ret =
2149 EplIdentuRequestIdentResponse(uiNodeId_p,
2150 EplNmtMnuCbIdentResponse);
2151 }
2152 break;
2153 }
2154
2155 case kEplNmtMnuIntNodeEventStatusResponse:
2156 {
2157 if ((NmtState >= kEplNmtMsPreOperational2)
2158 &&
2159 ((pNodeInfo->
2160 m_wFlags & EPL_NMTMNU_NODE_FLAG_NOT_SCANNED) !=
2161 0)) {
2162 // decrement only signal slave count if checked once for ReadyToOp, CheckCom, Operational
2163 EplNmtMnuInstance_g.m_uiSignalSlaveCount--;
2164 pNodeInfo->m_wFlags &=
2165 ~EPL_NMTMNU_NODE_FLAG_NOT_SCANNED;
2166 }
2167 // check NMT state of CN
2168 Ret =
2169 EplNmtMnuCheckNmtState(uiNodeId_p, pNodeInfo,
2170 NodeNmtState_p, wErrorCode_p,
2171 NmtState);
2172 if (Ret != kEplSuccessful) {
2173 if (Ret == kEplReject) {
2174 Ret = kEplSuccessful;
2175 }
2176 break;
2177 }
2178
2179 if (NmtState == kEplNmtMsPreOperational1) {
2180 // request next StatusResponse immediately
2181 Ret =
2182 EplStatusuRequestStatusResponse(uiNodeId_p,
2183 EplNmtMnuCbStatusResponse);
2184 if (Ret != kEplSuccessful) {
2185 EPL_NMTMNU_DBG_POST_TRACE_VALUE
2186 (NodeEvent_p, uiNodeId_p, Ret);
2187 }
2188
2189 } else if ((pNodeInfo->m_wFlags & EPL_NMTMNU_NODE_FLAG_ISOCHRON) == 0) { // start timer
2190 // not isochronously accessed CN (e.g. async-only or stopped CN)
2191 EPL_NMTMNU_SET_FLAGS_TIMERARG_STATREQ(pNodeInfo,
2192 uiNodeId_p,
2193 TimerArg);
2194 // TimerArg.m_EventSink = kEplEventSinkNmtMnu;
2195 // TimerArg.m_ulArg = EPL_NMTMNU_TIMERARG_STATREQ | uiNodeId_p;
2196 /*
2197 EPL_NMTMNU_DBG_POST_TRACE_VALUE(kEplNmtMnuIntNodeEventStatusResponse,
2198 uiNodeId_p,
2199 ((pNodeInfo->m_NodeState << 8)
2200 | 0x80
2201 | ((pNodeInfo->m_wFlags & EPL_NMTMNU_NODE_FLAG_COUNT_STATREQ) >> 6)
2202 | ((TimerArg.m_ulArg & EPL_NMTMNU_TIMERARG_COUNT_SR) >> 8)));
2203 */
2204 Ret =
2205 EplTimeruModifyTimerMs(&pNodeInfo->
2206 m_TimerHdlStatReq,
2207 EplNmtMnuInstance_g.
2208 m_ulStatusRequestDelay,
2209 TimerArg);
2210 }
2211
2212 break;
2213 }
2214
2215 case kEplNmtMnuIntNodeEventNoStatusResponse:
2216 {
2217 // function CheckNmtState sets node state to unknown if necessary
2218 /*
2219 if ((NmtState >= kEplNmtMsPreOperational2)
2220 && ((pNodeInfo->m_wFlags & EPL_NMTMNU_NODE_FLAG_NOT_SCANNED) != 0))
2221 {
2222 // decrement only signal slave count if checked once for ReadyToOp, CheckCom, Operational
2223 EplNmtMnuInstance_g.m_uiSignalSlaveCount--;
2224 pNodeInfo->m_wFlags &= ~EPL_NMTMNU_NODE_FLAG_NOT_SCANNED;
2225 }
2226 */
2227 // check NMT state of CN
2228 Ret =
2229 EplNmtMnuCheckNmtState(uiNodeId_p, pNodeInfo,
2230 NodeNmtState_p, wErrorCode_p,
2231 NmtState);
2232 if (Ret != kEplSuccessful) {
2233 if (Ret == kEplReject) {
2234 Ret = kEplSuccessful;
2235 }
2236 break;
2237 }
2238
2239 break;
2240 }
2241
2242 case kEplNmtMnuIntNodeEventError:
2243 { // currently only issued on kEplNmtNodeCommandConfErr
2244
2245 if (pNodeInfo->m_NodeState != kEplNmtMnuNodeStateIdentified) { // wrong CN state
2246 // ignore event
2247 break;
2248 }
2249 // check NMT state of CN
2250 Ret =
2251 EplNmtMnuCheckNmtState(uiNodeId_p, pNodeInfo,
2252 kEplNmtCsNotActive,
2253 wErrorCode_p, NmtState);
2254 if (Ret != kEplSuccessful) {
2255 if (Ret == kEplReject) {
2256 Ret = kEplSuccessful;
2257 }
2258 break;
2259 }
2260
2261 break;
2262 }
2263
2264 case kEplNmtMnuIntNodeEventExecReset:
2265 {
2266 if (pNodeInfo->m_NodeState != kEplNmtMnuNodeStateIdentified) { // wrong CN state
2267 // ignore event
2268 break;
2269 }
2270
2271 pNodeInfo->m_NodeState = kEplNmtMnuNodeStateResetConf;
2272
2273 EPL_NMTMNU_DBG_POST_TRACE_VALUE(NodeEvent_p,
2274 uiNodeId_p,
2275 (((NodeNmtState_p &
2276 0xFF) << 8)
2277 |
2278 kEplNmtCmdResetConfiguration));
2279
2280 // send NMT reset configuration to CN for activation of configuration
2281 Ret =
2282 EplNmtMnuSendNmtCommand(uiNodeId_p,
2283 kEplNmtCmdResetConfiguration);
2284
2285 break;
2286 }
2287
2288 case kEplNmtMnuIntNodeEventHeartbeat:
2289 {
2290 /*
2291 if ((NmtState >= kEplNmtMsPreOperational2)
2292 && ((pNodeInfo->m_wFlags & EPL_NMTMNU_NODE_FLAG_NOT_SCANNED) != 0))
2293 {
2294 // decrement only signal slave count if checked once for ReadyToOp, CheckCom, Operational
2295 EplNmtMnuInstance_g.m_uiSignalSlaveCount--;
2296 pNodeInfo->m_wFlags &= ~EPL_NMTMNU_NODE_FLAG_NOT_SCANNED;
2297 }
2298 */
2299 // check NMT state of CN
2300 Ret =
2301 EplNmtMnuCheckNmtState(uiNodeId_p, pNodeInfo,
2302 NodeNmtState_p, wErrorCode_p,
2303 NmtState);
2304 if (Ret != kEplSuccessful) {
2305 if (Ret == kEplReject) {
2306 Ret = kEplSuccessful;
2307 }
2308 break;
2309 }
2310
2311 break;
2312 }
2313
2314 case kEplNmtMnuIntNodeEventTimerIdentReq:
2315 {
2316 EPL_DBGLVL_NMTMN_TRACE1
2317 ("TimerStatReq->IdentReq(%02X)\n", uiNodeId_p);
2318 // trigger IdentRequest again
2319 Ret =
2320 EplIdentuRequestIdentResponse(uiNodeId_p,
2321 EplNmtMnuCbIdentResponse);
2322 if (Ret != kEplSuccessful) {
2323 EPL_NMTMNU_DBG_POST_TRACE_VALUE(NodeEvent_p,
2324 uiNodeId_p,
2325 (((NodeNmtState_p & 0xFF) << 8)
2326 | Ret));
2327 if (Ret == kEplInvalidOperation) { // this can happen because of a bug in EplTimeruLinuxKernel.c
2328 // so ignore this error.
2329 Ret = kEplSuccessful;
2330 }
2331 }
2332
2333 break;
2334 }
2335
2336 case kEplNmtMnuIntNodeEventTimerStateMon:
2337 {
2338 // reset NMT state change flag
2339 // because from now on the CN must have the correct NMT state
2340 pNodeInfo->m_wFlags &=
2341 ~EPL_NMTMNU_NODE_FLAG_NMT_CMD_ISSUED;
2342
2343 // continue with normal StatReq processing
2344 }
2345
2346 case kEplNmtMnuIntNodeEventTimerStatReq:
2347 {
2348 EPL_DBGLVL_NMTMN_TRACE1("TimerStatReq->StatReq(%02X)\n",
2349 uiNodeId_p);
2350 // request next StatusResponse
2351 Ret =
2352 EplStatusuRequestStatusResponse(uiNodeId_p,
2353 EplNmtMnuCbStatusResponse);
2354 if (Ret != kEplSuccessful) {
2355 EPL_NMTMNU_DBG_POST_TRACE_VALUE(NodeEvent_p,
2356 uiNodeId_p,
2357 (((NodeNmtState_p & 0xFF) << 8)
2358 | Ret));
2359 if (Ret == kEplInvalidOperation) { // the only situation when this should happen is, when
2360 // StatusResponse was already requested while processing
2361 // event IdentResponse.
2362 // so ignore this error.
2363 Ret = kEplSuccessful;
2364 }
2365 }
2366
2367 break;
2368 }
2369
2370 case kEplNmtMnuIntNodeEventTimerLonger:
2371 {
2372 switch (pNodeInfo->m_NodeState) {
2373 case kEplNmtMnuNodeStateConfigured:
2374 { // node should be ReadyToOp but it is not
2375
2376 // check NMT state which shall be intentionally wrong, so that ERROR_TREATMENT will be started
2377 Ret =
2378 EplNmtMnuCheckNmtState(uiNodeId_p,
2379 pNodeInfo,
2380 kEplNmtCsNotActive,
2381 EPL_E_NMT_BPO2,
2382 NmtState);
2383 if (Ret != kEplSuccessful) {
2384 if (Ret == kEplReject) {
2385 Ret = kEplSuccessful;
2386 }
2387 break;
2388 }
2389
2390 break;
2391 }
2392
2393 case kEplNmtMnuNodeStateReadyToOp:
2394 { // CheckCom finished successfully
2395
2396 pNodeInfo->m_NodeState =
2397 kEplNmtMnuNodeStateComChecked;
2398
2399 if ((pNodeInfo->
2400 m_wFlags &
2401 EPL_NMTMNU_NODE_FLAG_NOT_SCANNED)
2402 != 0) {
2403 // decrement only signal slave count if checked once for ReadyToOp, CheckCom, Operational
2404 EplNmtMnuInstance_g.
2405 m_uiSignalSlaveCount--;
2406 pNodeInfo->m_wFlags &=
2407 ~EPL_NMTMNU_NODE_FLAG_NOT_SCANNED;
2408 }
2409
2410 if ((pNodeInfo->
2411 m_dwNodeCfg &
2412 EPL_NODEASSIGN_MANDATORY_CN) !=
2413 0) {
2414 // decrement mandatory slave counter
2415 EplNmtMnuInstance_g.
2416 m_uiMandatorySlaveCount--;
2417 }
2418 if (NmtState != kEplNmtMsReadyToOperate) {
2419 EPL_NMTMNU_DBG_POST_TRACE_VALUE
2420 (NodeEvent_p, uiNodeId_p,
2421 (((NodeNmtState_p & 0xFF)
2422 << 8)
2423 | kEplNmtCmdStartNode));
2424
2425 // start optional CN
2426 Ret =
2427 EplNmtMnuSendNmtCommand
2428 (uiNodeId_p,
2429 kEplNmtCmdStartNode);
2430 }
2431 break;
2432 }
2433
2434 default:
2435 {
2436 break;
2437 }
2438 }
2439 break;
2440 }
2441
2442 case kEplNmtMnuIntNodeEventNmtCmdSent:
2443 {
2444 BYTE bNmtState;
2445
2446 // update expected NMT state with the one that results
2447 // from the sent NMT command
2448 bNmtState = (BYTE) (NodeNmtState_p & 0xFF);
2449
2450 // write object 0x1F8F NMT_MNNodeExpState_AU8
2451 Ret =
2452 EplObduWriteEntry(0x1F8F, uiNodeId_p, &bNmtState,
2453 1);
2454 if (Ret != kEplSuccessful) {
2455 goto Exit;
2456 }
2457
2458 if (NodeNmtState_p == kEplNmtCsNotActive) { // restart processing with IdentRequest
2459 EPL_NMTMNU_SET_FLAGS_TIMERARG_IDENTREQ
2460 (pNodeInfo, uiNodeId_p, TimerArg);
2461 } else { // monitor NMT state change with StatusRequest after
2462 // the corresponding delay;
2463 // until then wrong NMT states will be ignored
2464 EPL_NMTMNU_SET_FLAGS_TIMERARG_STATE_MON
2465 (pNodeInfo, uiNodeId_p, TimerArg);
2466
2467 // set NMT state change flag
2468 pNodeInfo->m_wFlags |=
2469 EPL_NMTMNU_NODE_FLAG_NMT_CMD_ISSUED;
2470 }
2471
2472 Ret =
2473 EplTimeruModifyTimerMs(&pNodeInfo->
2474 m_TimerHdlStatReq,
2475 EplNmtMnuInstance_g.
2476 m_ulStatusRequestDelay,
2477 TimerArg);
2478
2479 // finish processing, because NmtState_p is the expected and not the current state
2480 goto Exit;
2481 }
2482
2483 default:
2484 {
2485 break;
2486 }
2487 }
2488
2489 // check if network is ready to change local NMT state and this was not done before
2490 if ((EplNmtMnuInstance_g.m_wFlags & (EPL_NMTMNU_FLAG_HALTED | EPL_NMTMNU_FLAG_APP_INFORMED)) == 0) { // boot process is not halted
2491 switch (NmtState) {
2492 case kEplNmtMsPreOperational1:
2493 {
2494 if ((EplNmtMnuInstance_g.m_uiSignalSlaveCount ==
2495 0)
2496 && (EplNmtMnuInstance_g.m_uiMandatorySlaveCount == 0)) { // all optional CNs scanned once and all mandatory CNs configured successfully
2497 EplNmtMnuInstance_g.m_wFlags |=
2498 EPL_NMTMNU_FLAG_APP_INFORMED;
2499 // inform application
2500 Ret =
2501 EplNmtMnuInstance_g.
2502 m_pfnCbBootEvent
2503 (kEplNmtBootEventBootStep1Finish,
2504 NmtState, EPL_E_NO_ERROR);
2505 if (Ret != kEplSuccessful) {
2506 if (Ret == kEplReject) {
2507 // wait for application
2508 Ret = kEplSuccessful;
2509 }
2510 break;
2511 }
2512 // enter PreOp2
2513 Ret =
2514 EplNmtuNmtEvent
2515 (kEplNmtEventAllMandatoryCNIdent);
2516 }
2517 break;
2518 }
2519
2520 case kEplNmtMsPreOperational2:
2521 {
2522 if ((EplNmtMnuInstance_g.m_uiSignalSlaveCount ==
2523 0)
2524 && (EplNmtMnuInstance_g.m_uiMandatorySlaveCount == 0)) { // all optional CNs checked once for ReadyToOp and all mandatory CNs are ReadyToOp
2525 EplNmtMnuInstance_g.m_wFlags |=
2526 EPL_NMTMNU_FLAG_APP_INFORMED;
2527 // inform application
2528 Ret =
2529 EplNmtMnuInstance_g.
2530 m_pfnCbBootEvent
2531 (kEplNmtBootEventBootStep2Finish,
2532 NmtState, EPL_E_NO_ERROR);
2533 if (Ret != kEplSuccessful) {
2534 if (Ret == kEplReject) {
2535 // wait for application
2536 Ret = kEplSuccessful;
2537 }
2538 break;
2539 }
2540 // enter ReadyToOp
2541 Ret =
2542 EplNmtuNmtEvent
2543 (kEplNmtEventEnterReadyToOperate);
2544 }
2545 break;
2546 }
2547
2548 case kEplNmtMsReadyToOperate:
2549 {
2550 if ((EplNmtMnuInstance_g.m_uiSignalSlaveCount ==
2551 0)
2552 && (EplNmtMnuInstance_g.m_uiMandatorySlaveCount == 0)) { // all CNs checked for errorless communication
2553 EplNmtMnuInstance_g.m_wFlags |=
2554 EPL_NMTMNU_FLAG_APP_INFORMED;
2555 // inform application
2556 Ret =
2557 EplNmtMnuInstance_g.
2558 m_pfnCbBootEvent
2559 (kEplNmtBootEventCheckComFinish,
2560 NmtState, EPL_E_NO_ERROR);
2561 if (Ret != kEplSuccessful) {
2562 if (Ret == kEplReject) {
2563 // wait for application
2564 Ret = kEplSuccessful;
2565 }
2566 break;
2567 }
2568 // enter Operational
2569 Ret =
2570 EplNmtuNmtEvent
2571 (kEplNmtEventEnterMsOperational);
2572 }
2573 break;
2574 }
2575
2576 case kEplNmtMsOperational:
2577 {
2578 if ((EplNmtMnuInstance_g.m_uiSignalSlaveCount ==
2579 0)
2580 && (EplNmtMnuInstance_g.m_uiMandatorySlaveCount == 0)) { // all optional CNs scanned once and all mandatory CNs are OPERATIONAL
2581 EplNmtMnuInstance_g.m_wFlags |=
2582 EPL_NMTMNU_FLAG_APP_INFORMED;
2583 // inform application
2584 Ret =
2585 EplNmtMnuInstance_g.
2586 m_pfnCbBootEvent
2587 (kEplNmtBootEventOperational,
2588 NmtState, EPL_E_NO_ERROR);
2589 if (Ret != kEplSuccessful) {
2590 if (Ret == kEplReject) {
2591 // ignore error code
2592 Ret = kEplSuccessful;
2593 }
2594 break;
2595 }
2596 }
2597 break;
2598 }
2599
2600 default:
2601 {
2602 break;
2603 }
2604 }
2605 }
2606
2607 Exit:
2608 return Ret;
2609 }
2610
2611 //---------------------------------------------------------------------------
2612 //
2613 // Function: EplNmtMnuCheckNmtState
2614 //
2615 // Description: checks the NMT state, i.e. evaluates it with object 0x1F8F
2616 // NMT_MNNodeExpState_AU8 and updates object 0x1F8E
2617 // NMT_MNNodeCurrState_AU8.
2618 // It manipulates m_NodeState in internal node info structure.
2619 //
2620 // Parameters: uiNodeId_p = node ID
2621 // NodeNmtState_p = NMT state of CN
2622 //
2623 // Returns: tEplKernel = error code
2624 // kEplReject = CN was in wrong state and has been reset
2625 //
2626 // State:
2627 //
2628 //---------------------------------------------------------------------------
2629
2630 static tEplKernel EplNmtMnuCheckNmtState(unsigned int uiNodeId_p,
2631 tEplNmtMnuNodeInfo * pNodeInfo_p,
2632 tEplNmtState NodeNmtState_p,
2633 WORD wErrorCode_p,
2634 tEplNmtState LocalNmtState_p)
2635 {
2636 tEplKernel Ret = kEplSuccessful;
2637 tEplObdSize ObdSize;
2638 BYTE bNmtState;
2639 BYTE bNmtStatePrev;
2640 tEplNmtState ExpNmtState;
2641
2642 ObdSize = 1;
2643 // read object 0x1F8F NMT_MNNodeExpState_AU8
2644 Ret = EplObduReadEntry(0x1F8F, uiNodeId_p, &bNmtState, &ObdSize);
2645 if (Ret != kEplSuccessful) {
2646 goto Exit;
2647 }
2648 // compute expected NMT state
2649 ExpNmtState = (tEplNmtState) (bNmtState | EPL_NMT_TYPE_CS);
2650 // compute BYTE of current NMT state
2651 bNmtState = ((BYTE) NodeNmtState_p & 0xFF);
2652
2653 if (ExpNmtState == kEplNmtCsNotActive) { // ignore the current state, because the CN shall be not active
2654 Ret = kEplReject;
2655 goto Exit;
2656 } else if ((ExpNmtState == kEplNmtCsPreOperational2)
2657 && (NodeNmtState_p == kEplNmtCsReadyToOperate)) { // CN switched to ReadyToOp
2658 // delete timer for timeout handling
2659 Ret = EplTimeruDeleteTimer(&pNodeInfo_p->m_TimerHdlLonger);
2660 if (Ret != kEplSuccessful) {
2661 goto Exit;
2662 }
2663 pNodeInfo_p->m_NodeState = kEplNmtMnuNodeStateReadyToOp;
2664
2665 // update object 0x1F8F NMT_MNNodeExpState_AU8 to ReadyToOp
2666 Ret = EplObduWriteEntry(0x1F8F, uiNodeId_p, &bNmtState, 1);
2667 if (Ret != kEplSuccessful) {
2668 goto Exit;
2669 }
2670
2671 if ((pNodeInfo_p->m_dwNodeCfg & EPL_NODEASSIGN_MANDATORY_CN) != 0) { // node is a mandatory CN -> decrement counter
2672 EplNmtMnuInstance_g.m_uiMandatorySlaveCount--;
2673 }
2674 if (LocalNmtState_p >= kEplNmtMsReadyToOperate) { // start procedure CheckCommunication for this node
2675 Ret = EplNmtMnuNodeCheckCom(uiNodeId_p, pNodeInfo_p);
2676 if (Ret != kEplSuccessful) {
2677 goto Exit;
2678 }
2679
2680 if ((LocalNmtState_p == kEplNmtMsOperational)
2681 && (pNodeInfo_p->m_NodeState ==
2682 kEplNmtMnuNodeStateComChecked)) {
2683 EPL_NMTMNU_DBG_POST_TRACE_VALUE(0, uiNodeId_p,
2684 (((NodeNmtState_p & 0xFF) << 8)
2685 |
2686 kEplNmtCmdStartNode));
2687
2688 // immediately start optional CN, because communication is always OK (e.g. async-only CN)
2689 Ret =
2690 EplNmtMnuSendNmtCommand(uiNodeId_p,
2691 kEplNmtCmdStartNode);
2692 if (Ret != kEplSuccessful) {
2693 goto Exit;
2694 }
2695 }
2696 }
2697
2698 } else if ((ExpNmtState == kEplNmtCsReadyToOperate)
2699 && (NodeNmtState_p == kEplNmtCsOperational)) { // CN switched to OPERATIONAL
2700 pNodeInfo_p->m_NodeState = kEplNmtMnuNodeStateOperational;
2701
2702 if ((pNodeInfo_p->m_dwNodeCfg & EPL_NODEASSIGN_MANDATORY_CN) != 0) { // node is a mandatory CN -> decrement counter
2703 EplNmtMnuInstance_g.m_uiMandatorySlaveCount--;
2704 }
2705
2706 } else if ((ExpNmtState != NodeNmtState_p)
2707 && !((ExpNmtState == kEplNmtCsPreOperational1)
2708 && (NodeNmtState_p == kEplNmtCsPreOperational2))) { // CN is not in expected NMT state (without the exceptions above)
2709 WORD wbeErrorCode;
2710
2711 if ((pNodeInfo_p->
2712 m_wFlags & EPL_NMTMNU_NODE_FLAG_NOT_SCANNED) != 0) {
2713 // decrement only signal slave count if checked once
2714 EplNmtMnuInstance_g.m_uiSignalSlaveCount--;
2715 pNodeInfo_p->m_wFlags &=
2716 ~EPL_NMTMNU_NODE_FLAG_NOT_SCANNED;
2717 }
2718
2719 if (pNodeInfo_p->m_NodeState == kEplNmtMnuNodeStateUnknown) { // CN is already in state unknown, which means that it got
2720 // NMT reset command earlier
2721 goto Exit;
2722 }
2723 // -> CN is in wrong NMT state
2724 pNodeInfo_p->m_NodeState = kEplNmtMnuNodeStateUnknown;
2725
2726 if (wErrorCode_p == 0) { // assume wrong NMT state error
2727 if ((pNodeInfo_p->m_wFlags & EPL_NMTMNU_NODE_FLAG_NMT_CMD_ISSUED) != 0) { // NMT command has been just issued;
2728 // ignore wrong NMT state until timer expires;
2729 // other errors like LOSS_PRES_TH are still processed
2730 goto Exit;
2731 }
2732
2733 wErrorCode_p = EPL_E_NMT_WRONG_STATE;
2734 }
2735
2736 BENCHMARK_MOD_07_TOGGLE(9);
2737
2738 // $$$ start ERROR_TREATMENT and inform application
2739 Ret = EplNmtMnuInstance_g.m_pfnCbNodeEvent(uiNodeId_p,
2740 kEplNmtNodeEventError,
2741 NodeNmtState_p,
2742 wErrorCode_p,
2743 (pNodeInfo_p->
2744 m_dwNodeCfg &
2745 EPL_NODEASSIGN_MANDATORY_CN)
2746 != 0);
2747 if (Ret != kEplSuccessful) {
2748 goto Exit;
2749 }
2750
2751 EPL_NMTMNU_DBG_POST_TRACE_VALUE(0,
2752 uiNodeId_p,
2753 (((NodeNmtState_p & 0xFF) << 8)
2754 | kEplNmtCmdResetNode));
2755
2756 // reset CN
2757 // store error code in NMT command data for diagnostic purpose
2758 AmiSetWordToLe(&wbeErrorCode, wErrorCode_p);
2759 Ret =
2760 EplNmtMnuSendNmtCommandEx(uiNodeId_p, kEplNmtCmdResetNode,
2761 &wbeErrorCode,
2762 sizeof(wbeErrorCode));
2763 if (Ret == kEplSuccessful) {
2764 Ret = kEplReject;
2765 }
2766
2767 goto Exit;
2768 }
2769 // check if NMT_MNNodeCurrState_AU8 has to be changed
2770 ObdSize = 1;
2771 Ret = EplObduReadEntry(0x1F8E, uiNodeId_p, &bNmtStatePrev, &ObdSize);
2772 if (Ret != kEplSuccessful) {
2773 goto Exit;
2774 }
2775 if (bNmtState != bNmtStatePrev) {
2776 // update object 0x1F8E NMT_MNNodeCurrState_AU8
2777 Ret = EplObduWriteEntry(0x1F8E, uiNodeId_p, &bNmtState, 1);
2778 if (Ret != kEplSuccessful) {
2779 goto Exit;
2780 }
2781 Ret = EplNmtMnuInstance_g.m_pfnCbNodeEvent(uiNodeId_p,
2782 kEplNmtNodeEventNmtState,
2783 NodeNmtState_p,
2784 wErrorCode_p,
2785 (pNodeInfo_p->
2786 m_dwNodeCfg &
2787 EPL_NODEASSIGN_MANDATORY_CN)
2788 != 0);
2789 if (Ret != kEplSuccessful) {
2790 goto Exit;
2791 }
2792 }
2793
2794 Exit:
2795 return Ret;
2796 }
2797
2798 //---------------------------------------------------------------------------
2799 //
2800 // Function: EplNmtMnuReset
2801 //
2802 // Description: reset internal structures, e.g. timers
2803 //
2804 // Parameters: void
2805 //
2806 // Returns: tEplKernel = error code
2807 //
2808 // State:
2809 //
2810 //---------------------------------------------------------------------------
2811
2812 static tEplKernel EplNmtMnuReset(void)
2813 {
2814 tEplKernel Ret;
2815 int iIndex;
2816
2817 Ret = EplTimeruDeleteTimer(&EplNmtMnuInstance_g.m_TimerHdlNmtState);
2818
2819 for (iIndex = 1; iIndex <= tabentries(EplNmtMnuInstance_g.m_aNodeInfo);
2820 iIndex++) {
2821 // delete timer handles
2822 Ret =
2823 EplTimeruDeleteTimer(&EPL_NMTMNU_GET_NODEINFO(iIndex)->
2824 m_TimerHdlStatReq);
2825 Ret =
2826 EplTimeruDeleteTimer(&EPL_NMTMNU_GET_NODEINFO(iIndex)->
2827 m_TimerHdlLonger);
2828 }
2829
2830 return Ret;
2831 }
2832
2833 #endif // #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
2834
2835 // EOF
Nao low-level kernelspace/userspace library that runs on our robots, Nao-Team HTWK