OpenEL  3.0.0
openEL_motor.c
Go to the documentation of this file.
1 
12 /*
13 
14 Copyright (c) 2017,2018 Japan Embedded Systems Technology Association(JASA)
15 All rights reserved.
16 
17 Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
18 
19  Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
20  Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
21  Neither the name of the Association nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
22 
23 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24 */
25 
26 #define OPENEL_SW_SURFACE_FRIEND (1)
27 #include "openEL.h"
28 #include <stdio.h>
29 
30 /*---------------------------------------------------------------------------*/
41 enum ReturnCode HalSetPosition(HALCOMPONENT_T *halComponent, halfloat position) {
42  printf("HalSetPosition()\n");
43  // int32_t posI32;
44  int32_t this;
45  this = halComponent->halComponent_core.handle;
46  printf("this=%x\n", this);
47  struct elMotorFncTblSt *pMotorFbl;
48 #if 1 == EL_SW_FAST
49  uint32_t physicalPortID = elPortTbl[this].physicalPortID;
50 #else
51  uint32_t physicalPortID;
52  if ( 0 == (physicalPortID = elGetPhyicalPortID(this, ELMOTOR_PROPERTY)) ) {
53  return HAL_ERROR;
54  }
55 #endif
56  pMotorFbl = elPortTbl[this].fncTbl.pMotor;
57  return pMotorFbl->pFncSetPosition(&halComponent, position);
58 }
59 
60 /*---------------------------------------------------------------------------*/
69 enum ReturnCode HalGetPosition(HALCOMPONENT_T *halComponent, halfloat *position) {
70  int32_t this;
71  this = halComponent->halComponent_core.handle;
72 #if 1 == EL_SW_FAST
73  uint32_t physicalPortID = elPortTbl[this].physicalPortID;
74 #else
75  uint32_t physicalPortID;
76  if ( 0 == (physicalPortID = elGetPhyicalPortID(this,ELMOTOR_PROPERTY)) ) {
77  return HAL_ERROR;
78  }
79 #endif
80  return elPortTbl[this].fncTbl.pMotor->pFncGetPosition(&halComponent, &position);
81 }
82 /*---------------------------------------------------------------------------*/
83 
84 
85 #if 0
86 /*---------------------------------------------------------------------------*/
102 int32_t elMotorSetCtlMode(uint32_t portID,uint32_t mode);
103 /*---------------------------------------------------------------------------*/
111 uint32_t elMotorGetCtlMode(uint32_t portID);
112 /*---------------------------------------------------------------------------*/
124 int32_t elMotorSetBrake_I32(uint32_t portID,uint32_t ctlAftBrk,int32_t tmDec) {
125 #if 1 == EL_SW_FAST
126  uint32_t physicalPortID = elPortTbl[portID].physicalPortID;
127 #else
128  uint32_t physicalPortID;
129  if ( 0 == (physicalPortID = elGetPhyicalPortID(portID,ELMOTOR_PROPERTY)) ) {
130  return EL_ERR_INIT;
131  }
132 #endif
133  return elPortTbl[portID].fncTbl.pMotor->pFncSetBrake(physicalPortID,ctlAftBrk,tmDec);
134 }
136 int32_t elMotorSetBrake_F64(uint32_t portID,uint32_t ctlAftBrk,double tmDec) {
137 #if 1 == EL_SW_FAST
138  uint32_t physicalPortID = elPortTbl[portID].physicalPortID;
139 #else
140  uint32_t physicalPortID;
141  if ( 0 == (physicalPortID = elGetPhyicalPortID(portID,ELMOTOR_PROPERTY)) ) {
142  return EL_ERR_INIT;
143  }
144 #endif
145  int32_t tmDecI32 = (int32_t)( tmDec/1000.0 );
146  return elPortTbl[portID].fncTbl.pMotor->pFncSetBrake(physicalPortID,ctlAftBrk,tmDecI32);
147 }
148 /*---------------------------------------------------------------------------*/
159 int32_t elMotorSetPosition_I32(uint32_t portID,int32_t position,int32_t speed,int32_t tmAcc) {
160 #if 1 == EL_SW_FAST
161  uint32_t physicalPortID = elPortTbl[portID].physicalPortID;
162 #else
163  uint32_t physicalPortID;
164  if ( 0 == (physicalPortID = elGetPhyicalPortID(portID,ELMOTOR_PROPERTY)) ) {
165  return EL_ERR_INIT;
166  }
167 #endif
168  return elPortTbl[portID].fncTbl.pMotor->pFncSetPosition(physicalPortID,position,speed,tmAcc);
169 }
170 /*---------------------------------------------------------------------------*/
181 int32_t elMotorSetPosition_F64(uint32_t portID,double position,double speed,double tmAcc) {
182  int32_t posI32,speedI32,tmAccI32;
183  double kMov;
184  struct elMotorFncTblSt *pMotorFbl;
185 #if 1 == EL_SW_FAST
186  uint32_t physicalPortID = elPortTbl[portID].physicalPortID;
187 #else
188  uint32_t physicalPortID;
189  if ( 0 == (physicalPortID = elGetPhyicalPortID(portID,ELMOTOR_PROPERTY)) ) {
190  return EL_ERR_INIT;
191  }
192 #endif
193 
194  pMotorFbl = elPortTbl[portID].fncTbl.pMotor;
195  pMotorFbl->pFncGetParam(physicalPortID,ELMOTOR_PRM_K_MOVE, &kMov, sizeof(kMov) );
196 
197  posI32 = (int32_t)( kMov * position );
198  speedI32 = (int32_t)( kMov * speed );
199  tmAccI32 = (int32_t)( 1000.0 * tmAcc );
200 
201  return pMotorFbl->pFncSetPosition(physicalPortID,posI32,speedI32,tmAccI32);
202 }
203 /*---------------------------------------------------------------------------*/
214 int32_t elMotorSetSpeed_I32(uint32_t portID,int32_t speed,int32_t tmAcc) {
215 #if 1 == EL_SW_FAST
216  uint32_t physicalPortID = elPortTbl[portID].physicalPortID;
217 #else
218  uint32_t physicalPortID;
219  if ( 0 == (physicalPortID = elGetPhyicalPortID(portID,ELMOTOR_PROPERTY)) ) {
220  return EL_ERR_INIT;
221  }
222 #endif
223  return elPortTbl[portID].fncTbl.pMotor->pFncSetSpeed(physicalPortID,speed,tmAcc);
224 }
225 /*---------------------------------------------------------------------------*/
235 int32_t elMotorSetSpeed_F64(uint32_t portID,double speed,double tmAcc) {
236  int32_t speedI32,tmAccI32;
237  double kMov;
238  struct elMotorFncTblSt *pMotorFbl;
239 #if 1 == EL_SW_FAST
240  uint32_t physicalPortID = elPortTbl[portID].physicalPortID;
241 #else
242  uint32_t physicalPortID;
243  if ( 0 == (physicalPortID = elGetPhyicalPortID(portID,ELMOTOR_PROPERTY)) ) {
244  return EL_ERR_INIT;
245  }
246 #endif
247 
248  pMotorFbl = elPortTbl[portID].fncTbl.pMotor;
249  pMotorFbl->pFncGetParam(physicalPortID,ELMOTOR_PRM_K_MOVE, &kMov, sizeof(kMov) );
250 
251  speedI32 = (int32_t)( kMov * speed );
252  tmAccI32 = (int32_t)( 1000.0 * tmAcc );
253 
254  return pMotorFbl->pFncSetSpeed(physicalPortID,speedI32,tmAccI32);
255 }
256 /*---------------------------------------------------------------------------*/
264 //int32_t elMotorSetTorque_I32(uint32_t portID,int32_t torque);
265 //int32_t elMotorSetTorque_F64(uint32_t portID,double torque);
266 /*---------------------------------------------------------------------------*/
278 //int32_t elMotorSetBrakeD_I32(uint32_t portID,uint32_t ctlAB,int32_t tmDec);
279 //int32_t elMotorSetBrakeD_F64(uint32_t portID,uint32_t ctlAB,double tmDec);
280 //int32_t elMotorSetBrake(uint32_t portID);
281 /*---------------------------------------------------------------------------*/
292 //uint32_t elMotorGetBrake(uint32_t portID);
293 /*---------------------------------------------------------------------------*/
302 //int32_t elMotorPreSetPosition_I32(uint32_t portID,int32_t angle);
303 //double elMotorPreSetPosition_F64(uint32_t portID,double angle);
304 //#define elMotorPreSetAngle_I32 elMotorPreSetPosition_I32
305 //#define elMotorPreSetAngle_F64 elMotorPreSetPosition_F64
306 /*---------------------------------------------------------------------------*/
315 int32_t elMotorGetPosition_I32(uint32_t portID,uint32_t idx,int32_t *pOutPos) {
316 #if 1 == EL_SW_FAST
317  uint32_t physicalPortID = elPortTbl[portID].physicalPortID;
318 #else
319  uint32_t physicalPortID;
320  if ( 0 == (physicalPortID = elGetPhyicalPortID(portID,ELMOTOR_PROPERTY)) ) {
321  return EL_ERR_INIT;
322  }
323 #endif
324  return elPortTbl[portID].fncTbl.pMotor->pFncGetPosition(physicalPortID,idx,pOutPos);
325 }
326 /*---------------------------------------------------------------------------*/
335 int32_t elMotorGetPosition_F64(uint32_t portID,uint32_t idx,double *pOutPosition) {
336  struct elMotorFncTblSt *pMotorFbl;
337  double kMov;
338  int32_t posI32;
339  int32_t retVal;
340 #if 1 == EL_SW_FAST
341  uint32_t physicalPortID = elPortTbl[portID].physicalPortID;
342 #else
343  uint32_t physicalPortID;
344  if ( 0 == (physicalPortID = elGetPhyicalPortID(portID,ELMOTOR_PROPERTY)) ) {
345  return EL_ERR_INIT;
346  }
347 #endif
348 
349  pMotorFbl = elPortTbl[portID].fncTbl.pMotor;
350  pMotorFbl->pFncGetParam(physicalPortID,ELMOTOR_PRM_K_MOVE, &kMov, sizeof(kMov) );
351  retVal = pMotorFbl->pFncGetPosition(physicalPortID,idx,&posI32);
352  *pOutPosition = (double)posI32/kMov;
353  return retVal;
354 }
355 /*---------------------------------------------------------------------------*/
364 int32_t elMotorGetSpeed_I32(uint32_t portID,int32_t idx,int32_t *pOutSpeed) {
365 #if 1 == EL_SW_FAST
366  uint32_t physicalPortID = elPortTbl[portID].physicalPortID;
367 #else
368  uint32_t physicalPortID;
369  if ( 0 == (physicalPortID = elGetPhyicalPortID(portID,ELMOTOR_PROPERTY)) ) {
370  return EL_ERR_INIT;
371  }
372 #endif
373  return elPortTbl[portID].fncTbl.pMotor->pFncGetSpeed(physicalPortID,idx,pOutSpeed);
374 }
375 /*---------------------------------------------------------------------------*/
384 int32_t elMotorGetSpeed_F64(uint32_t portID,int32_t idx,double *pOutSpeed) {
385  struct elMotorFncTblSt *pMotorFbl;
386  double kMov;
387  int32_t speedI32;
388  int32_t retVal;
389 #if 1 == EL_SW_FAST
390  uint32_t physicalPortID = elPortTbl[portID].physicalPortID;
391 #else
392  uint32_t physicalPortID;
393  if ( 0 == (physicalPortID = elGetPhyicalPortID(portID,ELMOTOR_PROPERTY)) ) {
394  return EL_ERR_INIT;
395  }
396 #endif
397 
398  pMotorFbl = elPortTbl[portID].fncTbl.pMotor;
399  pMotorFbl->pFncGetParam(physicalPortID,ELMOTOR_PRM_K_MOVE, &kMov, sizeof(kMov) );
400  retVal = pMotorFbl->pFncGetSpeed(physicalPortID,idx,&speedI32);
401  *pOutSpeed = (double)speedI32/kMov;
402  return retVal;
403 }
404 /*---------------------------------------------------------------------------*/
410 int32_t elMotorGoHome_I32(uint32_t portID,uint32_t idx,int32_t speed) {
411  uint32_t physicalPortID;
412  if ( 0 == (physicalPortID = elGetPhyicalPortID(portID,ELMOTOR_PROPERTY)) ) {
413  return EL_ERR_INIT;
414  }
415 
416  return elPortTbl[portID].fncTbl.pMotor->pFncGoHome(physicalPortID,idx,speed);
417 }
418 /*---------------------------------------------------------------------------*/
424 int32_t elMotorGoHome_F64(uint32_t portID,uint32_t idx,double speed) {
425  int32_t speedI32;
426  double kMov;
427  struct elMotorFncTblSt *pMotorFbl;
428  uint32_t physicalPortID;
429  if ( 0 == (physicalPortID = elGetPhyicalPortID(portID,ELMOTOR_PROPERTY)) ) {
430  return EL_ERR_INIT;
431  }
432 
433  pMotorFbl = elPortTbl[portID].fncTbl.pMotor;
434  pMotorFbl->pFncGetParam(physicalPortID,ELMOTOR_PRM_K_MOVE, &kMov, sizeof(kMov) );
435 
436  speedI32 = (int32_t)( kMov * speed );
437 
438  return elPortTbl[portID].fncTbl.pMotor->pFncGoHome(physicalPortID,idx,speedI32);
439 }
440 /*---------------------------------------------------------------------------*/
447 int32_t elMotorSetCallBack_I32(uint32_t portID,uint32_t idx,ELMOTOR_P_FNC_CALLBACK pFncCB,int32_t val) {
448 #if 1 == EL_SW_FAST
449  uint32_t physicalPortID = elPortTbl[portID].physicalPortID;
450 #else
451  uint32_t physicalPortID;
452  if ( 0 == (physicalPortID = elGetPhyicalPortID(portID,ELMOTOR_PROPERTY)) ) {
453  return EL_ERR_INIT;
454  }
455 #endif
456  return elPortTbl[portID].fncTbl.pMotor->pFncSetCallBack(physicalPortID,idx,pFncCB,val);
457 }
458 /*---------------------------------------------------------------------------*/
465 int32_t elMotorSetCallBack_F64(uint32_t portID,uint32_t idx,ELMOTOR_P_FNC_CALLBACK pFncCB,double val) {
466  struct elMotorFncTblSt *pMotorFbl;
467  double kMov;
468  int32_t valI32;
469 #if 1 == EL_SW_FAST
470  uint32_t physicalPortID = elPortTbl[portID].physicalPortID;
471 #else
472  uint32_t physicalPortID;
473  if ( 0 == (physicalPortID = elGetPhyicalPortID(portID,ELMOTOR_PROPERTY)) ) {
474  return EL_ERR_INIT;
475  }
476 #endif
477  pMotorFbl = elPortTbl[portID].fncTbl.pMotor;
478  pMotorFbl->pFncGetParam(physicalPortID,ELMOTOR_PRM_K_MOVE, &kMov, sizeof(kMov) );
479  valI32 = (int32_t)( kMov*val );
480  return pMotorFbl->pFncSetCallBack(physicalPortID,idx,pFncCB,valI32);
481 }
482 /*---------------------------------------------------------------------------*/
483 
484 
485 //i 後でopenEL.cに移動する
486 /* parameter read/write */
487 /*---------------------------------------------------------------------------*/
494 int32_t elMotorSetParam_U16(uint32_t portID,uint32_t prmID,uint16_t val) {
495 #if 1 == EL_SW_FAST
496  uint32_t physicalPortID = elPortTbl[portID].physicalPortID;
497 #else
498  uint32_t physicalPortID;
499  if ( 0 == (physicalPortID = elGetPhyicalPortID(portID,ELMOTOR_PROPERTY)) ) {
500  return EL_ERR_INIT;
501  }
502 #endif
503  return elPortTbl[portID].fncTbl.pMotor->pFncSetParam(physicalPortID,prmID,&val,sizeof(val) );
504 }
505 int32_t elMotorSetParam_I16(uint32_t portID,uint32_t prmID,int16_t val) {
506 #if 1 == EL_SW_FAST
507  uint32_t physicalPortID = elPortTbl[portID].physicalPortID;
508 #else
509  uint32_t physicalPortID;
510  if ( 0 == (physicalPortID = elGetPhyicalPortID(portID,ELMOTOR_PROPERTY)) ) {
511  return EL_ERR_INIT;
512  }
513 #endif
514  return elPortTbl[portID].fncTbl.pMotor->pFncSetParam(physicalPortID,prmID,&val,sizeof(val) );
515 }
516 int32_t elMotorSetParam_U32(uint32_t portID,uint32_t prmID,uint32_t val) {
517 #if 1 == EL_SW_FAST
518  uint32_t physicalPortID = elPortTbl[portID].physicalPortID;
519 #else
520  uint32_t physicalPortID;
521  if ( 0 == (physicalPortID = elGetPhyicalPortID(portID,ELMOTOR_PROPERTY)) ) {
522  return EL_ERR_INIT;
523  }
524 #endif
525  return elPortTbl[portID].fncTbl.pMotor->pFncSetParam(physicalPortID,prmID,&val,sizeof(val) );
526 }
527 int32_t elMotorSetParam_I32(uint32_t portID,uint32_t prmID,uint32_t val) {
528 #if 1 == EL_SW_FAST
529  uint32_t physicalPortID = elPortTbl[portID].physicalPortID;
530 #else
531  uint32_t physicalPortID;
532  if ( 0 == (physicalPortID = elGetPhyicalPortID(portID,ELMOTOR_PROPERTY)) ) {
533  return EL_ERR_INIT;
534  }
535 #endif
536  return elPortTbl[portID].fncTbl.pMotor->pFncSetParam(physicalPortID,prmID,&val,sizeof(val) );
537 }
538 int32_t elMotorSetParam_F32(uint32_t portID,uint32_t prmID,float val) {
539 #if 1 == EL_SW_FAST
540  uint32_t physicalPortID = elPortTbl[portID].physicalPortID;
541 #else
542  uint32_t physicalPortID;
543  if ( 0 == (physicalPortID = elGetPhyicalPortID(portID,ELMOTOR_PROPERTY)) ) {
544  return EL_ERR_INIT;
545  }
546 #endif
547  return elPortTbl[portID].fncTbl.pMotor->pFncSetParam(physicalPortID,prmID,&val,sizeof(val) );
548 }
549 int32_t elMotorSetParam_F64(uint32_t portID,uint32_t prmID,double val) {
550 #if 1 == EL_SW_FAST
551  uint32_t physicalPortID = elPortTbl[portID].physicalPortID;
552 #else
553  uint32_t physicalPortID;
554  if ( 0 == (physicalPortID = elGetPhyicalPortID(portID,ELMOTOR_PROPERTY)) ) {
555  return EL_ERR_INIT;
556  }
557 #endif
558  return elPortTbl[portID].fncTbl.pMotor->pFncSetParam(physicalPortID,prmID,&val,sizeof(val) );
559 }
560 /*---------------------------------------------------------------------------*/
567 int32_t elMotorGetParam_U16(uint32_t portID,uint32_t prmID,uint16_t *pOutVal) {
568 #if 1 == EL_SW_FAST
569  uint32_t physicalPortID = elPortTbl[portID].physicalPortID;
570 #else
571  uint32_t physicalPortID;
572  if ( 0 == (physicalPortID = elGetPhyicalPortID(portID,ELMOTOR_PROPERTY)) ) {
573  return EL_ERR_INIT;
574  }
575 #endif
576  return elPortTbl[portID].fncTbl.pMotor->pFncGetParam(physicalPortID,prmID,pOutVal,sizeof(*pOutVal) );
577 }
578 int32_t elMotorGetParam_I16(uint32_t portID,uint32_t prmID,int16_t *pOutVal) {
579 #if 1 == EL_SW_FAST
580  uint32_t physicalPortID = elPortTbl[portID].physicalPortID;
581 #else
582  uint32_t physicalPortID;
583  if ( 0 == (physicalPortID = elGetPhyicalPortID(portID,ELMOTOR_PROPERTY)) ) {
584  return EL_ERR_INIT;
585  }
586 #endif
587  return elPortTbl[portID].fncTbl.pMotor->pFncGetParam(physicalPortID,prmID,pOutVal,sizeof(*pOutVal) );
588 }
589 int32_t elMotorGetParam_U32(uint32_t portID,uint32_t prmID,uint32_t *pOutVal) {
590 #if 1 == EL_SW_FAST
591  uint32_t physicalPortID = elPortTbl[portID].physicalPortID;
592 #else
593  uint32_t physicalPortID;
594  if ( 0 == (physicalPortID = elGetPhyicalPortID(portID,ELMOTOR_PROPERTY)) ) {
595  return EL_ERR_INIT;
596  }
597 #endif
598  return elPortTbl[portID].fncTbl.pMotor->pFncGetParam(physicalPortID,prmID,pOutVal,sizeof(*pOutVal) );
599 }
600 int32_t elMotorGetParam_I32(uint32_t portID,uint32_t prmID,int32_t *pOutVal) {
601 #if 1 == EL_SW_FAST
602  uint32_t physicalPortID = elPortTbl[portID].physicalPortID;
603 #else
604  uint32_t physicalPortID;
605  if ( 0 == (physicalPortID = elGetPhyicalPortID(portID,ELMOTOR_PROPERTY)) ) {
606  return EL_ERR_INIT;
607  }
608 #endif
609  return elPortTbl[portID].fncTbl.pMotor->pFncGetParam(physicalPortID,prmID,pOutVal,sizeof(*pOutVal) );
610 }
611 int32_t elMotorGetParam_F32(uint32_t portID,uint32_t prmID,float *pOutVal) {
612 #if 1 == EL_SW_FAST
613  uint32_t physicalPortID = elPortTbl[portID].physicalPortID;
614 #else
615  uint32_t physicalPortID;
616  if ( 0 == (physicalPortID = elGetPhyicalPortID(portID,ELMOTOR_PROPERTY)) ) {
617  return EL_ERR_INIT;
618  }
619 #endif
620  return elPortTbl[portID].fncTbl.pMotor->pFncGetParam(physicalPortID,prmID,pOutVal,sizeof(*pOutVal) );
621 }
622 int32_t elMotorGetParam_F64(uint32_t portID,uint32_t prmID,double *pOutVal) {
623 #if 1 == EL_SW_FAST
624  uint32_t physicalPortID = elPortTbl[portID].physicalPortID;
625 #else
626  uint32_t physicalPortID;
627  if ( 0 == (physicalPortID = elGetPhyicalPortID(portID,ELMOTOR_PROPERTY)) ) {
628  return EL_ERR_INIT;
629  }
630 #endif
631  return elPortTbl[portID].fncTbl.pMotor->pFncGetParam(physicalPortID,prmID,pOutVal,sizeof(*pOutVal) );
632 }
633 /*---------------------------------------------------------------------------*/
634 #endif
struct elPort_st elPortTbl[EL_PORT_ID_MAX]
Definition: openEL.c:44
struct elMotorFncTblSt * pMotor
Definition: openEL.h:29
OpenEL Common Header File 3.0.0.
HALCOMPONENT_CORE_T halComponent_core
Definition: openEL.h:163
EL_CMN_FNC_TBL_T fncTbl
Definition: openEL.h:226
#define ELMOTOR_PROPERTY
Definition: openEL_motor.h:31
ReturnCode
Definition: openEL.h:44
uint32_t physicalPortID
Definition: openEL.h:225
float32_t halfloat
Definition: openEL.h:53
enum ReturnCode HalGetPosition(HALCOMPONENT_T *halComponent, halfloat *position)
Definition: openEL_motor.c:69
int32_t elGetPhyicalPortID(uint32_t portID, uint32_t PropertyID)
Definition: openEL.c:196
enum ReturnCode HalSetPosition(HALCOMPONENT_T *halComponent, halfloat position)
Definition: openEL_motor.c:41
enum ReturnCode(* pFncGetPosition)(HALCOMPONENT_T **halComponent, halfloat **position)
Definition: openEL_motor.h:123
enum ReturnCode(* pFncSetPosition)(HALCOMPONENT_T **halComponent, halfloat position)
Definition: openEL_motor.h:122