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-Userspace-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: EplNmtu.c,v $
53
54 $Author: D.Krueger $
55
56 $Revision: 1.8 $ $Date: 2008/11/10 17:17:42 $
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 "EplInc.h"
72 #include "user/EplNmtu.h"
73 #include "user/EplObdu.h"
74 #include "user/EplTimeru.h"
75 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMTK)) != 0)
76 #include "kernel/EplNmtk.h"
77 #endif
78
79 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMTU)) != 0)
80 /***************************************************************************/
81 /* */
82 /* */
83 /* G L O B A L D E F I N I T I O N S */
84 /* */
85 /* */
86 /***************************************************************************/
87
88 //---------------------------------------------------------------------------
89 // const defines
90 //---------------------------------------------------------------------------
91
92 //---------------------------------------------------------------------------
93 // local types
94 //---------------------------------------------------------------------------
95
96 typedef struct {
97 tEplNmtuStateChangeCallback m_pfnNmtChangeCb;
98 tEplTimerHdl m_TimerHdl;
99
100 } tEplNmtuInstance;
101
102 //---------------------------------------------------------------------------
103 // modul globale vars
104 //---------------------------------------------------------------------------
105
106 static tEplNmtuInstance EplNmtuInstance_g;
107
108 //---------------------------------------------------------------------------
109 // local function prototypes
110 //---------------------------------------------------------------------------
111
112 //=========================================================================//
113 // //
114 // P U B L I C F U N C T I O N S //
115 // //
116 //=========================================================================//
117
118 //---------------------------------------------------------------------------
119 //
120 // Function: EplNmtuInit
121 //
122 // Description: init first instance of the module
123 //
124 //
125 //
126 // Parameters:
127 //
128 //
129 // Returns: tEplKernel = errorcode
130 //
131 //
132 // State:
133 //
134 //---------------------------------------------------------------------------
135 tEplKernel EplNmtuInit(void)
136 {
137 tEplKernel Ret;
138
139 Ret = EplNmtuAddInstance();
140
141 return Ret;
142 }
143
144 //---------------------------------------------------------------------------
145 //
146 // Function: EplNmtuAddInstance
147 //
148 // Description: init other instances of the module
149 //
150 //
151 //
152 // Parameters:
153 //
154 //
155 // Returns: tEplKernel = errorcode
156 //
157 //
158 // State:
159 //
160 //---------------------------------------------------------------------------
161 tEplKernel EplNmtuAddInstance(void)
162 {
163 tEplKernel Ret;
164
165 Ret = kEplSuccessful;
166
167 EplNmtuInstance_g.m_pfnNmtChangeCb = NULL;
168
169 return Ret;
170
171 }
172
173 //---------------------------------------------------------------------------
174 //
175 // Function: EplNmtuDelInstance
176 //
177 // Description: delete instance
178 //
179 //
180 //
181 // Parameters:
182 //
183 //
184 // Returns: tEplKernel = errorcode
185 //
186 //
187 // State:
188 //
189 //---------------------------------------------------------------------------
190 tEplKernel EplNmtuDelInstance(void)
191 {
192 tEplKernel Ret;
193
194 Ret = kEplSuccessful;
195
196 EplNmtuInstance_g.m_pfnNmtChangeCb = NULL;
197
198 // delete timer
199 Ret = EplTimeruDeleteTimer(&EplNmtuInstance_g.m_TimerHdl);
200
201 return Ret;
202
203 }
204
205 //---------------------------------------------------------------------------
206 //
207 // Function: EplNmtuNmtEvent
208 //
209 // Description: sends the NMT-Event to the NMT-State-Maschine
210 //
211 //
212 //
213 // Parameters: NmtEvent_p = NMT-Event to send
214 //
215 //
216 // Returns: tEplKernel = errorcode
217 //
218 //
219 // State:
220 //
221 //---------------------------------------------------------------------------
222 tEplKernel EplNmtuNmtEvent(tEplNmtEvent NmtEvent_p)
223 {
224 tEplKernel Ret;
225 tEplEvent Event;
226
227 Event.m_EventSink = kEplEventSinkNmtk;
228 Event.m_NetTime.m_dwNanoSec = 0;
229 Event.m_NetTime.m_dwSec = 0;
230 Event.m_EventType = kEplEventTypeNmtEvent;
231 Event.m_pArg = &NmtEvent_p;
232 Event.m_uiSize = sizeof(NmtEvent_p);
233
234 Ret = EplEventuPost(&Event);
235
236 return Ret;
237 }
238
239 //---------------------------------------------------------------------------
240 //
241 // Function: EplNmtuGetNmtState
242 //
243 // Description: returns the actuell NMT-State
244 //
245 //
246 //
247 // Parameters:
248 //
249 //
250 // Returns: tEplNmtState = NMT-State
251 //
252 //
253 // State:
254 //
255 //---------------------------------------------------------------------------
256 tEplNmtState EplNmtuGetNmtState(void)
257 {
258 tEplNmtState NmtState;
259
260 // $$$ call function of communication abstraction layer
261 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMTK)) != 0)
262 NmtState = EplNmtkGetNmtState();
263 #else
264 NmtState = 0;
265 #endif
266
267 return NmtState;
268 }
269
270 //---------------------------------------------------------------------------
271 //
272 // Function: EplNmtuProcessEvent
273 //
274 // Description: processes events from event queue
275 //
276 //
277 //
278 // Parameters: pEplEvent_p = pointer to event
279 //
280 //
281 // Returns: tEplKernel = errorcode
282 //
283 //
284 // State:
285 //
286 //---------------------------------------------------------------------------
287 tEplKernel EplNmtuProcessEvent(tEplEvent *pEplEvent_p)
288 {
289 tEplKernel Ret;
290
291 Ret = kEplSuccessful;
292
293 // process event
294 switch (pEplEvent_p->m_EventType) {
295 // state change of NMT-Module
296 case kEplEventTypeNmtStateChange:
297 {
298 tEplEventNmtStateChange *pNmtStateChange;
299
300 // delete timer
301 Ret =
302 EplTimeruDeleteTimer(&EplNmtuInstance_g.m_TimerHdl);
303
304 pNmtStateChange =
305 (tEplEventNmtStateChange *) pEplEvent_p->m_pArg;
306
307 // call cb-functions to inform higher layer
308 if (EplNmtuInstance_g.m_pfnNmtChangeCb != NULL) {
309 Ret =
310 EplNmtuInstance_g.
311 m_pfnNmtChangeCb(*pNmtStateChange);
312 }
313
314 if (Ret == kEplSuccessful) { // everything is OK, so switch to next state if necessary
315 switch (pNmtStateChange->m_NewNmtState) {
316 // EPL stack is not running
317 case kEplNmtGsOff:
318 break;
319
320 // first init of the hardware
321 case kEplNmtGsInitialising:
322 {
323 Ret =
324 EplNmtuNmtEvent
325 (kEplNmtEventEnterResetApp);
326 break;
327 }
328
329 // init of the manufacturer-specific profile area and the
330 // standardised device profile area
331 case kEplNmtGsResetApplication:
332 {
333 Ret =
334 EplNmtuNmtEvent
335 (kEplNmtEventEnterResetCom);
336 break;
337 }
338
339 // init of the communication profile area
340 case kEplNmtGsResetCommunication:
341 {
342 Ret =
343 EplNmtuNmtEvent
344 (kEplNmtEventEnterResetConfig);
345 break;
346 }
347
348 // build the configuration with infos from OD
349 case kEplNmtGsResetConfiguration:
350 {
351 unsigned int uiNodeId;
352
353 // get node ID from OD
354 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDU)) != 0) || (EPL_OBD_USE_KERNEL != FALSE)
355 uiNodeId =
356 EplObduGetNodeId
357 (EPL_MCO_PTR_INSTANCE_PTR);
358 #else
359 uiNodeId = 0;
360 #endif
361 //check node ID if not should be master or slave
362 if (uiNodeId == EPL_C_ADR_MN_DEF_NODE_ID) { // node shall be MN
363 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
364 Ret =
365 EplNmtuNmtEvent
366 (kEplNmtEventEnterMsNotActive);
367 #else
368 TRACE0
369 ("EplNmtuProcess(): no MN functionality implemented\n");
370 #endif
371 } else { // node shall be CN
372 Ret =
373 EplNmtuNmtEvent
374 (kEplNmtEventEnterCsNotActive);
375 }
376 break;
377 }
378
379 //-----------------------------------------------------------
380 // CN part of the state machine
381
382 // node listens for EPL-Frames and check timeout
383 case kEplNmtCsNotActive:
384 {
385 u32 dwBuffer;
386 tEplObdSize ObdSize;
387 tEplTimerArg TimerArg;
388
389 // create timer to switch automatically to BasicEthernet if no MN available in network
390
391 // read NMT_CNBasicEthernetTimerout_U32 from OD
392 ObdSize = sizeof(dwBuffer);
393 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDU)) != 0) || (EPL_OBD_USE_KERNEL != FALSE)
394 Ret =
395 EplObduReadEntry
396 (EPL_MCO_PTR_INSTANCE_PTR_
397 0x1F99, 0x00, &dwBuffer,
398 &ObdSize);
399 #else
400 Ret = kEplObdIndexNotExist;
401 #endif
402 if (Ret != kEplSuccessful) {
403 break;
404 }
405 if (dwBuffer != 0) { // BasicEthernet is enabled
406 // convert us into ms
407 dwBuffer =
408 dwBuffer / 1000;
409 if (dwBuffer == 0) { // timer was below one ms
410 // set one ms
411 dwBuffer = 1;
412 }
413 TimerArg.m_EventSink =
414 kEplEventSinkNmtk;
415 TimerArg.m_ulArg =
416 (unsigned long)
417 kEplNmtEventTimerBasicEthernet;
418 Ret =
419 EplTimeruModifyTimerMs
420 (&EplNmtuInstance_g.
421 m_TimerHdl,
422 (unsigned long)
423 dwBuffer,
424 TimerArg);
425 // potential error is forwarded to event queue which generates error event
426 }
427 break;
428 }
429
430 // node processes only async frames
431 case kEplNmtCsPreOperational1:
432 {
433 break;
434 }
435
436 // node processes isochronous and asynchronous frames
437 case kEplNmtCsPreOperational2:
438 {
439 Ret =
440 EplNmtuNmtEvent
441 (kEplNmtEventEnterReadyToOperate);
442 break;
443 }
444
445 // node should be configured und application is ready
446 case kEplNmtCsReadyToOperate:
447 {
448 break;
449 }
450
451 // normal work state
452 case kEplNmtCsOperational:
453 {
454 break;
455 }
456
457 // node stopped by MN
458 // -> only process asynchronous frames
459 case kEplNmtCsStopped:
460 {
461 break;
462 }
463
464 // no EPL cycle
465 // -> normal ethernet communication
466 case kEplNmtCsBasicEthernet:
467 {
468 break;
469 }
470
471 //-----------------------------------------------------------
472 // MN part of the state machine
473
474 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
475 // node listens for EPL-Frames and check timeout
476 case kEplNmtMsNotActive:
477 {
478 u32 dwBuffer;
479 tEplObdSize ObdSize;
480 tEplTimerArg TimerArg;
481
482 // create timer to switch automatically to BasicEthernet/PreOp1 if no other MN active in network
483
484 // check NMT_StartUp_U32.Bit13
485 // read NMT_StartUp_U32 from OD
486 ObdSize = sizeof(dwBuffer);
487 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDU)) != 0) || (EPL_OBD_USE_KERNEL != FALSE)
488 Ret =
489 EplObduReadEntry
490 (EPL_MCO_PTR_INSTANCE_PTR_
491 0x1F80, 0x00, &dwBuffer,
492 &ObdSize);
493 #else
494 Ret = kEplObdIndexNotExist;
495 #endif
496 if (Ret != kEplSuccessful) {
497 break;
498 }
499
500 if ((dwBuffer & EPL_NMTST_BASICETHERNET) == 0) { // NMT_StartUp_U32.Bit13 == 0
501 // new state PreOperational1
502 TimerArg.m_ulArg =
503 (unsigned long)
504 kEplNmtEventTimerMsPreOp1;
505 } else { // NMT_StartUp_U32.Bit13 == 1
506 // new state BasicEthernet
507 TimerArg.m_ulArg =
508 (unsigned long)
509 kEplNmtEventTimerBasicEthernet;
510 }
511
512 // read NMT_BootTime_REC.MNWaitNotAct_U32 from OD
513 ObdSize = sizeof(dwBuffer);
514 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDU)) != 0) || (EPL_OBD_USE_KERNEL != FALSE)
515 Ret =
516 EplObduReadEntry
517 (EPL_MCO_PTR_INSTANCE_PTR_
518 0x1F89, 0x01, &dwBuffer,
519 &ObdSize);
520 #else
521 Ret = kEplObdIndexNotExist;
522 #endif
523 if (Ret != kEplSuccessful) {
524 break;
525 }
526 // convert us into ms
527 dwBuffer = dwBuffer / 1000;
528 if (dwBuffer == 0) { // timer was below one ms
529 // set one ms
530 dwBuffer = 1;
531 }
532 TimerArg.m_EventSink =
533 kEplEventSinkNmtk;
534 Ret =
535 EplTimeruModifyTimerMs
536 (&EplNmtuInstance_g.
537 m_TimerHdl,
538 (unsigned long)dwBuffer,
539 TimerArg);
540 // potential error is forwarded to event queue which generates error event
541 break;
542 }
543
544 // node processes only async frames
545 case kEplNmtMsPreOperational1:
546 {
547 u32 dwBuffer = 0;
548 tEplObdSize ObdSize;
549 tEplTimerArg TimerArg;
550
551 // create timer to switch automatically to PreOp2 if MN identified all mandatory CNs
552
553 // read NMT_BootTime_REC.MNWaitPreOp1_U32 from OD
554 ObdSize = sizeof(dwBuffer);
555 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDU)) != 0) || (EPL_OBD_USE_KERNEL != FALSE)
556 Ret =
557 EplObduReadEntry
558 (EPL_MCO_PTR_INSTANCE_PTR_
559 0x1F89, 0x03, &dwBuffer,
560 &ObdSize);
561 if (Ret != kEplSuccessful) {
562 // ignore error, because this timeout is optional
563 dwBuffer = 0;
564 }
565 #endif
566 if (dwBuffer == 0) { // delay is deactivated
567 // immediately post timer event
568 Ret =
569 EplNmtuNmtEvent
570 (kEplNmtEventTimerMsPreOp2);
571 break;
572 }
573 // convert us into ms
574 dwBuffer = dwBuffer / 1000;
575 if (dwBuffer == 0) { // timer was below one ms
576 // set one ms
577 dwBuffer = 1;
578 }
579 TimerArg.m_EventSink =
580 kEplEventSinkNmtk;
581 TimerArg.m_ulArg =
582 (unsigned long)
583 kEplNmtEventTimerMsPreOp2;
584 Ret =
585 EplTimeruModifyTimerMs
586 (&EplNmtuInstance_g.
587 m_TimerHdl,
588 (unsigned long)dwBuffer,
589 TimerArg);
590 // potential error is forwarded to event queue which generates error event
591 break;
592 }
593
594 // node processes isochronous and asynchronous frames
595 case kEplNmtMsPreOperational2:
596 {
597 break;
598 }
599
600 // node should be configured und application is ready
601 case kEplNmtMsReadyToOperate:
602 {
603 break;
604 }
605
606 // normal work state
607 case kEplNmtMsOperational:
608 {
609 break;
610 }
611
612 // no EPL cycle
613 // -> normal ethernet communication
614 case kEplNmtMsBasicEthernet:
615 {
616 break;
617 }
618 #endif // (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
619
620 default:
621 {
622 TRACE1
623 ("EplNmtuProcess(): unhandled NMT state 0x%X\n",
624 pNmtStateChange->
625 m_NewNmtState);
626 }
627 }
628 } else if (Ret == kEplReject) { // application wants to change NMT state itself
629 // it's OK
630 Ret = kEplSuccessful;
631 }
632
633 EPL_DBGLVL_NMTU_TRACE0
634 ("EplNmtuProcessEvent(): NMT-State-Maschine announce change of NMT State\n");
635 break;
636 }
637
638 default:
639 {
640 Ret = kEplNmtInvalidEvent;
641 }
642
643 }
644
645 //Exit:
646 return Ret;
647 }
648
649 //---------------------------------------------------------------------------
650 //
651 // Function: EplNmtuRegisterStateChangeCb
652 //
653 // Description: register Callback-function go get informed about a
654 // NMT-Change-State-Event
655 //
656 //
657 //
658 // Parameters: pfnEplNmtStateChangeCb_p = functionpointer
659 //
660 //
661 // Returns: tEplKernel = errorcode
662 //
663 //
664 // State:
665 //
666 //---------------------------------------------------------------------------
667 tEplKernel EplNmtuRegisterStateChangeCb(tEplNmtuStateChangeCallback pfnEplNmtStateChangeCb_p)
668 {
669 tEplKernel Ret;
670
671 Ret = kEplSuccessful;
672
673 // save callback-function in modul global var
674 EplNmtuInstance_g.m_pfnNmtChangeCb = pfnEplNmtStateChangeCb_p;
675
676 return Ret;
677
678 }
679
680 //=========================================================================//
681 // //
682 // P R I V A T E F U N C T I O N S //
683 // //
684 //=========================================================================//
685
686 //---------------------------------------------------------------------------
687 //
688 // Function:
689 //
690 // Description:
691 //
692 //
693 //
694 // Parameters:
695 //
696 //
697 // Returns:
698 //
699 //
700 // State:
701 //
702 //---------------------------------------------------------------------------
703
704 #endif // #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMTU)) != 0)
705
706 // EOF
707
|
This page was automatically generated by the
LXR engine.
|