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 communication abstraction layer
9 for the Epl-Obd-Userspace-Modul
10
11 License:
12
13 Redistribution and use in source and binary forms, with or without
14 modification, are permitted provided that the following conditions
15 are met:
16
17 1. Redistributions of source code must retain the above copyright
18 notice, this list of conditions and the following disclaimer.
19
20 2. Redistributions in binary form must reproduce the above copyright
21 notice, this list of conditions and the following disclaimer in the
22 documentation and/or other materials provided with the distribution.
23
24 3. Neither the name of SYSTEC electronic GmbH nor the names of its
25 contributors may be used to endorse or promote products derived
26 from this software without prior written permission. For written
27 permission, please contact info@systec-electronic.com.
28
29 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
30 "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
31 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
32 FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
33 COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
34 INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
35 BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
36 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
37 CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
38 LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
39 ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
40 POSSIBILITY OF SUCH DAMAGE.
41
42 Severability Clause:
43
44 If a provision of this License is or becomes illegal, invalid or
45 unenforceable in any jurisdiction, that shall not affect:
46 1. the validity or enforceability in that jurisdiction of any other
47 provision of this License; or
48 2. the validity or enforceability in other jurisdictions of that or
49 any other provision of this License.
50
51 -------------------------------------------------------------------------
52
53 $RCSfile: EplObduCal.c,v $
54
55 $Author: D.Krueger $
56
57 $Revision: 1.6 $ $Date: 2008/10/17 15:32:32 $
58
59 $State: Exp $
60
61 Build Environment:
62 GCC V3.4
63
64 -------------------------------------------------------------------------
65
66 Revision History:
67
68 2006/06/19 k.t.: start of the implementation
69
70 ****************************************************************************/
71 #include "EplInc.h"
72 #include "user/EplObduCal.h"
73 #include "kernel/EplObdk.h"
74
75 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDU)) != 0) && (EPL_OBD_USE_KERNEL != FALSE)
76
77 /***************************************************************************/
78 /* */
79 /* */
80 /* G L O B A L D E F I N I T I O N S */
81 /* */
82 /* */
83 /***************************************************************************/
84
85 //---------------------------------------------------------------------------
86 // const defines
87 //---------------------------------------------------------------------------
88
89 //---------------------------------------------------------------------------
90 // local types
91 //---------------------------------------------------------------------------
92
93 //---------------------------------------------------------------------------
94 // modul globale vars
95 //---------------------------------------------------------------------------
96
97 //---------------------------------------------------------------------------
98 // local function prototypes
99 //---------------------------------------------------------------------------
100
101 //=========================================================================//
102 // //
103 // P U B L I C F U N C T I O N S //
104 // //
105 //=========================================================================//
106
107 //---------------------------------------------------------------------------
108 //
109 // Function: EplObduCalWriteEntry()
110 //
111 // Description: Function encapsulate access of function EplObdWriteEntry
112 //
113 // Parameters: uiIndex_p = Index of the OD entry
114 // uiSubIndex_p = Subindex of the OD Entry
115 // pSrcData_p = Pointer to the data to write
116 // Size_p = Size of the data in Byte
117 //
118 // Return: tEplKernel = Errorcode
119 //
120 //
121 // State:
122 //
123 //---------------------------------------------------------------------------
EplObduCalWriteEntry(unsigned int uiIndex_p,unsigned int uiSubIndex_p,void * pSrcData_p,tEplObdSize Size_p)124 EPLDLLEXPORT tEplKernel PUBLIC EplObduCalWriteEntry(unsigned int uiIndex_p,
125 unsigned int uiSubIndex_p,
126 void *pSrcData_p,
127 tEplObdSize Size_p)
128 {
129 tEplKernel Ret;
130
131 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDK)) != 0)
132 Ret = EplObdWriteEntry(uiIndex_p, uiSubIndex_p, pSrcData_p, Size_p);
133 #else
134 Ret = kEplSuccessful;
135 #endif
136
137 return Ret;
138 }
139
140 //---------------------------------------------------------------------------
141 //
142 // Function: EplObduCalReadEntry()
143 //
144 // Description: Function encapsulate access of function EplObdReadEntry
145 //
146 // Parameters: uiIndex_p = Index oof the OD entry to read
147 // uiSubIndex_p = Subindex to read
148 // pDstData_p = pointer to the buffer for data
149 // Offset_p = offset in data for read access
150 // pSize_p = IN: Size of the buffer
151 // OUT: number of readed Bytes
152 //
153 // Return: tEplKernel = errorcode
154 //
155 // State:
156 //
157 //---------------------------------------------------------------------------
EplObduCalReadEntry(unsigned int uiIndex_p,unsigned int uiSubIndex_p,void * pDstData_p,tEplObdSize * pSize_p)158 EPLDLLEXPORT tEplKernel PUBLIC EplObduCalReadEntry(unsigned int uiIndex_p,
159 unsigned int uiSubIndex_p,
160 void *pDstData_p,
161 tEplObdSize * pSize_p)
162 {
163 tEplKernel Ret;
164
165 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDK)) != 0)
166 Ret = EplObdReadEntry(uiIndex_p, uiSubIndex_p, pDstData_p, pSize_p);
167 #else
168 Ret = kEplSuccessful;
169 #endif
170
171 return Ret;
172 }
173
174 //---------------------------------------------------------------------------
175 //
176 // Function: EplObduCalAccessOdPart()
177 //
178 // Description: Function encapsulate access of function EplObdAccessOdPart
179 //
180 // Parameters: ObdPart_p = od-part to reset
181 // Direction_p = directory flag for
182 //
183 // Return: tEplKernel = errorcode
184 //
185 // State:
186 //
187 //---------------------------------------------------------------------------
EplObduCalAccessOdPart(tEplObdPart ObdPart_p,tEplObdDir Direction_p)188 EPLDLLEXPORT tEplKernel PUBLIC EplObduCalAccessOdPart(tEplObdPart ObdPart_p,
189 tEplObdDir Direction_p)
190 {
191 tEplKernel Ret;
192
193 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDK)) != 0)
194 Ret = EplObdAccessOdPart(ObdPart_p, Direction_p);
195 #else
196 Ret = kEplSuccessful;
197 #endif
198
199 return Ret;
200 }
201
202 //---------------------------------------------------------------------------
203 //
204 // Function: EplObduCalDefineVar()
205 //
206 // Description: Function encapsulate access of function EplObdDefineVar
207 //
208 // Parameters: pEplVarParam_p = varentry
209 //
210 // Return: tEplKernel = errorcode
211 //
212 // State:
213 //
214 //---------------------------------------------------------------------------
EplObduCalDefineVar(tEplVarParam MEM * pVarParam_p)215 EPLDLLEXPORT tEplKernel PUBLIC EplObduCalDefineVar(tEplVarParam MEM *
216 pVarParam_p)
217 {
218 tEplKernel Ret;
219
220 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDK)) != 0)
221 Ret = EplObdDefineVar(pVarParam_p);
222 #else
223 Ret = kEplSuccessful;
224 #endif
225
226 return Ret;
227 }
228
229 //---------------------------------------------------------------------------
230 //
231 // Function: EplObduCalGetObjectDataPtr()
232 //
233 // Description: Function encapsulate access of function EplObdGetObjectDataPtr
234 //
235 // Parameters: uiIndex_p = Index of the entry
236 // uiSubindex_p = Subindex of the entry
237 //
238 // Return: void * = pointer to object data
239 //
240 // State:
241 //
242 //---------------------------------------------------------------------------
EplObduCalGetObjectDataPtr(unsigned int uiIndex_p,unsigned int uiSubIndex_p)243 EPLDLLEXPORT void *PUBLIC EplObduCalGetObjectDataPtr(unsigned int uiIndex_p,
244 unsigned int uiSubIndex_p)
245 {
246 void *pData;
247
248 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDK)) != 0)
249 pData = EplObdGetObjectDataPtr(uiIndex_p, uiSubIndex_p);
250 #else
251 pData = NULL;
252 #endif
253
254 return pData;
255 }
256
257 //---------------------------------------------------------------------------
258 //
259 // Function: EplObduCalRegisterUserOd()
260 //
261 // Description: Function encapsulate access of function EplObdRegisterUserOd
262 //
263 // Parameters: pUserOd_p = pointer to user OD
264 //
265 // Return: tEplKernel = errorcode
266 //
267 // State:
268 //
269 //---------------------------------------------------------------------------
270 #if (defined (EPL_OBD_USER_OD) && (EPL_OBD_USER_OD != FALSE))
EplObduCalRegisterUserOd(tEplObdEntryPtr pUserOd_p)271 EPLDLLEXPORT tEplKernel PUBLIC EplObduCalRegisterUserOd(tEplObdEntryPtr
272 pUserOd_p)
273 {
274 tEplKernel Ret;
275
276 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDK)) != 0)
277 Ret = EplObdRegisterUserOd(pUserOd_p);
278 #else
279 Ret = kEplSuccessful;
280 #endif
281
282 return Ret;
283
284 }
285 #endif
286 //---------------------------------------------------------------------------
287 //
288 // Function: EplObduCalInitVarEntry()
289 //
290 // Description: Function encapsulate access of function EplObdInitVarEntry
291 //
292 // Parameters: pVarEntry_p = pointer to var entry structure
293 // bType_p = object type
294 // ObdSize_p = size of object data
295 //
296 // Returns: none
297 //
298 // State:
299 //
300 //---------------------------------------------------------------------------
EplObduCalInitVarEntry(tEplObdVarEntry MEM * pVarEntry_p,BYTE bType_p,tEplObdSize ObdSize_p)301 EPLDLLEXPORT void PUBLIC EplObduCalInitVarEntry(tEplObdVarEntry MEM *
302 pVarEntry_p, BYTE bType_p,
303 tEplObdSize ObdSize_p)
304 {
305 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDK)) != 0)
306 EplObdInitVarEntry(pVarEntry_p, bType_p, ObdSize_p);
307 #endif
308 }
309
310 //---------------------------------------------------------------------------
311 //
312 // Function: EplObduCalGetDataSize()
313 //
314 // Description: Function encapsulate access of function EplObdGetDataSize
315 //
316 // gets the data size of an object
317 // for string objects it returnes the string length
318 //
319 // Parameters: uiIndex_p = Index
320 // uiSubIndex_p= Subindex
321 //
322 // Return: tEplObdSize
323 //
324 // State:
325 //
326 //---------------------------------------------------------------------------
EplObduCalGetDataSize(unsigned int uiIndex_p,unsigned int uiSubIndex_p)327 EPLDLLEXPORT tEplObdSize PUBLIC EplObduCalGetDataSize(unsigned int uiIndex_p,
328 unsigned int uiSubIndex_p)
329 {
330 tEplObdSize Size;
331
332 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDK)) != 0)
333 Size = EplObdGetDataSize(uiIndex_p, uiSubIndex_p);
334 #else
335 Size = 0;
336 #endif
337
338 return Size;
339 }
340
341 //---------------------------------------------------------------------------
342 //
343 // Function: EplObduCalGetNodeId()
344 //
345 // Description: Function encapsulate access of function EplObdGetNodeId
346 //
347 //
348 // Parameters:
349 //
350 // Return: unsigned int = Node Id
351 //
352 // State:
353 //
354 //---------------------------------------------------------------------------
EplObduCalGetNodeId()355 EPLDLLEXPORT unsigned int PUBLIC EplObduCalGetNodeId()
356 {
357 unsigned int uiNodeId;
358
359 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDK)) != 0)
360 uiNodeId = EplObdGetNodeId();
361 #else
362 uiNodeId = 0;
363 #endif
364
365 return uiNodeId;
366 }
367
368 //---------------------------------------------------------------------------
369 //
370 // Function: EplObduCalSetNodeId()
371 //
372 // Description: Function encapsulate access of function EplObdSetNodeId
373 //
374 //
375 // Parameters: uiNodeId_p = Node Id to set
376 // NodeIdType_p= Type on which way the Node Id was set
377 //
378 // Return: tEplKernel = Errorcode
379 //
380 // State:
381 //
382 //---------------------------------------------------------------------------
EplObduCalSetNodeId(unsigned int uiNodeId_p,tEplObdNodeIdType NodeIdType_p)383 EPLDLLEXPORT tEplKernel PUBLIC EplObduCalSetNodeId(unsigned int uiNodeId_p,
384 tEplObdNodeIdType
385 NodeIdType_p)
386 {
387 tEplKernel Ret;
388
389 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDK)) != 0)
390 Ret = EplObdSetNodeId(uiNodeId_p, NodeIdType_p);
391 #else
392 Ret = kEplSuccessful;
393 #endif
394
395 return Ret;
396 }
397
398 //---------------------------------------------------------------------------
399 //
400 // Function: EplObduCalGetAccessType()
401 //
402 // Description: Function encapsulate access of function EplObdGetAccessType
403 //
404 // Parameters: uiIndex_p = Index of the OD entry
405 // uiSubIndex_p = Subindex of the OD Entry
406 // pAccessTyp_p = pointer to buffer to store accesstype
407 //
408 // Return: tEplKernel = errorcode
409 //
410 //
411 // State:
412 //
413 //---------------------------------------------------------------------------
EplObduCalGetAccessType(unsigned int uiIndex_p,unsigned int uiSubIndex_p,tEplObdAccess * pAccessTyp_p)414 EPLDLLEXPORT tEplKernel PUBLIC EplObduCalGetAccessType(unsigned int uiIndex_p,
415 unsigned int
416 uiSubIndex_p,
417 tEplObdAccess *
418 pAccessTyp_p)
419 {
420 tEplObdAccess AccesType;
421
422 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDK)) != 0)
423 AccesType = EplObdGetAccessType(uiIndex_p, uiSubIndex_p, pAccessTyp_p);
424 #else
425 AccesType = 0;
426 #endif
427
428 return AccesType;
429
430 }
431
432 //---------------------------------------------------------------------------
433 //
434 // Function: EplObduCalReadEntryToLe()
435 //
436 // Description: Function encapsulate access of function EplObdReadEntryToLe
437 //
438 // Parameters: uiIndex_p = Index of the OD entry to read
439 // uiSubIndex_p = Subindex to read
440 // pDstData_p = pointer to the buffer for data
441 // Offset_p = offset in data for read access
442 // pSize_p = IN: Size of the buffer
443 // OUT: number of readed Bytes
444 //
445 // Return: tEplKernel
446 //
447 // State:
448 //
449 //---------------------------------------------------------------------------
EplObduCalReadEntryToLe(unsigned int uiIndex_p,unsigned int uiSubIndex_p,void * pDstData_p,tEplObdSize * pSize_p)450 EPLDLLEXPORT tEplKernel PUBLIC EplObduCalReadEntryToLe(unsigned int uiIndex_p,
451 unsigned int
452 uiSubIndex_p,
453 void *pDstData_p,
454 tEplObdSize * pSize_p)
455 {
456 tEplKernel Ret;
457
458 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDK)) != 0)
459 Ret = EplObdReadEntryToLe(uiIndex_p, uiSubIndex_p, pDstData_p, pSize_p);
460 #else
461 Ret = kEplSuccessful;
462 #endif
463
464 return Ret;
465 }
466
467 //---------------------------------------------------------------------------
468 //
469 // Function: EplObduCalWriteEntryFromLe()
470 //
471 // Description: Function encapsulate access of function EplObdWriteEntryFromLe
472 //
473 // Parameters: uiIndex_p = Index of the OD entry
474 // uiSubIndex_p = Subindex of the OD Entry
475 // pSrcData_p = Pointer to the data to write
476 // Size_p = Size of the data in Byte
477 //
478 // Return: tEplKernel = Errorcode
479 //
480 //
481 // State:
482 //
483 //---------------------------------------------------------------------------
EplObduCalWriteEntryFromLe(unsigned int uiIndex_p,unsigned int uiSubIndex_p,void * pSrcData_p,tEplObdSize Size_p)484 EPLDLLEXPORT tEplKernel PUBLIC EplObduCalWriteEntryFromLe(unsigned int
485 uiIndex_p,
486 unsigned int
487 uiSubIndex_p,
488 void *pSrcData_p,
489 tEplObdSize Size_p)
490 {
491 tEplKernel Ret;
492
493 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDK)) != 0)
494 Ret =
495 EplObdWriteEntryFromLe(uiIndex_p, uiSubIndex_p, pSrcData_p, Size_p);
496 #else
497 Ret = kEplSuccessful;
498 #endif
499 return Ret;
500 }
501
502 //---------------------------------------------------------------------------
503 //
504 // Function: EplObduCalSearchVarEntry()
505 //
506 // Description: gets variable from OD
507 //
508 // Parameters: uiIndex_p = index of the var entry to search
509 // uiSubindex_p = subindex of var entry to search
510 // ppVarEntry_p = pointer to the pointer to the varentry
511 //
512 // Return: tEplKernel
513 //
514 // State:
515 //
516 //---------------------------------------------------------------------------
517 EPLDLLEXPORT tEplKernel PUBLIC
EplObduCalSearchVarEntry(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,unsigned int uiSubindex_p,tEplObdVarEntry MEM ** ppVarEntry_p)518 EplObduCalSearchVarEntry(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
519 unsigned int uiSubindex_p,
520 tEplObdVarEntry MEM ** ppVarEntry_p)
521 {
522 tEplKernel Ret;
523
524 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDK)) != 0)
525 Ret = EplObdSearchVarEntry(uiIndex_p, uiSubindex_p, ppVarEntry_p);
526 #else
527 Ret = kEplSuccessful;
528 #endif
529 return Ret;
530 }
531
532 //=========================================================================//
533 // //
534 // P R I V A T E F U N C T I O N S //
535 // //
536 //=========================================================================//
537
538 //---------------------------------------------------------------------------
539 //
540 // Function:
541 //
542 // Description:
543 //
544 //
545 //
546 // Parameters:
547 //
548 //
549 // Returns:
550 //
551 //
552 // State:
553 //
554 //---------------------------------------------------------------------------
555
556 #endif //(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDU)) != 0)
557
558 // EOF
559