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: definitions for generating instances 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: EplInstDef.h,v $ 53 54 $Author: D.Krueger $ 55 56 $Revision: 1.4 $ $Date: 2008/04/17 21:36:32 $ 57 58 $State: Exp $ 59 60 Build Environment: 61 ... 62 63 ------------------------------------------------------------------------- 64 65 Revision History: 66 67 r.d.: first implementation 68 69 ****************************************************************************/ 70 71 #ifndef _EPLINSTDEF_H_ 72 #define _EPLINSTDEF_H_ 73 74 // ========================================================================= 75 // types and macros for generating instances 76 // ========================================================================= 77 78 typedef enum { 79 kStateUnused = 0, 80 kStateDeleted = 1, 81 kStateUsed = 0xFF 82 } tInstState; 83 84 //------------------------------------------------------------------------------------------ 85 86 typedef void MEM *tEplPtrInstance; 87 typedef BYTE tEplInstanceHdl; 88 89 // define const for illegale values 90 #define CCM_ILLINSTANCE NULL 91 #define CCM_ILLINSTANCE_HDL 0xFF 92 93 //------------------------------------------------------------------------------------------ 94 // if more than one instance then use this macros 95 #if (EPL_MAX_INSTANCES > 1) 96 97 //-------------------------------------------------------------------------------------- 98 // macro definition for instance table definition 99 //-------------------------------------------------------------------------------------- 100 101 // memory attributes for instance table 102 #define INST_NEAR // faster access to variables 103 #define INST_FAR // variables wich have to located in xdata 104 #define STATIC // prevent warnings for variables with same name 105 106 #define INSTANCE_TYPE_BEGIN typedef struct { 107 #define INSTANCE_TYPE_END } tEplInstanceInfo; 108 109 //-------------------------------------------------------------------------------------- 110 // macro definition for API interface 111 //-------------------------------------------------------------------------------------- 112 113 // declaration: 114 115 // macros for declaration within function header or prototype of API functions 116 #define CCM_DECL_INSTANCE_HDL tEplInstanceHdl InstanceHandle 117 #define CCM_DECL_INSTANCE_HDL_ tEplInstanceHdl InstanceHandle, 118 119 // macros for declaration of pointer to instance handle within function header or prototype of API functions 120 #define CCM_DECL_PTR_INSTANCE_HDL tEplInstanceHdl MEM* pInstanceHandle 121 #define CCM_DECL_PTR_INSTANCE_HDL_ tEplInstanceHdl MEM* pInstanceHandle, 122 123 // macros for declaration instance as lokacl variable within functions 124 #define CCM_DECL_INSTANCE_PTR_LOCAL tCcmInstanceInfo MEM* pInstance; 125 #define CCM_DECL_PTR_INSTANCE_HDL_LOCAL tEplInstanceHdl MEM* pInstanceHandle; 126 127 // reference: 128 129 // macros for reference of instance handle for function parameters 130 #define CCM_INSTANCE_HDL InstanceHandle 131 #define CCM_INSTANCE_HDL_ InstanceHandle, 132 133 // macros for reference of instance parameter for function parameters 134 #define CCM_INSTANCE_PARAM(par) par 135 #define CCM_INSTANCE_PARAM_(par) par, 136 137 // macros for reference of instance parameter for writing or reading values 138 #define CCM_INST_ENTRY (*((tEplPtrInstance)pInstance)) 139 140 // processing: 141 142 // macros for process instance handle 143 #define CCM_CHECK_INSTANCE_HDL() if (InstanceHandle >= EPL_MAX_INSTANCES) \ 144 {return (kEplIllegalInstance);} 145 146 // macros for process pointer to instance handle 147 #define CCM_CHECK_PTR_INSTANCE_HDL() if (pInstanceHandle == NULL) \ 148 {return (kEplInvalidInstanceParam);} 149 150 // This macro returned the handle and pointer to next free instance. 151 #define CCM_GET_FREE_INSTANCE_AND_HDL() pInstance = CcmGetFreeInstanceAndHandle (pInstanceHandle); \ 152 ASSERT (*pInstanceHandle != CCM_ILLINSTANCE_HDL); 153 154 #define CCM_CHECK_INSTANCE_PTR() if (pInstance == CCM_ILLINSTANCE) \ 155 {return (kEplNoFreeInstance);} 156 157 #define CCM_GET_INSTANCE_PTR() pInstance = CcmGetInstancePtr (InstanceHandle); 158 #define CCM_GET_FREE_INSTANCE_PTR() pInstance = GetFreeInstance (); \ 159 ASSERT (pInstance != CCM_ILLINSTANCE); 160 161 //-------------------------------------------------------------------------------------- 162 // macro definition for stack interface 163 //-------------------------------------------------------------------------------------- 164 165 // macros for declaration within the function header, prototype or local var list 166 // Declaration of pointers within function paramater list must defined as void MEM* 167 // pointer. 168 #define EPL_MCO_DECL_INSTANCE_PTR void MEM* pInstance 169 #define EPL_MCO_DECL_INSTANCE_PTR_ void MEM* pInstance, 170 #define EPL_MCO_DECL_INSTANCE_PTR_LOCAL tEplPtrInstance pInstance; 171 172 // macros for reference of pointer to instance 173 // These macros are used for parameter passing to called function. 174 #define EPL_MCO_INSTANCE_PTR pInstance 175 #define EPL_MCO_INSTANCE_PTR_ pInstance, 176 #define EPL_MCO_ADDR_INSTANCE_PTR_ &pInstance, 177 178 // macro for access of struct members of one instance 179 // An access to a member of instance table must be casted by the local 180 // defined type of instance table. 181 #define EPL_MCO_INST_ENTRY (*(tEplPtrInstance)pInstance) 182 #define EPL_MCO_GLB_VAR(var) (((tEplPtrInstance)pInstance)->var) 183 184 // macros for process pointer to instance 185 #define EPL_MCO_GET_INSTANCE_PTR() pInstance = (tEplPtrInstance) GetInstancePtr (InstanceHandle); 186 #define EPL_MCO_GET_FREE_INSTANCE_PTR() pInstance = (tEplPtrInstance) GetFreeInstance (); \ 187 ASSERT (pInstance != CCM_ILLINSTANCE); 188 189 // This macro should be used to check the passed pointer to an public function 190 #define EPL_MCO_CHECK_INSTANCE_STATE() ASSERT (pInstance != NULL); \ 191 ASSERT (((tEplPtrInstance)pInstance)->m_InstState == kStateUsed); 192 193 // macros for declaration of pointer to instance pointer 194 #define EPL_MCO_DECL_PTR_INSTANCE_PTR void MEM* MEM* pInstancePtr 195 #define EPL_MCO_DECL_PTR_INSTANCE_PTR_ void MEM* MEM* pInstancePtr, 196 197 // macros for reference of pointer to instance pointer 198 // These macros are used for parameter passing to called function. 199 #define EPL_MCO_PTR_INSTANCE_PTR pInstancePtr 200 #define EPL_MCO_PTR_INSTANCE_PTR_ pInstancePtr, 201 202 // macros for process pointer to instance pointer 203 #define EPL_MCO_CHECK_PTR_INSTANCE_PTR() ASSERT (pInstancePtr != NULL); 204 #define EPL_MCO_SET_PTR_INSTANCE_PTR() (*pInstancePtr = pInstance); 205 206 #define EPL_MCO_INSTANCE_PARAM(a) (a) 207 #define EPL_MCO_INSTANCE_PARAM_(a) (a), 208 #define EPL_MCO_INSTANCE_PARAM_IDX_() EPL_MCO_INSTANCE_PARAM_ (EPL_MCO_GLB_VAR (m_bInstIndex)) 209 #define EPL_MCO_INSTANCE_PARAM_IDX() EPL_MCO_INSTANCE_PARAM (EPL_MCO_GLB_VAR (m_bInstIndex)) 210 #define EPL_MCO_WRITE_INSTANCE_STATE(a) EPL_MCO_GLB_VAR (m_InstState) = a; 211 212 // this macro deletes all instance entries as unused 213 #define EPL_MCO_DELETE_INSTANCE_TABLE() \ 214 { \ 215 tEplInstanceInfo MEM* pInstance = &aEplInstanceTable_g[0]; \ 216 tFastByte InstNumber = 0; \ 217 tFastByte i = EPL_MAX_INSTANCES; \ 218 do { \ 219 pInstance->m_InstState = (BYTE) kStateUnused; \ 220 pInstance->m_bInstIndex = (BYTE) InstNumber; \ 221 pInstance++; InstNumber++; i--; \ 222 } while (i != 0); \ 223 } 224 225 // definition of functions which has to be defined in each module of CANopen stack 226 #define EPL_MCO_DEFINE_INSTANCE_FCT() \ 227 static tEplPtrInstance GetInstancePtr (tEplInstanceHdl InstHandle_p); \ 228 static tEplPtrInstance GetFreeInstance (void); 229 #define EPL_MCO_DECL_INSTANCE_FCT() \ 230 static tEplPtrInstance GetInstancePtr (tEplInstanceHdl InstHandle_p) { \ 231 return &aEplInstanceTable_g[InstHandle_p]; } \ 232 static tEplPtrInstance GetFreeInstance (void) { \ 233 tEplInstanceInfo MEM* pInstance = &aEplInstanceTable_g[0]; \ 234 tFastByte i = EPL_MAX_INSTANCES; \ 235 do { if (pInstance->m_InstState != kStateUsed) { \ 236 return (tEplPtrInstance) pInstance; } \ 237 pInstance++; i--; } \ 238 while (i != 0); \ 239 return CCM_ILLINSTANCE; } 240 241 // this macro defines the instance table. Each entry is reserved for an instance of CANopen. 242 #define EPL_MCO_DECL_INSTANCE_VAR() \ 243 static tEplInstanceInfo MEM aEplInstanceTable_g [EPL_MAX_INSTANCES]; 244 245 // this macro defines member variables in instance table which are needed in 246 // all modules of Epl stack 247 #define EPL_MCO_DECL_INSTANCE_MEMBER() \ 248 STATIC BYTE m_InstState; \ 249 STATIC BYTE m_bInstIndex; 250 251 #define EPL_MCO_INSTANCE_PARAM_IDX_() EPL_MCO_INSTANCE_PARAM_ (EPL_MCO_GLB_VAR (m_bInstIndex)) 252 #define EPL_MCO_INSTANCE_PARAM_IDX() EPL_MCO_INSTANCE_PARAM (EPL_MCO_GLB_VAR (m_bInstIndex)) 253 254 #else // only one instance is used 255 256 // Memory attributes for instance table. 257 #define INST_NEAR NEAR // faster access to variables 258 #define INST_FAR MEM // variables wich have to located in xdata 259 #define STATIC static // prevent warnings for variables with same name 260 261 #define INSTANCE_TYPE_BEGIN 262 #define INSTANCE_TYPE_END 263 264 // macros for declaration, initializing and member access for instance handle 265 // This class of macros are used by API function to inform CCM-modul which 266 // instance is to be used. 267 268 // macros for reference of instance handle 269 // These macros are used for parameter passing to CANopen API function. 270 #define CCM_INSTANCE_HDL 271 #define CCM_INSTANCE_HDL_ 272 273 #define CCM_DECL_INSTANCE_PTR_LOCAL 274 275 // macros for declaration within the function header or prototype 276 #define CCM_DECL_INSTANCE_HDL void 277 #define CCM_DECL_INSTANCE_HDL_ 278 279 // macros for process instance handle 280 #define CCM_CHECK_INSTANCE_HDL() 281 282 // macros for declaration of pointer to instance handle 283 #define CCM_DECL_PTR_INSTANCE_HDL void 284 #define CCM_DECL_PTR_INSTANCE_HDL_ 285 286 // macros for process pointer to instance handle 287 #define CCM_CHECK_PTR_INSTANCE_HDL() 288 289 // This macro returned the handle and pointer to next free instance. 290 #define CCM_GET_FREE_INSTANCE_AND_HDL() 291 292 #define CCM_CHECK_INSTANCE_PTR() 293 294 #define CCM_GET_INSTANCE_PTR() 295 #define CCM_GET_FREE_INSTANCE_PTR() 296 297 #define CCM_INSTANCE_PARAM(par) 298 #define CCM_INSTANCE_PARAM_(par) 299 300 #define CCM_INST_ENTRY aCcmInstanceTable_g[0] 301 302 // macros for declaration, initializing and member access for instance pointer 303 // This class of macros are used by CANopen internal function to point to one instance. 304 305 // macros for declaration within the function header, prototype or local var list 306 #define EPL_MCO_DECL_INSTANCE_PTR void 307 #define EPL_MCO_DECL_INSTANCE_PTR_ 308 #define EPL_MCO_DECL_INSTANCE_PTR_LOCAL 309 310 // macros for reference of pointer to instance 311 // These macros are used for parameter passing to called function. 312 #define EPL_MCO_INSTANCE_PTR 313 #define EPL_MCO_INSTANCE_PTR_ 314 #define EPL_MCO_ADDR_INSTANCE_PTR_ 315 316 // macros for process pointer to instance 317 #define EPL_MCO_GET_INSTANCE_PTR() 318 #define EPL_MCO_GET_FREE_INSTANCE_PTR() 319 320 // This macro should be used to check the passed pointer to an public function 321 #define EPL_MCO_CHECK_INSTANCE_STATE() 322 323 // macros for declaration of pointer to instance pointer 324 #define EPL_MCO_DECL_PTR_INSTANCE_PTR void 325 #define EPL_MCO_DECL_PTR_INSTANCE_PTR_ 326 327 // macros for reference of pointer to instance pointer 328 // These macros are used for parameter passing to called function. 329 #define EPL_MCO_PTR_INSTANCE_PTR 330 #define EPL_MCO_PTR_INSTANCE_PTR_ 331 332 // macros for process pointer to instance pointer 333 #define EPL_MCO_CHECK_PTR_INSTANCE_PTR() 334 #define EPL_MCO_SET_PTR_INSTANCE_PTR() 335 336 #define EPL_MCO_INSTANCE_PARAM(a) 337 #define EPL_MCO_INSTANCE_PARAM_(a) 338 #define EPL_MCO_INSTANCE_PARAM_IDX_() 339 #define EPL_MCO_INSTANCE_PARAM_IDX() 340 341 // macro for access of struct members of one instance 342 #define EPL_MCO_INST_ENTRY aEplInstanceTable_g[0] 343 #define EPL_MCO_GLB_VAR(var) (var) 344 #define EPL_MCO_WRITE_INSTANCE_STATE(a) 345 346 // this macro deletes all instance entries as unused 347 #define EPL_MCO_DELETE_INSTANCE_TABLE() 348 349 // definition of functions which has to be defined in each module of CANopen stack 350 #define EPL_MCO_DEFINE_INSTANCE_FCT() 351 #define EPL_MCO_DECL_INSTANCE_FCT() 352 353 // this macro defines the instance table. Each entry is reserved for an instance of CANopen. 354 #define EPL_MCO_DECL_INSTANCE_VAR() 355 356 // this macro defines member variables in instance table which are needed in 357 // all modules of CANopen stack 358 #define EPL_MCO_DECL_INSTANCE_MEMBER() 359 360 #endif 361 362 /* 363 #if (CDRV_MAX_INSTANCES > 1) 364 365 #define CDRV_REENTRANT REENTRANT 366 367 #else 368 369 #define CDRV_REENTRANT 370 371 #endif 372 */ 373 374 #endif // _EPLINSTDEF_H_ 375 376 // Die letzte Zeile mu� unbedingt eine leere Zeile sein, weil manche Compiler 377 // damit ein Problem haben, wenn das nicht so ist (z.B. GNU oder Borland C++ Builder). 378