| /**************************************************************************** | |
| (c) SYSTEC electronic GmbH, D-07973 Greiz, August-Bebel-Str. 29 | |
| www.systec-electronic.com | |
| Project: openPOWERLINK | |
| Description: definitions for generating instances | |
| License: | |
| Redistribution and use in source and binary forms, with or without | |
| modification, are permitted provided that the following conditions | |
| are met: | |
| 1. Redistributions of source code must retain the above copyright | |
| notice, this list of conditions and the following disclaimer. | |
| 2. 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. | |
| 3. Neither the name of SYSTEC electronic GmbH nor the names of its | |
| contributors may be used to endorse or promote products derived | |
| from this software without prior written permission. For written | |
| permission, please contact info@systec-electronic.com. | |
| 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 HOLDERS 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. | |
| Severability Clause: | |
| If a provision of this License is or becomes illegal, invalid or | |
| unenforceable in any jurisdiction, that shall not affect: | |
| 1. the validity or enforceability in that jurisdiction of any other | |
| provision of this License; or | |
| 2. the validity or enforceability in other jurisdictions of that or | |
| any other provision of this License. | |
| ------------------------------------------------------------------------- | |
| $RCSfile: EplInstDef.h,v $ | |
| $Author: D.Krueger $ | |
| $Revision: 1.4 $ $Date: 2008/04/17 21:36:32 $ | |
| $State: Exp $ | |
| Build Environment: | |
| ... | |
| ------------------------------------------------------------------------- | |
| Revision History: | |
| r.d.: first implementation | |
| ****************************************************************************/ | |
| #ifndef _EPLINSTDEF_H_ | |
| #define _EPLINSTDEF_H_ | |
| // ========================================================================= | |
| // types and macros for generating instances | |
| // ========================================================================= | |
| typedef enum { | |
| kStateUnused = 0, | |
| kStateDeleted = 1, | |
| kStateUsed = 0xFF | |
| } tInstState; | |
| //------------------------------------------------------------------------------------------ | |
| typedef void MEM *tEplPtrInstance; | |
| typedef BYTE tEplInstanceHdl; | |
| // define const for illegale values | |
| #define CCM_ILLINSTANCE NULL | |
| #define CCM_ILLINSTANCE_HDL 0xFF | |
| //------------------------------------------------------------------------------------------ | |
| // if more than one instance then use this macros | |
| #if (EPL_MAX_INSTANCES > 1) | |
| //-------------------------------------------------------------------------------------- | |
| // macro definition for instance table definition | |
| //-------------------------------------------------------------------------------------- | |
| // memory attributes for instance table | |
| #define INST_NEAR // faster access to variables | |
| #define INST_FAR // variables wich have to located in xdata | |
| #define STATIC // prevent warnings for variables with same name | |
| #define INSTANCE_TYPE_BEGIN typedef struct { | |
| #define INSTANCE_TYPE_END } tEplInstanceInfo; | |
| //-------------------------------------------------------------------------------------- | |
| // macro definition for API interface | |
| //-------------------------------------------------------------------------------------- | |
| // declaration: | |
| // macros for declaration within function header or prototype of API functions | |
| #define CCM_DECL_INSTANCE_HDL tEplInstanceHdl InstanceHandle | |
| #define CCM_DECL_INSTANCE_HDL_ tEplInstanceHdl InstanceHandle, | |
| // macros for declaration of pointer to instance handle within function header or prototype of API functions | |
| #define CCM_DECL_PTR_INSTANCE_HDL tEplInstanceHdl MEM* pInstanceHandle | |
| #define CCM_DECL_PTR_INSTANCE_HDL_ tEplInstanceHdl MEM* pInstanceHandle, | |
| // macros for declaration instance as lokacl variable within functions | |
| #define CCM_DECL_INSTANCE_PTR_LOCAL tCcmInstanceInfo MEM* pInstance; | |
| #define CCM_DECL_PTR_INSTANCE_HDL_LOCAL tEplInstanceHdl MEM* pInstanceHandle; | |
| // reference: | |
| // macros for reference of instance handle for function parameters | |
| #define CCM_INSTANCE_HDL InstanceHandle | |
| #define CCM_INSTANCE_HDL_ InstanceHandle, | |
| // macros for reference of instance parameter for function parameters | |
| #define CCM_INSTANCE_PARAM(par) par | |
| #define CCM_INSTANCE_PARAM_(par) par, | |
| // macros for reference of instance parameter for writing or reading values | |
| #define CCM_INST_ENTRY (*((tEplPtrInstance)pInstance)) | |
| // processing: | |
| // macros for process instance handle | |
| #define CCM_CHECK_INSTANCE_HDL() if (InstanceHandle >= EPL_MAX_INSTANCES) \ | |
| {return (kEplIllegalInstance);} | |
| // macros for process pointer to instance handle | |
| #define CCM_CHECK_PTR_INSTANCE_HDL() if (pInstanceHandle == NULL) \ | |
| {return (kEplInvalidInstanceParam);} | |
| // This macro returned the handle and pointer to next free instance. | |
| #define CCM_GET_FREE_INSTANCE_AND_HDL() pInstance = CcmGetFreeInstanceAndHandle (pInstanceHandle); \ | |
| ASSERT (*pInstanceHandle != CCM_ILLINSTANCE_HDL); | |
| #define CCM_CHECK_INSTANCE_PTR() if (pInstance == CCM_ILLINSTANCE) \ | |
| {return (kEplNoFreeInstance);} | |
| #define CCM_GET_INSTANCE_PTR() pInstance = CcmGetInstancePtr (InstanceHandle); | |
| #define CCM_GET_FREE_INSTANCE_PTR() pInstance = GetFreeInstance (); \ | |
| ASSERT (pInstance != CCM_ILLINSTANCE); | |
| //-------------------------------------------------------------------------------------- | |
| // macro definition for stack interface | |
| //-------------------------------------------------------------------------------------- | |
| // macros for declaration within the function header, prototype or local var list | |
| // Declaration of pointers within function paramater list must defined as void MEM* | |
| // pointer. | |
| #define EPL_MCO_DECL_INSTANCE_PTR void MEM* pInstance | |
| #define EPL_MCO_DECL_INSTANCE_PTR_ void MEM* pInstance, | |
| #define EPL_MCO_DECL_INSTANCE_PTR_LOCAL tEplPtrInstance pInstance; | |
| // macros for reference of pointer to instance | |
| // These macros are used for parameter passing to called function. | |
| #define EPL_MCO_INSTANCE_PTR pInstance | |
| #define EPL_MCO_INSTANCE_PTR_ pInstance, | |
| #define EPL_MCO_ADDR_INSTANCE_PTR_ &pInstance, | |
| // macro for access of struct members of one instance | |
| // An access to a member of instance table must be casted by the local | |
| // defined type of instance table. | |
| #define EPL_MCO_INST_ENTRY (*(tEplPtrInstance)pInstance) | |
| #define EPL_MCO_GLB_VAR(var) (((tEplPtrInstance)pInstance)->var) | |
| // macros for process pointer to instance | |
| #define EPL_MCO_GET_INSTANCE_PTR() pInstance = (tEplPtrInstance) GetInstancePtr (InstanceHandle); | |
| #define EPL_MCO_GET_FREE_INSTANCE_PTR() pInstance = (tEplPtrInstance) GetFreeInstance (); \ | |
| ASSERT (pInstance != CCM_ILLINSTANCE); | |
| // This macro should be used to check the passed pointer to an public function | |
| #define EPL_MCO_CHECK_INSTANCE_STATE() ASSERT (pInstance != NULL); \ | |
| ASSERT (((tEplPtrInstance)pInstance)->m_InstState == kStateUsed); | |
| // macros for declaration of pointer to instance pointer | |
| #define EPL_MCO_DECL_PTR_INSTANCE_PTR void MEM* MEM* pInstancePtr | |
| #define EPL_MCO_DECL_PTR_INSTANCE_PTR_ void MEM* MEM* pInstancePtr, | |
| // macros for reference of pointer to instance pointer | |
| // These macros are used for parameter passing to called function. | |
| #define EPL_MCO_PTR_INSTANCE_PTR pInstancePtr | |
| #define EPL_MCO_PTR_INSTANCE_PTR_ pInstancePtr, | |
| // macros for process pointer to instance pointer | |
| #define EPL_MCO_CHECK_PTR_INSTANCE_PTR() ASSERT (pInstancePtr != NULL); | |
| #define EPL_MCO_SET_PTR_INSTANCE_PTR() (*pInstancePtr = pInstance); | |
| #define EPL_MCO_INSTANCE_PARAM(a) (a) | |
| #define EPL_MCO_INSTANCE_PARAM_(a) (a), | |
| #define EPL_MCO_INSTANCE_PARAM_IDX_() EPL_MCO_INSTANCE_PARAM_ (EPL_MCO_GLB_VAR (m_bInstIndex)) | |
| #define EPL_MCO_INSTANCE_PARAM_IDX() EPL_MCO_INSTANCE_PARAM (EPL_MCO_GLB_VAR (m_bInstIndex)) | |
| #define EPL_MCO_WRITE_INSTANCE_STATE(a) EPL_MCO_GLB_VAR (m_InstState) = a; | |
| // this macro deletes all instance entries as unused | |
| #define EPL_MCO_DELETE_INSTANCE_TABLE() \ | |
| { \ | |
| tEplInstanceInfo MEM* pInstance = &aEplInstanceTable_g[0]; \ | |
| tFastByte InstNumber = 0; \ | |
| tFastByte i = EPL_MAX_INSTANCES; \ | |
| do { \ | |
| pInstance->m_InstState = (BYTE) kStateUnused; \ | |
| pInstance->m_bInstIndex = (BYTE) InstNumber; \ | |
| pInstance++; InstNumber++; i--; \ | |
| } while (i != 0); \ | |
| } | |
| // definition of functions which has to be defined in each module of CANopen stack | |
| #define EPL_MCO_DEFINE_INSTANCE_FCT() \ | |
| static tEplPtrInstance GetInstancePtr (tEplInstanceHdl InstHandle_p); \ | |
| static tEplPtrInstance GetFreeInstance (void); | |
| #define EPL_MCO_DECL_INSTANCE_FCT() \ | |
| static tEplPtrInstance GetInstancePtr (tEplInstanceHdl InstHandle_p) { \ | |
| return &aEplInstanceTable_g[InstHandle_p]; } \ | |
| static tEplPtrInstance GetFreeInstance (void) { \ | |
| tEplInstanceInfo MEM* pInstance = &aEplInstanceTable_g[0]; \ | |
| tFastByte i = EPL_MAX_INSTANCES; \ | |
| do { if (pInstance->m_InstState != kStateUsed) { \ | |
| return (tEplPtrInstance) pInstance; } \ | |
| pInstance++; i--; } \ | |
| while (i != 0); \ | |
| return CCM_ILLINSTANCE; } | |
| // this macro defines the instance table. Each entry is reserved for an instance of CANopen. | |
| #define EPL_MCO_DECL_INSTANCE_VAR() \ | |
| static tEplInstanceInfo MEM aEplInstanceTable_g [EPL_MAX_INSTANCES]; | |
| // this macro defines member variables in instance table which are needed in | |
| // all modules of Epl stack | |
| #define EPL_MCO_DECL_INSTANCE_MEMBER() \ | |
| STATIC BYTE m_InstState; \ | |
| STATIC BYTE m_bInstIndex; | |
| #define EPL_MCO_INSTANCE_PARAM_IDX_() EPL_MCO_INSTANCE_PARAM_ (EPL_MCO_GLB_VAR (m_bInstIndex)) | |
| #define EPL_MCO_INSTANCE_PARAM_IDX() EPL_MCO_INSTANCE_PARAM (EPL_MCO_GLB_VAR (m_bInstIndex)) | |
| #else // only one instance is used | |
| // Memory attributes for instance table. | |
| #define INST_NEAR NEAR // faster access to variables | |
| #define INST_FAR MEM // variables wich have to located in xdata | |
| #define STATIC static // prevent warnings for variables with same name | |
| #define INSTANCE_TYPE_BEGIN | |
| #define INSTANCE_TYPE_END | |
| // macros for declaration, initializing and member access for instance handle | |
| // This class of macros are used by API function to inform CCM-modul which | |
| // instance is to be used. | |
| // macros for reference of instance handle | |
| // These macros are used for parameter passing to CANopen API function. | |
| #define CCM_INSTANCE_HDL | |
| #define CCM_INSTANCE_HDL_ | |
| #define CCM_DECL_INSTANCE_PTR_LOCAL | |
| // macros for declaration within the function header or prototype | |
| #define CCM_DECL_INSTANCE_HDL void | |
| #define CCM_DECL_INSTANCE_HDL_ | |
| // macros for process instance handle | |
| #define CCM_CHECK_INSTANCE_HDL() | |
| // macros for declaration of pointer to instance handle | |
| #define CCM_DECL_PTR_INSTANCE_HDL void | |
| #define CCM_DECL_PTR_INSTANCE_HDL_ | |
| // macros for process pointer to instance handle | |
| #define CCM_CHECK_PTR_INSTANCE_HDL() | |
| // This macro returned the handle and pointer to next free instance. | |
| #define CCM_GET_FREE_INSTANCE_AND_HDL() | |
| #define CCM_CHECK_INSTANCE_PTR() | |
| #define CCM_GET_INSTANCE_PTR() | |
| #define CCM_GET_FREE_INSTANCE_PTR() | |
| #define CCM_INSTANCE_PARAM(par) | |
| #define CCM_INSTANCE_PARAM_(par) | |
| #define CCM_INST_ENTRY aCcmInstanceTable_g[0] | |
| // macros for declaration, initializing and member access for instance pointer | |
| // This class of macros are used by CANopen internal function to point to one instance. | |
| // macros for declaration within the function header, prototype or local var list | |
| #define EPL_MCO_DECL_INSTANCE_PTR void | |
| #define EPL_MCO_DECL_INSTANCE_PTR_ | |
| #define EPL_MCO_DECL_INSTANCE_PTR_LOCAL | |
| // macros for reference of pointer to instance | |
| // These macros are used for parameter passing to called function. | |
| #define EPL_MCO_INSTANCE_PTR | |
| #define EPL_MCO_INSTANCE_PTR_ | |
| #define EPL_MCO_ADDR_INSTANCE_PTR_ | |
| // macros for process pointer to instance | |
| #define EPL_MCO_GET_INSTANCE_PTR() | |
| #define EPL_MCO_GET_FREE_INSTANCE_PTR() | |
| // This macro should be used to check the passed pointer to an public function | |
| #define EPL_MCO_CHECK_INSTANCE_STATE() | |
| // macros for declaration of pointer to instance pointer | |
| #define EPL_MCO_DECL_PTR_INSTANCE_PTR void | |
| #define EPL_MCO_DECL_PTR_INSTANCE_PTR_ | |
| // macros for reference of pointer to instance pointer | |
| // These macros are used for parameter passing to called function. | |
| #define EPL_MCO_PTR_INSTANCE_PTR | |
| #define EPL_MCO_PTR_INSTANCE_PTR_ | |
| // macros for process pointer to instance pointer | |
| #define EPL_MCO_CHECK_PTR_INSTANCE_PTR() | |
| #define EPL_MCO_SET_PTR_INSTANCE_PTR() | |
| #define EPL_MCO_INSTANCE_PARAM(a) | |
| #define EPL_MCO_INSTANCE_PARAM_(a) | |
| #define EPL_MCO_INSTANCE_PARAM_IDX_() | |
| #define EPL_MCO_INSTANCE_PARAM_IDX() | |
| // macro for access of struct members of one instance | |
| #define EPL_MCO_INST_ENTRY aEplInstanceTable_g[0] | |
| #define EPL_MCO_GLB_VAR(var) (var) | |
| #define EPL_MCO_WRITE_INSTANCE_STATE(a) | |
| // this macro deletes all instance entries as unused | |
| #define EPL_MCO_DELETE_INSTANCE_TABLE() | |
| // definition of functions which has to be defined in each module of CANopen stack | |
| #define EPL_MCO_DEFINE_INSTANCE_FCT() | |
| #define EPL_MCO_DECL_INSTANCE_FCT() | |
| // this macro defines the instance table. Each entry is reserved for an instance of CANopen. | |
| #define EPL_MCO_DECL_INSTANCE_VAR() | |
| // this macro defines member variables in instance table which are needed in | |
| // all modules of CANopen stack | |
| #define EPL_MCO_DECL_INSTANCE_MEMBER() | |
| #endif | |
| /* | |
| #if (CDRV_MAX_INSTANCES > 1) | |
| #define CDRV_REENTRANT REENTRANT | |
| #else | |
| #define CDRV_REENTRANT | |
| #endif | |
| */ | |
| #endif // _EPLINSTDEF_H_ | |
| // Die letzte Zeile muß unbedingt eine leere Zeile sein, weil manche Compiler | |
| // damit ein Problem haben, wenn das nicht so ist (z.B. GNU oder Borland C++ Builder). |