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
elPortTbl
struct elPort_st elPortTbl[EL_PORT_ID_MAX]
Definition: openEL.c:44
elCommonFncTbl::pMotor
struct elMotorFncTblSt * pMotor
Definition: openEL.h:29
openEL.h
OpenEL Common Header File 3.0.0.
HalComponent::halComponent_core
HALCOMPONENT_CORE_T halComponent_core
Definition: openEL.h:163
elPort_st::fncTbl
EL_CMN_FNC_TBL_T fncTbl
Definition: openEL.h:226
ELMOTOR_PROPERTY
#define ELMOTOR_PROPERTY
Definition: openEL_motor.h:31
ReturnCode
ReturnCode
Definition: openEL.h:44
elPort_st::physicalPortID
uint32_t physicalPortID
Definition: openEL.h:225
elMotorFncTblSt
Definition: openEL_motor.h:112
halfloat
float32_t halfloat
Definition: openEL.h:53
HalComponent
Definition: openEL.h:162
HalGetPosition
enum ReturnCode HalGetPosition(HALCOMPONENT_T *halComponent, halfloat *position)
Definition: openEL_motor.c:69
elGetPhyicalPortID
int32_t elGetPhyicalPortID(uint32_t portID, uint32_t PropertyID)
Definition: openEL.c:196
HalSetPosition
enum ReturnCode HalSetPosition(HALCOMPONENT_T *halComponent, halfloat position)
Definition: openEL_motor.c:41
elMotorFncTblSt::pFncGetPosition
enum ReturnCode(* pFncGetPosition)(HALCOMPONENT_T **halComponent, halfloat **position)
Definition: openEL_motor.h:123
HAL_ERROR
Definition: openEL.h:46
elMotorFncTblSt::pFncSetPosition
enum ReturnCode(* pFncSetPosition)(HALCOMPONENT_T **halComponent, halfloat position)
Definition: openEL_motor.h:122