From 7f86ce33ef47c9136985569a894e499d87c043c9 Mon Sep 17 00:00:00 2001 From: rgruening Date: Thu, 3 Apr 2025 14:53:33 +0200 Subject: [PATCH] initial push to add extended can ids --- 301/CO_Emergency.c | 42 ++++++++++++++++++++------------ 301/CO_Emergency.h | 4 +-- 301/CO_Node_Guarding.c | 2 +- 301/CO_Node_Guarding.h | 2 +- 301/CO_PDO.c | 42 +++++++++++++++++++------------- 301/CO_PDO.h | 10 ++++---- 301/CO_SDOclient.c | 32 ++++++++++++++++-------- 301/CO_SDOclient.h | 2 +- 301/CO_SDOserver.c | 30 ++++++++++++++--------- 301/CO_SDOserver.h | 2 +- 301/CO_SYNC.c | 24 ++++++++++++------ 301/CO_SYNC.h | 4 +-- 301/CO_TIME.c | 14 ++++++++--- 301/CO_TIME.h | 2 +- 301/CO_config.h | 13 ++++++++++ 301/CO_driver.h | 50 ++++++++++++++++++++++++++------------ example/CO_driver_blank.c | 6 ++--- example/CO_driver_target.h | 10 +++++--- 18 files changed, 190 insertions(+), 101 deletions(-) diff --git a/301/CO_Emergency.c b/301/CO_Emergency.c index 614b4d3..240094c 100644 --- a/301/CO_Emergency.c +++ b/301/CO_Emergency.c @@ -28,6 +28,14 @@ #error CO_CONFIG_EM_ERR_STATUS_BITS_COUNT is not correct #endif +#if ((CO_CONFIG_EM)&CO_CONFIG_FLAG_ALLOW_EXT_ID) != 0 +#define COB_CAN_ID_MASK CO_COB_EXT_MASK +#define CO_IS_VALID_CAN_ID(cob) CO_CHECK_CAN_ID_IN_COB(cob) +#else +#define COB_CAN_ID_MASK CO_COB_STD_MASK +#define CO_IS_VALID_CAN_ID(cob) CO_CHECK_CAN_ID_IN_COB_ASSUME_STD(cob) +#endif + /* fifo buffer example for fifoSize = 7 (actual capacity = 6) * * * * 0 * * * * * @@ -58,8 +66,8 @@ OD_read_1014(OD_stream_t* stream, void* buf, OD_size_t count, OD_size_t* countRe CO_EM_t* em = (CO_EM_t*)stream->object; - uint16_t canId = (em->producerCanId == CO_CAN_ID_EMERGENCY) ? (CO_CAN_ID_EMERGENCY + em->nodeId) - : em->producerCanId; + CO_CANident_t canId = (em->producerCanId == CO_CAN_ID_EMERGENCY) ? (CO_CAN_ID_EMERGENCY + em->nodeId) + : em->producerCanId; uint32_t COB_IDEmergency32 = em->producerEnabled ? 0U : 0x80000000U; COB_IDEmergency32 |= canId; (void)CO_setUint32(buf, COB_IDEmergency32); @@ -79,18 +87,19 @@ OD_write_1014(OD_stream_t* stream, const void* buf, OD_size_t count, OD_size_t* /* Verify written value. COB ID must not change, if emergency is enabled */ uint32_t COB_IDEmergency32 = CO_getUint32(buf); - uint16_t newCanId = (uint16_t)(COB_IDEmergency32 & 0x7FFU); - uint16_t curCanId = (em->producerCanId == CO_CAN_ID_EMERGENCY) ? (CO_CAN_ID_EMERGENCY + em->nodeId) - : em->producerCanId; + CO_CANident_t newCanId = (CO_CANident_t)(COB_IDEmergency32 & COB_CAN_ID_MASK); + CO_CANident_t curCanId = (em->producerCanId == CO_CAN_ID_EMERGENCY) ? (CO_CAN_ID_EMERGENCY + em->nodeId) + : em->producerCanId; bool_t newEnabled = ((COB_IDEmergency32 & 0x80000000U) == 0U) && (newCanId != 0U); - if (((COB_IDEmergency32 & 0x7FFFF800U) != 0U) || CO_IS_RESTRICTED_CAN_ID(newCanId) - || ((em->producerEnabled && newEnabled) && (newCanId != curCanId))) { + if (!CO_IS_VALID_CAN_ID(COB_IDEmergency32) || ((COB_IDEmergency32 & 0x40000000U) != 0) + || CO_IS_RESTRICTED_CAN_ID(newCanId) || ((em->producerEnabled && newEnabled) && (newCanId != curCanId))) { return ODR_INVALID_VALUE; } /* store values. If default CAN-ID is used, then store only value of CO_CAN_ID_EMERGENCY without node id. */ em->producerEnabled = newEnabled; - em->producerCanId = (newCanId == ((uint16_t)CO_CAN_ID_EMERGENCY + em->nodeId)) ? CO_CAN_ID_EMERGENCY : newCanId; + em->producerCanId = (newCanId == ((CO_CANident_t)CO_CAN_ID_EMERGENCY + em->nodeId)) ? CO_CAN_ID_EMERGENCY + : newCanId; /* configure emergency message CAN transmission */ if (newEnabled) { @@ -280,7 +289,7 @@ CO_EM_receive(void* object, void* msg) { CO_EM_t* em = (CO_EM_t*)object; if ((em != NULL) && (em->pFunctSignalRx != NULL)) { - uint16_t ident = CO_CANrxMsg_readIdent(msg); + CO_CANident_t ident = CO_CANrxMsg_readIdent(msg); /* ignore sync messages (necessary if sync object is not used) */ if (ident != 0x80U) { @@ -363,7 +372,7 @@ CO_EM_init(CO_EM_t* em, CO_CANmodule_t* CANdevTx, const OD_entry_t* OD_1001_errR uint32_t COB_IDEmergency32; ODR_t odRet; odRet = OD_get_u32(OD_1014_cobIdEm, 0, &COB_IDEmergency32, true); - if ((odRet != ODR_OK) || ((COB_IDEmergency32 & 0x7FFFF800U) != 0U)) { + if ((odRet != ODR_OK) || !CO_IS_VALID_CAN_ID(COB_IDEmergency32) || ((COB_IDEmergency32 & 0x40000000U) != 0)) { if (errInfo != NULL) { *errInfo = OD_getIndex(OD_1014_cobIdEm); } @@ -374,7 +383,7 @@ CO_EM_init(CO_EM_t* em, CO_CANmodule_t* CANdevTx, const OD_entry_t* OD_1001_errR } #if ((CO_CONFIG_EM)&CO_CONFIG_EM_PROD_CONFIGURABLE) != 0 - uint16_t producerCanId = (uint16_t)(COB_IDEmergency32 & 0x7FFU); + CO_CANident_t producerCanId = (CO_CANident_t)(COB_IDEmergency32 & COB_CAN_ID_MASK); em->producerEnabled = ((COB_IDEmergency32 & 0x80000000U) == 0U) && (producerCanId != 0U); em->OD_1014_extension.object = em; @@ -396,7 +405,7 @@ CO_EM_init(CO_EM_t* em, CO_CANmodule_t* CANdevTx, const OD_entry_t* OD_1001_errR producerCanId += nodeId; } #else - uint16_t producerCanId = CO_CAN_ID_EMERGENCY + (uint16_t)nodeId; + CO_CANident_t producerCanId = (CO_CANident_t)(CO_CAN_ID_EMERGENCY + nodeId); em->producerEnabled = (COB_IDEmergency32 & 0x80000000U) == 0U; em->OD_1014_extension.object = em; @@ -456,7 +465,8 @@ CO_EM_init(CO_EM_t* em, CO_CANmodule_t* CANdevTx, const OD_entry_t* OD_1001_errR #if ((CO_CONFIG_EM)&CO_CONFIG_EM_CONSUMER) != 0 em->pFunctSignalRx = NULL; /* configure SDO server CAN reception */ - ret = CO_CANrxBufferInit(CANdevRx, CANdevRxIdx, CO_CAN_ID_EMERGENCY, 0x780, false, (void*)em, CO_EM_receive); + ret = CO_CANrxBufferInit(CANdevRx, CANdevRxIdx, CO_CAN_ID_EMERGENCY, COB_CAN_ID_MASK ^ 0x7FU, false, (void*)em, + CO_EM_receive); #endif /* (CO_CONFIG_EM) & CO_CONFIG_EM_CONSUMER */ return ret; @@ -464,9 +474,9 @@ CO_EM_init(CO_EM_t* em, CO_CANmodule_t* CANdevTx, const OD_entry_t* OD_1001_errR #if ((CO_CONFIG_EM)&CO_CONFIG_EM_CONSUMER) != 0 void -CO_EM_initCallbackRx(CO_EM_t* em, - void (*pFunctSignalRx)(const uint16_t ident, const uint16_t errorCode, const uint8_t errorRegister, - const uint8_t errorBit, const uint32_t infoCode)) { +CO_EM_initCallbackRx(CO_EM_t* em, void (*pFunctSignalRx)(const CO_CANident_t ident, const uint16_t errorCode, + const uint8_t errorRegister, const uint8_t errorBit, + const uint32_t infoCode)) { if (em != NULL) { em->pFunctSignalRx = pFunctSignalRx; } diff --git a/301/CO_Emergency.h b/301/CO_Emergency.h index c449c7c..baa133c 100644 --- a/301/CO_Emergency.h +++ b/301/CO_Emergency.h @@ -28,7 +28,7 @@ #ifndef CO_CONFIG_EM #define CO_CONFIG_EM \ (CO_CONFIG_EM_PRODUCER | CO_CONFIG_EM_HISTORY | CO_CONFIG_GLOBAL_FLAG_CALLBACK_PRE \ - | CO_CONFIG_GLOBAL_FLAG_TIMERNEXT) + | CO_CONFIG_GLOBAL_FLAG_TIMERNEXT | CO_CONFIG_GLOBAL_FLAG_ALLOW_EXT_ID) #endif #ifndef CO_CONFIG_EM_ERR_STATUS_BITS_COUNT #define CO_CONFIG_EM_ERR_STATUS_BITS_COUNT (10U * 8U) @@ -284,7 +284,7 @@ typedef struct { CO_CANtx_t* CANtxBuff; /**< CAN transmit buffer */ OD_extension_t OD_1014_extension; /**< Extension for OD object */ #if (((CO_CONFIG_EM)&CO_CONFIG_EM_PROD_CONFIGURABLE) != 0) || defined CO_DOXYGEN - uint16_t producerCanId; /**< COB ID of emergency message, from Object dictionary */ + CO_CANident_t producerCanId; /**< COB ID of emergency message, from Object dictionary */ uint16_t CANdevTxIdx; /**< From CO_EM_init() */ #endif #if (((CO_CONFIG_EM)&CO_CONFIG_EM_PROD_INHIBIT) != 0) || defined CO_DOXYGEN diff --git a/301/CO_Node_Guarding.c b/301/CO_Node_Guarding.c index e7cda3d..d81f159 100644 --- a/301/CO_Node_Guarding.c +++ b/301/CO_Node_Guarding.c @@ -246,7 +246,7 @@ CO_ngm_receive(void* object, void* msg) { uint8_t DLC = CO_CANrxMsg_readDLC(msg); const uint8_t* data = CO_CANrxMsg_readData(msg); - uint16_t ident = CO_CANrxMsg_readIdent(msg); + CO_CANident_t ident = CO_CANrxMsg_readIdent(msg); CO_nodeGuardingMasterNode_t* node = &ngm->nodes[0]; if (DLC == 1) { diff --git a/301/CO_Node_Guarding.h b/301/CO_Node_Guarding.h index 467527d..734d956 100644 --- a/301/CO_Node_Guarding.h +++ b/301/CO_Node_Guarding.h @@ -167,7 +167,7 @@ extern "C" { typedef struct { uint32_t guardTime_us; /**< Guard time in microseconds */ uint32_t guardTimer; /**< Guard timer in microseconds, counting down */ - uint16_t ident; /**< CAN identifier (CO_CAN_ID_HEARTBEAT + Node Id) */ + CO_CANident_t ident; /**< CAN identifier (CO_CAN_ID_HEARTBEAT + Node Id) */ CO_NMT_internalState_t NMTstate; /**< NMT operating state */ uint8_t toggle; /**< toggle bit7, expected from the next received message */ bool_t responseRecived; /**< True, if response was received since last rtr message */ diff --git a/301/CO_PDO.c b/301/CO_PDO.c index 527618b..b03bf1d 100644 --- a/301/CO_PDO.c +++ b/301/CO_PDO.c @@ -30,6 +30,14 @@ #endif #endif +#if ((CO_CONFIG_PDO)&CO_CONFIG_FLAG_ALLOW_EXT_ID) != 0 +#define COB_CAN_ID_MASK CO_COB_EXT_MASK +#define CO_IS_VALID_CAN_ID(cob) CO_CHECK_CAN_ID_IN_COB(cob) +#else +#define COB_CAN_ID_MASK CO_COB_STD_MASK +#define CO_IS_VALID_CAN_ID(cob) CO_CHECK_CAN_ID_IN_COB_ASSUME_STD(cob) +#endif + #if ((CO_CONFIG_PDO)&CO_CONFIG_PDO_OD_IO_ACCESS) != 0 /* * Custom function for write dummy OD object. Will be used only from RPDO. @@ -385,11 +393,11 @@ OD_read_PDO_commParam(OD_stream_t* stream, void* buf, OD_size_t count, OD_size_t /* Only common part of the CO_RPDO_t or CO_TPDO_t will be used */ CO_PDO_common_t* PDO = stream->object; uint32_t COB_ID = CO_getUint32(buf); - uint16_t CAN_ID = (uint16_t)(COB_ID & 0x7FFU); + CO_CANident_t CAN_ID = (CO_CANident_t)(COB_ID & COB_CAN_ID_MASK); /* If default CAN-ID is stored in OD (without Node-ID), add Node-ID */ - if ((CAN_ID != 0U) && (CAN_ID == (PDO->preDefinedCanId & 0xFF80U))) { - COB_ID = (COB_ID & 0xFFFF0000U) | PDO->preDefinedCanId; + if ((CAN_ID != 0U) && (CAN_ID == (PDO->preDefinedCanId & (COB_CAN_ID_MASK ^ 0x7FU)))) { + COB_ID = (COB_ID & (CO_COB_BIT31 | CO_COB_BIT30)) | PDO->preDefinedCanId; } /* If PDO is not valid, set bit 31 */ @@ -499,12 +507,12 @@ OD_write_14xx(OD_stream_t* stream, const void* buf, OD_size_t count, OD_size_t* switch (stream->subIndex) { case 1: { /* COB-ID used by PDO */ uint32_t COB_ID = CO_getUint32(buf); - uint16_t CAN_ID = (uint16_t)(COB_ID & 0x7FFU); + CO_CANident_t CAN_ID = (CO_CANident_t)(COB_ID & COB_CAN_ID_MASK); bool_t valid = (COB_ID & 0x80000000U) == 0U; - /* bits 11...29 must be zero, PDO must be disabled on change, CAN_ID == 0 is + /* PDO must be disabled on change, CAN_ID == 0 is * not allowed, mapping must be configured before enabling the PDO */ - if (((COB_ID & 0x3FFFF800U) != 0U) || (valid && PDO->valid && (CAN_ID != PDO->configuredCanId)) + if (!CO_IS_VALID_CAN_ID(COB_ID) || (valid && PDO->valid && (CAN_ID != PDO->configuredCanId)) || (valid && CO_IS_RESTRICTED_CAN_ID(CAN_ID)) || (valid && (PDO->mappedObjectsCount == 0U))) { return ODR_INVALID_VALUE; } @@ -519,7 +527,7 @@ OD_write_14xx(OD_stream_t* stream, const void* buf, OD_size_t count, OD_size_t* CAN_ID = 0; } - CO_ReturnError_t ret = CO_CANrxBufferInit(PDO->CANdev, PDO->CANdevIdx, CAN_ID, 0x7FF, false, + CO_ReturnError_t ret = CO_CANrxBufferInit(PDO->CANdev, PDO->CANdevIdx, CAN_ID, COB_CAN_ID_MASK, false, (void*)RPDO, CO_PDO_receive); if (valid && (ret == CO_ERROR_NO)) { @@ -584,7 +592,7 @@ CO_RPDO_init(CO_RPDO_t* RPDO, OD_t* OD, CO_EM_t* em, #if ((CO_CONFIG_PDO)&CO_CONFIG_PDO_SYNC_ENABLE) != 0 CO_SYNC_t* SYNC, #endif - uint16_t preDefinedCanId, OD_entry_t* OD_14xx_RPDOCommPar, OD_entry_t* OD_16xx_RPDOMapPar, + CO_CANident_t preDefinedCanId, OD_entry_t* OD_14xx_RPDOCommPar, OD_entry_t* OD_16xx_RPDOMapPar, CO_CANmodule_t* CANdevRx, uint16_t CANdevRxIdx, uint32_t* errInfo) { CO_PDO_common_t* PDO = &RPDO->PDO_common; CO_ReturnError_t ret; @@ -621,7 +629,7 @@ CO_RPDO_init(CO_RPDO_t* RPDO, OD_t* OD, CO_EM_t* em, } bool_t valid = (COB_ID & 0x80000000U) == 0U; - uint16_t CAN_ID = (uint16_t)(COB_ID & 0x7FFU); + CO_CANident_t CAN_ID = (CO_CANident_t)(COB_ID & COB_CAN_ID_MASK); if (valid && ((PDO->mappedObjectsCount == 0U) || (CAN_ID == 0U))) { valid = false; if (erroneousMap == 0U) { @@ -638,11 +646,11 @@ CO_RPDO_init(CO_RPDO_t* RPDO, OD_t* OD, CO_EM_t* em, } /* If default CAN-ID is stored in OD (without Node-ID), add Node-ID */ - if ((CAN_ID != 0U) && (CAN_ID == (preDefinedCanId & 0xFF80U))) { + if ((CAN_ID != 0U) && (CAN_ID == (preDefinedCanId & COB_CAN_ID_MASK))) { CAN_ID = preDefinedCanId; } - ret = CO_CANrxBufferInit(CANdevRx, CANdevRxIdx, CAN_ID, 0x7FF, false, (void*)RPDO, CO_PDO_receive); + ret = CO_CANrxBufferInit(CANdevRx, CANdevRxIdx, CAN_ID, COB_CAN_ID_MASK, false, (void*)RPDO, CO_PDO_receive); if (ret != CO_ERROR_NO) { return ret; } @@ -888,12 +896,12 @@ OD_write_18xx(OD_stream_t* stream, const void* buf, OD_size_t count, OD_size_t* switch (stream->subIndex) { case 1: { /* COB-ID used by PDO */ uint32_t COB_ID = CO_getUint32(buf); - uint16_t CAN_ID = (uint16_t)(COB_ID & 0x7FFU); + CO_CANident_t CAN_ID = (CO_CANident_t)(COB_ID & COB_CAN_ID_MASK); bool_t valid = (COB_ID & 0x80000000U) == 0U; - /* bits 11...29 must be zero, PDO must be disabled on change, CAN_ID == 0 is + /* PDO must be disabled on change, CAN_ID == 0 is * not allowed, mapping must be configured before enabling the PDO */ - if (((COB_ID & 0x3FFFF800U) != 0U) || (valid && (PDO->valid && (CAN_ID != PDO->configuredCanId))) + if (!CO_IS_VALID_CAN_ID(COB_ID) || (valid && (PDO->valid && (CAN_ID != PDO->configuredCanId))) || (valid && CO_IS_RESTRICTED_CAN_ID(CAN_ID)) || (valid && (PDO->mappedObjectsCount == 0U))) { return ODR_INVALID_VALUE; } @@ -990,7 +998,7 @@ CO_TPDO_init(CO_TPDO_t* TPDO, OD_t* OD, CO_EM_t* em, #if ((CO_CONFIG_PDO)&CO_CONFIG_PDO_SYNC_ENABLE) != 0 CO_SYNC_t* SYNC, #endif - uint16_t preDefinedCanId, OD_entry_t* OD_18xx_TPDOCommPar, OD_entry_t* OD_1Axx_TPDOMapPar, + CO_CANident_t preDefinedCanId, OD_entry_t* OD_18xx_TPDOCommPar, OD_entry_t* OD_1Axx_TPDOMapPar, CO_CANmodule_t* CANdevTx, uint16_t CANdevTxIdx, uint32_t* errInfo) { CO_PDO_common_t* PDO = &TPDO->PDO_common; ODR_t odRet; @@ -1045,7 +1053,7 @@ CO_TPDO_init(CO_TPDO_t* TPDO, OD_t* OD, CO_EM_t* em, } bool_t valid = (COB_ID & 0x80000000U) == 0U; - uint16_t CAN_ID = (uint16_t)(COB_ID & 0x7FFU); + CO_CANident_t CAN_ID = (CO_CANident_t)(COB_ID & COB_CAN_ID_MASK); if (valid && ((PDO->mappedObjectsCount == 0U) || (CAN_ID == 0U))) { valid = false; if (erroneousMap == 0U) { @@ -1062,7 +1070,7 @@ CO_TPDO_init(CO_TPDO_t* TPDO, OD_t* OD, CO_EM_t* em, } /* If default CAN-ID is stored in OD (without Node-ID), add Node-ID */ - if ((CAN_ID != 0U) && (CAN_ID == (preDefinedCanId & 0xFF80U))) { + if ((CAN_ID != 0U) && (CAN_ID == (preDefinedCanId & (COB_CAN_ID_MASK ^ 0x7FU)))) { CAN_ID = preDefinedCanId; } diff --git a/301/CO_PDO.h b/301/CO_PDO.h index 3ce6390..fa790f8 100644 --- a/301/CO_PDO.h +++ b/301/CO_PDO.h @@ -30,7 +30,7 @@ #define CO_CONFIG_PDO \ (CO_CONFIG_RPDO_ENABLE | CO_CONFIG_TPDO_ENABLE | CO_CONFIG_RPDO_TIMERS_ENABLE | CO_CONFIG_TPDO_TIMERS_ENABLE \ | CO_CONFIG_PDO_SYNC_ENABLE | CO_CONFIG_PDO_OD_IO_ACCESS | CO_CONFIG_GLOBAL_RT_FLAG_CALLBACK_PRE \ - | CO_CONFIG_GLOBAL_FLAG_TIMERNEXT | CO_CONFIG_GLOBAL_FLAG_OD_DYNAMIC) + | CO_CONFIG_GLOBAL_FLAG_TIMERNEXT | CO_CONFIG_GLOBAL_FLAG_OD_DYNAMIC | CO_CONFIG_GLOBAL_FLAG_ALLOW_EXT_ID) #endif #if (((CO_CONFIG_PDO) & (CO_CONFIG_RPDO_ENABLE | CO_CONFIG_TPDO_ENABLE)) != 0) || defined CO_DOXYGEN @@ -180,8 +180,8 @@ typedef struct { bool_t isRPDO; /**< True for RPDO, false for TPDO */ OD_t* OD; /**< From CO_xPDO_init() */ uint16_t CANdevIdx; /**< From CO_xPDO_init() */ - uint16_t preDefinedCanId; /**< From CO_xPDO_init() */ - uint16_t configuredCanId; /**< Currently configured CAN identifier */ + CO_CANident_t preDefinedCanId; /**< From CO_xPDO_init() */ + CO_CANident_t configuredCanId; /**< Currently configured CAN identifier */ OD_extension_t OD_communicationParam_ext; /**< Extension for OD object */ OD_extension_t OD_mappingParam_extension; /**< Extension for OD object */ #endif @@ -248,7 +248,7 @@ CO_ReturnError_t CO_RPDO_init(CO_RPDO_t* RPDO, OD_t* OD, CO_EM_t* em, #if (((CO_CONFIG_PDO)&CO_CONFIG_PDO_SYNC_ENABLE) != 0) || defined CO_DOXYGEN CO_SYNC_t* SYNC, #endif - uint16_t preDefinedCanId, OD_entry_t* OD_14xx_RPDOCommPar, OD_entry_t* OD_16xx_RPDOMapPar, + CO_CANident_t preDefinedCanId, OD_entry_t* OD_14xx_RPDOCommPar, OD_entry_t* OD_16xx_RPDOMapPar, CO_CANmodule_t* CANdevRx, uint16_t CANdevRxIdx, uint32_t* errInfo); #if (((CO_CONFIG_PDO)&CO_CONFIG_FLAG_CALLBACK_PRE) != 0) || defined CO_DOXYGEN @@ -335,7 +335,7 @@ CO_ReturnError_t CO_TPDO_init(CO_TPDO_t* TPDO, OD_t* OD, CO_EM_t* em, #if (((CO_CONFIG_PDO)&CO_CONFIG_PDO_SYNC_ENABLE) != 0) || defined CO_DOXYGEN CO_SYNC_t* SYNC, #endif - uint16_t preDefinedCanId, OD_entry_t* OD_18xx_TPDOCommPar, OD_entry_t* OD_1Axx_TPDOMapPar, + CO_CANident_t preDefinedCanId, OD_entry_t* OD_18xx_TPDOCommPar, OD_entry_t* OD_1Axx_TPDOMapPar, CO_CANmodule_t* CANdevTx, uint16_t CANdevTxIdx, uint32_t* errInfo); /** diff --git a/301/CO_SDOclient.c b/301/CO_SDOclient.c index 8114631..578c7d4 100644 --- a/301/CO_SDOclient.c +++ b/301/CO_SDOclient.c @@ -47,6 +47,14 @@ #define CO_CONFIG_SDO_CLI_PST 21U #endif +#if ((CO_CONFIG_SDO_CLI)&CO_CONFIG_FLAG_ALLOW_EXT_ID) != 0 +#define COB_CAN_ID_MASK CO_COB_EXT_MASK +#define CO_IS_VALID_CAN_ID(cob) CO_CHECK_CAN_ID_IN_COB(cob) +#else +#define COB_CAN_ID_MASK CO_COB_STD_MASK +#define CO_IS_VALID_CAN_ID(cob) CO_CHECK_CAN_ID_IN_COB_ASSUME_STD(cob) +#endif + /* * Read received message from CAN module. * @@ -166,12 +174,12 @@ OD_write_1280(OD_stream_t* stream, const void* buf, OD_size_t count, OD_size_t* case 1: { /* COB-ID client -> server */ uint32_t COB_ID = CO_getUint32(buf); - uint16_t CAN_ID = (uint16_t)(COB_ID & 0x7FFU); - uint16_t CAN_ID_cur = (uint16_t)(SDO_C->COB_IDClientToServer & 0x7FFU); + CO_CANident_t CAN_ID = (CO_CANident_t)(COB_ID & COB_CAN_ID_MASK); + CO_CANident_t CAN_ID_cur = (CO_CANident_t)(SDO_C->COB_IDClientToServer & COB_CAN_ID_MASK); bool_t valid = (COB_ID & 0x80000000U) == 0U; /* SDO client must not be valid when changing COB_ID */ - if (((COB_ID & 0x3FFFF800U) != 0U) || (valid && SDO_C->valid && (CAN_ID != CAN_ID_cur)) + if (!CO_IS_VALID_CAN_ID(COB_ID) || (valid && SDO_C->valid && (CAN_ID != CAN_ID_cur)) || (valid && CO_IS_RESTRICTED_CAN_ID(CAN_ID))) { return ODR_INVALID_VALUE; } @@ -181,12 +189,12 @@ OD_write_1280(OD_stream_t* stream, const void* buf, OD_size_t count, OD_size_t* case 2: { /* COB-ID server -> client */ uint32_t COB_ID = CO_getUint32(buf); - uint16_t CAN_ID = (uint16_t)(COB_ID & 0x7FFU); - uint16_t CAN_ID_cur = (uint16_t)(SDO_C->COB_IDServerToClient & 0x7FFU); + CO_CANident_t CAN_ID = (CO_CANident_t)(COB_ID & COB_CAN_ID_MASK); + CO_CANident_t CAN_ID_cur = (CO_CANident_t)(SDO_C->COB_IDServerToClient & COB_CAN_ID_MASK); bool_t valid = (COB_ID & 0x80000000U) == 0U; /* SDO client must not be valid when changing COB_ID */ - if (((COB_ID & 0x3FFFF800U) != 0U) || (valid && SDO_C->valid && (CAN_ID != CAN_ID_cur)) + if (!CO_IS_VALID_CAN_ID(COB_ID) || (valid && SDO_C->valid && (CAN_ID != CAN_ID_cur)) || (valid && CO_IS_RESTRICTED_CAN_ID(CAN_ID))) { return ODR_INVALID_VALUE; } @@ -332,8 +340,12 @@ CO_SDOclient_setup(CO_SDOclient_t* SDO_C, uint32_t COB_IDClientToServer, uint32_ #endif /* verify valid bit */ - uint16_t CanIdC2S = ((COB_IDClientToServer & 0x80000000UL) == 0U) ? (uint16_t)(COB_IDClientToServer & 0x7FFU) : 0U; - uint16_t CanIdS2C = ((COB_IDServerToClient & 0x80000000UL) == 0U) ? (uint16_t)(COB_IDServerToClient & 0x7FFU) : 0U; + CO_CANident_t CanIdC2S = ((COB_IDClientToServer & 0x80000000UL) == 0U) + ? (CO_CANident_t)(COB_IDClientToServer & COB_CAN_ID_MASK) + : 0U; + CO_CANident_t CanIdS2C = ((COB_IDServerToClient & 0x80000000UL) == 0U) + ? (CO_CANident_t)(COB_IDServerToClient & COB_CAN_ID_MASK) + : 0U; if ((CanIdC2S != 0U) && (CanIdS2C != 0U)) { SDO_C->valid = true; } else { @@ -343,8 +355,8 @@ CO_SDOclient_setup(CO_SDOclient_t* SDO_C, uint32_t COB_IDClientToServer, uint32_ } /* configure SDO client CAN reception */ - CO_ReturnError_t ret = CO_CANrxBufferInit(SDO_C->CANdevRx, SDO_C->CANdevRxIdx, CanIdS2C, 0x7FF, false, (void*)SDO_C, - CO_SDOclient_receive); + CO_ReturnError_t ret = CO_CANrxBufferInit(SDO_C->CANdevRx, SDO_C->CANdevRxIdx, CanIdS2C, COB_CAN_ID_MASK, false, + (void*)SDO_C, CO_SDOclient_receive); /* configure SDO client CAN transmission */ SDO_C->CANtxBuff = CO_CANtxBufferInit(SDO_C->CANdevTx, SDO_C->CANdevTxIdx, CanIdC2S, false, 8, false); diff --git a/301/CO_SDOclient.h b/301/CO_SDOclient.h index c12f6c2..5e95c2a 100644 --- a/301/CO_SDOclient.h +++ b/301/CO_SDOclient.h @@ -29,7 +29,7 @@ /* default configuration, see CO_config.h */ #ifndef CO_CONFIG_SDO_CLI -#define CO_CONFIG_SDO_CLI (0) +#define CO_CONFIG_SDO_CLI (CO_CONFIG_GLOBAL_FLAG_ALLOW_EXT_ID) #endif #ifndef CO_DOXYGEN diff --git a/301/CO_SDOserver.c b/301/CO_SDOserver.c index 369168b..0e295ff 100644 --- a/301/CO_SDOserver.c +++ b/301/CO_SDOserver.c @@ -41,6 +41,14 @@ #endif #endif +#if ((CO_CONFIG_SDO_SRV)&CO_CONFIG_FLAG_ALLOW_EXT_ID) != 0 +#define COB_CAN_ID_MASK CO_COB_EXT_MASK +#define CO_IS_VALID_CAN_ID(cob) CO_CHECK_CAN_ID_IN_COB(cob) +#else +#define COB_CAN_ID_MASK CO_COB_STD_MASK +#define CO_IS_VALID_CAN_ID(cob) CO_CHECK_CAN_ID_IN_COB_ASSUME_STD(cob) +#endif + /* * Read received message from CAN module. * @@ -157,8 +165,8 @@ CO_SDOserver_init_canRxTx(CO_SDOserver_t* SDO, CO_CANmodule_t* CANdevRx, uint16_ #endif /* verify valid bit */ - uint16_t idC2S = ((COB_IDClientToServer & 0x80000000UL) == 0U) ? (uint16_t)COB_IDClientToServer : 0U; - uint16_t idS2C = ((COB_IDServerToClient & 0x80000000UL) == 0U) ? (uint16_t)COB_IDServerToClient : 0U; + CO_CANident_t idC2S = ((COB_IDClientToServer & 0x80000000UL) == 0U) ? (CO_CANident_t)(COB_IDClientToServer & COB_CAN_ID_MASK) : 0U; + CO_CANident_t idS2C = ((COB_IDServerToClient & 0x80000000UL) == 0U) ? (CO_CANident_t)(COB_IDServerToClient & COB_CAN_ID_MASK) : 0U; if ((idC2S != 0U) && (idS2C != 0U)) { SDO->valid = true; } else { @@ -168,7 +176,7 @@ CO_SDOserver_init_canRxTx(CO_SDOserver_t* SDO, CO_CANmodule_t* CANdevRx, uint16_ } /* configure SDO server CAN reception */ - CO_ReturnError_t ret = CO_CANrxBufferInit(CANdevRx, CANdevRxIdx, idC2S, 0x7FF, false, (void*)SDO, CO_SDO_receive); + CO_ReturnError_t ret = CO_CANrxBufferInit(CANdevRx, CANdevRxIdx, idC2S, COB_CAN_ID_MASK, false, (void*)SDO, CO_SDO_receive); /* configure SDO server CAN transmission */ SDO->CANtxBuff = CO_CANtxBufferInit(SDO->CANdevTx, CANdevTxIdx, idS2C, false, 8, false); @@ -201,12 +209,12 @@ OD_write_1201_additional(OD_stream_t* stream, const void* buf, OD_size_t count, case 1: { /* COB-ID client -> server */ uint32_t COB_ID = CO_getUint32(buf); - uint16_t CAN_ID = (uint16_t)(COB_ID & 0x7FFU); - uint16_t CAN_ID_cur = (uint16_t)(SDO->COB_IDClientToServer & 0x7FFU); + CO_CANident_t CAN_ID = (CO_CANident_t)(COB_ID & COB_CAN_ID_MASK); + CO_CANident_t CAN_ID_cur = (CO_CANident_t)(SDO->COB_IDClientToServer & COB_CAN_ID_MASK); bool_t valid = (COB_ID & 0x80000000U) == 0U; /* SDO client must not be valid when changing COB_ID */ - if (((COB_ID & 0x3FFFF800U) != 0U) || ((valid && SDO->valid) && (CAN_ID != CAN_ID_cur)) + if (CO_IS_VALID_CAN_ID(COB_ID) || ((valid && SDO->valid) && (CAN_ID != CAN_ID_cur)) || (valid && CO_IS_RESTRICTED_CAN_ID(CAN_ID))) { return ODR_INVALID_VALUE; } @@ -217,12 +225,12 @@ OD_write_1201_additional(OD_stream_t* stream, const void* buf, OD_size_t count, case 2: { /* COB-ID server -> client */ uint32_t COB_ID = CO_getUint32(buf); - uint16_t CAN_ID = (uint16_t)(COB_ID & 0x7FFU); - uint16_t CAN_ID_cur = (uint16_t)(SDO->COB_IDServerToClient & 0x7FFU); + CO_CANident_t CAN_ID = (CO_CANident_t)(COB_ID & COB_CAN_ID_MASK); + CO_CANident_t CAN_ID_cur = (CO_CANident_t)(SDO->COB_IDServerToClient & COB_CAN_ID_MASK); bool_t valid = (COB_ID & 0x80000000U) == 0U; /* SDO client must not be valid when changing COB_ID */ - if (((COB_ID & 0x3FFFF800U) != 0U) || (valid && (SDO->valid && (CAN_ID != CAN_ID_cur))) + if (CO_IS_VALID_CAN_ID(COB_ID) || (valid && (SDO->valid && (CAN_ID != CAN_ID_cur))) || (valid && CO_IS_RESTRICTED_CAN_ID(CAN_ID))) { return ODR_INVALID_VALUE; } @@ -322,10 +330,10 @@ CO_SDOserver_init(CO_SDOserver_t* SDO, OD_t* OD, OD_entry_t* OD_1200_SDOsrvPar, } CanId_ClientToServer = ((COB_IDClientToServer32 & 0x80000000U) == 0U) - ? (uint16_t)(COB_IDClientToServer32 & 0x7FFU) + ? (CO_CANident_t)(COB_IDClientToServer32 & COB_CAN_ID_MASK) : 0U; CanId_ServerToClient = ((COB_IDServerToClient32 & 0x80000000U) == 0U) - ? (uint16_t)(COB_IDServerToClient32 & 0x7FFU) + ? (CO_CANident_t)(COB_IDServerToClient32 & COB_CAN_ID_MASK) : 0U; #if ((CO_CONFIG_SDO_SRV)&CO_CONFIG_FLAG_OD_DYNAMIC) != 0 diff --git a/301/CO_SDOserver.h b/301/CO_SDOserver.h index 5193aac..6c3e3bc 100644 --- a/301/CO_SDOserver.h +++ b/301/CO_SDOserver.h @@ -28,7 +28,7 @@ #ifndef CO_CONFIG_SDO_SRV #define CO_CONFIG_SDO_SRV \ (CO_CONFIG_SDO_SRV_SEGMENTED | CO_CONFIG_GLOBAL_FLAG_CALLBACK_PRE | CO_CONFIG_GLOBAL_FLAG_TIMERNEXT \ - | CO_CONFIG_GLOBAL_FLAG_OD_DYNAMIC) + | CO_CONFIG_GLOBAL_FLAG_OD_DYNAMIC | CO_CONFIG_GLOBAL_FLAG_ALLOW_EXT_ID) #endif #ifndef CO_CONFIG_SDO_SRV_BUFFER_SIZE #define CO_CONFIG_SDO_SRV_BUFFER_SIZE 32U diff --git a/301/CO_SYNC.c b/301/CO_SYNC.c index bc2f49d..625c6aa 100644 --- a/301/CO_SYNC.c +++ b/301/CO_SYNC.c @@ -22,6 +22,14 @@ #if ((CO_CONFIG_SYNC)&CO_CONFIG_SYNC_ENABLE) != 0 +#if ((CO_CONFIG_SYNC)&CO_CONFIG_FLAG_ALLOW_EXT_ID) != 0 +#define COB_CAN_ID_MASK CO_COB_EXT_MASK +#define CO_IS_VALID_CAN_ID(cob) CO_CHECK_CAN_ID_IN_COB(cob) +#else +#define COB_CAN_ID_MASK CO_COB_STD_MASK +#define CO_IS_VALID_CAN_ID(cob) CO_CHECK_CAN_ID_IN_COB_ASSUME_STD(cob) +#endif + /* * Read received message from CAN module. * @@ -80,24 +88,24 @@ OD_write_1005(OD_stream_t* stream, const void* buf, OD_size_t count, OD_size_t* CO_SYNC_t* SYNC = stream->object; uint32_t cobIdSync = CO_getUint32(buf); - uint16_t CAN_ID = (uint16_t)(cobIdSync & 0x7FFU); + CO_CANident_t CAN_ID = (CO_CANident_t)(cobIdSync & COB_CAN_ID_MASK); /* verify written value */ #if ((CO_CONFIG_SYNC)&CO_CONFIG_SYNC_PRODUCER) != 0 - bool_t isProducer = (cobIdSync & 0x40000000U) != 0U; - if (((cobIdSync & 0xBFFFF800U) != 0U) || CO_IS_RESTRICTED_CAN_ID(CAN_ID) + bool_t isProducer = (cobIdSync & CO_COB_BIT30) != 0U; + if (!CO_IS_VALID_CAN_ID(cobIdSync) || ((cobIdSync & CO_COB_BIT31) != 0) || CO_IS_RESTRICTED_CAN_ID(CAN_ID) || (SYNC->isProducer && isProducer && (CAN_ID != SYNC->CAN_ID))) { return ODR_INVALID_VALUE; } #else - if (((cobIdSync & 0xFFFFF800U) != 0U) || CO_IS_RESTRICTED_CAN_ID(CAN_ID)) { + if (!CO_IS_VALID_CAN_ID(cobIdSync) || ((cobIdSync & (CO_COB_BIT31 | CO_COB_BIT30)) != 0) || CO_IS_RESTRICTED_CAN_ID(CAN_ID)) { return ODR_INVALID_VALUE; } #endif /* Configure CAN receive and transmit buffers */ if (CAN_ID != SYNC->CAN_ID) { - CO_ReturnError_t CANret = CO_CANrxBufferInit(SYNC->CANdevRx, SYNC->CANdevRxIdx, CAN_ID, 0x7FF, false, + CO_ReturnError_t CANret = CO_CANrxBufferInit(SYNC->CANdevRx, SYNC->CANdevRxIdx, CAN_ID, COB_CAN_ID_MASK, false, (void*)SYNC, CO_SYNC_receive); if (CANret != CO_ERROR_NO) { @@ -272,7 +280,7 @@ CO_SYNC_init(CO_SYNC_t* SYNC, CO_EM_t* em, OD_entry_t* OD_1005_cobIdSync, OD_ent SYNC->CANdevTx = CANdevTx; #endif #if ((CO_CONFIG_SYNC)&CO_CONFIG_FLAG_OD_DYNAMIC) != 0 - SYNC->CAN_ID = (uint16_t)(cobIdSync & 0x7FFU); + SYNC->CAN_ID = (CO_CANident_t)(cobIdSync & COB_CAN_ID_MASK); SYNC->CANdevRx = CANdevRx; SYNC->CANdevRxIdx = CANdevRxIdx; #if ((CO_CONFIG_SYNC)&CO_CONFIG_SYNC_PRODUCER) != 0 @@ -281,14 +289,14 @@ CO_SYNC_init(CO_SYNC_t* SYNC, CO_EM_t* em, OD_entry_t* OD_1005_cobIdSync, OD_ent #endif /* configure SYNC CAN reception and transmission */ - CO_ReturnError_t ret = CO_CANrxBufferInit(CANdevRx, CANdevRxIdx, (uint16_t)(cobIdSync & 0x7FFU), 0x7FF, false, + CO_ReturnError_t ret = CO_CANrxBufferInit(CANdevRx, CANdevRxIdx, (CO_CANident_t)(cobIdSync & COB_CAN_ID_MASK), COB_CAN_ID_MASK, false, (void*)SYNC, CO_SYNC_receive); if (ret != CO_ERROR_NO) { return ret; } #if ((CO_CONFIG_SYNC)&CO_CONFIG_SYNC_PRODUCER) != 0 - SYNC->CANtxBuff = CO_CANtxBufferInit(CANdevTx, CANdevTxIdx, (uint16_t)(cobIdSync & 0x7FFU), false, + SYNC->CANtxBuff = CO_CANtxBufferInit(CANdevTx, CANdevTxIdx, (CO_CANident_t)(cobIdSync & COB_CAN_ID_MASK), false, (syncCounterOvf != 0U) ? 1U : 0U, false); if (SYNC->CANtxBuff == NULL) { diff --git a/301/CO_SYNC.h b/301/CO_SYNC.h index e281fe6..f74b2f2 100644 --- a/301/CO_SYNC.h +++ b/301/CO_SYNC.h @@ -29,7 +29,7 @@ #ifndef CO_CONFIG_SYNC #define CO_CONFIG_SYNC \ (CO_CONFIG_SYNC_ENABLE | CO_CONFIG_SYNC_PRODUCER | CO_CONFIG_GLOBAL_RT_FLAG_CALLBACK_PRE \ - | CO_CONFIG_GLOBAL_FLAG_TIMERNEXT | CO_CONFIG_GLOBAL_FLAG_OD_DYNAMIC) + | CO_CONFIG_GLOBAL_FLAG_TIMERNEXT | CO_CONFIG_GLOBAL_FLAG_OD_DYNAMIC | CO_CONFIG_GLOBAL_FLAG_ALLOW_EXT_ID) #endif #if (((CO_CONFIG_SYNC)&CO_CONFIG_SYNC_ENABLE) != 0) || defined CO_DOXYGEN @@ -90,7 +90,7 @@ typedef struct { CO_CANmodule_t* CANdevRx; /**< From CO_SYNC_init() */ uint16_t CANdevRxIdx; /**< From CO_SYNC_init() */ OD_extension_t OD_1005_extension; /**< Extension for OD object */ - uint16_t CAN_ID; /**< CAN ID of the SYNC message. Calculated from _COB ID SYNC Message_ variable + CO_CANident_t CAN_ID; /**< CAN ID of the SYNC message. Calculated from _COB ID SYNC Message_ variable from Object dictionary (index 0x1005). */ #if (((CO_CONFIG_SYNC)&CO_CONFIG_SYNC_PRODUCER) != 0) || defined CO_DOXYGEN uint16_t CANdevTxIdx; /**< From CO_SYNC_init() */ diff --git a/301/CO_TIME.c b/301/CO_TIME.c index 499271c..fc8235a 100644 --- a/301/CO_TIME.c +++ b/301/CO_TIME.c @@ -24,6 +24,14 @@ #if ((CO_CONFIG_TIME)&CO_CONFIG_TIME_ENABLE) != 0 +#if ((CO_CONFIG_TIME)&CO_CONFIG_FLAG_ALLOW_EXT_ID) != 0 +#define COB_CAN_ID_MASK CO_COB_EXT_MASK +#define CO_IS_VALID_CAN_ID(cob) CO_CHECK_CAN_ID_IN_COB(cob) +#else +#define COB_CAN_ID_MASK CO_COB_STD_MASK +#define CO_IS_VALID_CAN_ID(cob) CO_CHECK_CAN_ID_IN_COB_ASSUME_STD(cob) +#endif + /* * Read received message from CAN module. * @@ -66,7 +74,7 @@ OD_write_1012(OD_stream_t* stream, const void* buf, OD_size_t count, OD_size_t* /* verify written value */ uint32_t cobIdTimeStamp = CO_getUint32(buf); - uint16_t CAN_ID = (uint16_t)(cobIdTimeStamp & 0x7FFU); + CO_CANident_t CAN_ID = (CO_CANident_t)(cobIdTimeStamp & 0x7FFU); if (((cobIdTimeStamp & 0x3FFFF800U) != 0U) || CO_IS_RESTRICTED_CAN_ID(CAN_ID)) { return ODR_INVALID_VALUE; } @@ -114,14 +122,14 @@ CO_TIME_init(CO_TIME_t* TIME, OD_entry_t* OD_1012_cobIdTimeStamp, CO_CANmodule_t #endif /* Configure object variables */ - uint16_t cobId = (uint16_t)(cobIdTimeStamp & 0x7FFU); + CO_CANident_t cobId = (CO_CANident_t)(cobIdTimeStamp & COB_CAN_ID_MASK); TIME->isConsumer = (cobIdTimeStamp & 0x80000000UL) != 0U; TIME->isProducer = (cobIdTimeStamp & 0x40000000UL) != 0U; CO_FLAG_CLEAR(TIME->CANrxNew); /* configure TIME consumer message reception */ if (TIME->isConsumer) { - CO_ReturnError_t ret = CO_CANrxBufferInit(CANdevRx, CANdevRxIdx, cobId, 0x7FF, false, (void*)TIME, + CO_ReturnError_t ret = CO_CANrxBufferInit(CANdevRx, CANdevRxIdx, cobId, COB_CAN_ID_MASK, false, (void*)TIME, CO_TIME_receive); if (ret != CO_ERROR_NO) { return ret; diff --git a/301/CO_TIME.h b/301/CO_TIME.h index 86a2b9e..0bc17d5 100644 --- a/301/CO_TIME.h +++ b/301/CO_TIME.h @@ -27,7 +27,7 @@ /* default configuration, see CO_config.h */ #ifndef CO_CONFIG_TIME -#define CO_CONFIG_TIME (CO_CONFIG_TIME_ENABLE | CO_CONFIG_GLOBAL_FLAG_CALLBACK_PRE | CO_CONFIG_GLOBAL_FLAG_OD_DYNAMIC) +#define CO_CONFIG_TIME (CO_CONFIG_TIME_ENABLE | CO_CONFIG_GLOBAL_FLAG_CALLBACK_PRE | CO_CONFIG_GLOBAL_FLAG_OD_DYNAMIC | CO_CONFIG_GLOBAL_FLAG_ALLOW_EXT_ID) #endif #if (((CO_CONFIG_TIME)&CO_CONFIG_TIME_ENABLE) != 0) || defined CO_DOXYGEN diff --git a/301/CO_config.h b/301/CO_config.h index 5a07ae6..e7dda16 100644 --- a/301/CO_config.h +++ b/301/CO_config.h @@ -93,6 +93,19 @@ extern "C" { */ #define CO_CONFIG_FLAG_OD_DYNAMIC 0x4000 +/** + * Enable transmission and reception of extended CAN identifiers + * + * To use extended CAN identifiers, make sure @ref CO_CANident_t is set to + * an integer type with at least 30 bits. Bits 0-28 are the CAN identifier + * and bit 29 indicates whether the identifier is extended or not. + * If you set the identifier type to 16 bit, this flag does nothing, + * all identifiers are always 11 bit and no special handling is required. + * + * This flag is common to multiple configuration macros. + */ +#define CO_CONFIG_FLAG_ALLOW_EXT_ID 0x8000 + /** This flag may be set globally for mainline objects to * @ref CO_CONFIG_FLAG_CALLBACK_PRE */ #ifdef CO_DOXYGEN diff --git a/301/CO_driver.h b/301/CO_driver.h index e48c98f..31439b8 100644 --- a/301/CO_driver.h +++ b/301/CO_driver.h @@ -43,6 +43,9 @@ extern "C" { #ifndef CO_CONFIG_GLOBAL_FLAG_OD_DYNAMIC #define CO_CONFIG_GLOBAL_FLAG_OD_DYNAMIC CO_CONFIG_FLAG_OD_DYNAMIC #endif +#ifndef CO_CONFIG_GLOBAL_FLAG_ALLOW_EXT_ID +#define CO_CONFIG_GLOBAL_FLAG_ALLOW_EXT_ID (0) +#endif #ifdef CO_DEBUG_COMMON #if (CO_CONFIG_DEBUG) & CO_CONFIG_DEBUG_SDO_CLIENT #define CO_DEBUG_SDO_CLIENT(msg) CO_DEBUG_COMMON(msg) @@ -132,8 +135,9 @@ typedef unsigned char uint8_t; /**< UNSIGNED8 in CANopen (0005h), 8-bi typedef unsigned int uint16_t; /**< UNSIGNED16 in CANopen (0006h), 16-bit unsigned integer */ typedef unsigned long int uint32_t; /**< UNSIGNED32 in CANopen (0007h), 32-bit unsigned integer */ typedef unsigned long long int uint64_t; /**< UNSIGNED64 in CANopen (001Bh), 64-bit unsigned integer */ -typedef float float32_t; /**< REAL32 in CANopen (0008h), single precision floating point value, 32-bit */ -typedef double float64_t; /**< REAL64 in CANopen (0011h), double precision floating point value, 64-bit */ +typedef float float32_t; /**< REAL32 in CANopen (0008h), single precision floating point value, 32-bit */ +typedef double float64_t; /**< REAL64 in CANopen (0011h), double precision floating point value, 64-bit */ +typedef uint16_t CO_CANident_t; /**< Used for CAN Ids should be either 16 bit (std) or 32 bit (ext) */ /** @} */ /** @@ -176,7 +180,7 @@ void CANrx_callback(void* object, void* rxMsg); * @param rxMsg Pointer to received message * @return 11-bit CAN standard identifier. */ -static inline uint16_t +static inline CO_CANident_t CO_CANrxMsg_readIdent(void* rxMsg) { return 0; } @@ -423,6 +427,22 @@ typedef struct { || (((CAN_ID) >= 0x6E0U) && ((CAN_ID) <= 0x6FFU)) || ((CAN_ID) >= 0x701U)) #endif +#define CO_CAN_STD_MASK 0x000007FFU +#define CO_CAN_EXT_MASK 0x1FFFFFFFU + +#define CO_COB_BIT29 0x20000000U +#define CO_COB_BIT30 0x40000000U +#define CO_COB_BIT31 0x80000000U +#define CO_COB_EXT_BIT CO_COB_BIT29 +#define CO_COB_VALID_BIT CO_COB_BIT31 + +#define CO_COB_EXT_MASK ((CO_CANident_t)(CO_CAN_EXT_MASK | CO_COB_EXT_BIT)) +#define CO_COB_STD_MASK ((CO_CANident_t)(CO_CAN_STD_MASK | CO_COB_EXT_BIT)) + +#define CO_IS_EXTENDED_CAN_ID(CAN_ID) (((CAN_ID)&CO_COB_EXT_BIT) != 0) +#define CO_CHECK_CAN_ID_IN_COB_ASSUME_STD(cob) (((cob)&0x3FFFF800U) == 0) +#define CO_CHECK_CAN_ID_IN_COB(cob) (CO_IS_EXTENDED_CAN_ID(cob) || (((cob)&0x0FFFF800U) == 0)) + /** * @defgroup CO_CAN_ERR_status_t CAN error status bitmasks * @{ @@ -431,15 +451,15 @@ typedef struct { * reached, if counters are more or equal to 128. Transmitter goes in error state 'bus off' if transmit error counter is * more or equal to 256. */ -#define CO_CAN_ERRTX_WARNING 0x0001U /**< 0x0001 CAN transmitter warning */ -#define CO_CAN_ERRTX_PASSIVE 0x0002U /**< 0x0002 CAN transmitter passive */ -#define CO_CAN_ERRTX_BUS_OFF 0x0004U /**< 0x0004 CAN transmitter bus off */ -#define CO_CAN_ERRTX_OVERFLOW 0x0008U /**< 0x0008 CAN transmitter overflow */ -#define CO_CAN_ERRTX_PDO_LATE 0x0080U /**< 0x0080 TPDO is outside sync window */ -#define CO_CAN_ERRRX_WARNING 0x0100U /**< 0x0100 CAN receiver warning */ -#define CO_CAN_ERRRX_PASSIVE 0x0200U /**< 0x0200 CAN receiver passive */ -#define CO_CAN_ERRRX_OVERFLOW 0x0800U /**< 0x0800 CAN receiver overflow */ -#define CO_CAN_ERR_WARN_PASSIVE 0x0303U /**< 0x0303 combination */ +#define CO_CAN_ERRTX_WARNING 0x0001U /**< 0x0001 CAN transmitter warning */ +#define CO_CAN_ERRTX_PASSIVE 0x0002U /**< 0x0002 CAN transmitter passive */ +#define CO_CAN_ERRTX_BUS_OFF 0x0004U /**< 0x0004 CAN transmitter bus off */ +#define CO_CAN_ERRTX_OVERFLOW 0x0008U /**< 0x0008 CAN transmitter overflow */ +#define CO_CAN_ERRTX_PDO_LATE 0x0080U /**< 0x0080 TPDO is outside sync window */ +#define CO_CAN_ERRRX_WARNING 0x0100U /**< 0x0100 CAN receiver warning */ +#define CO_CAN_ERRRX_PASSIVE 0x0200U /**< 0x0200 CAN receiver passive */ +#define CO_CAN_ERRRX_OVERFLOW 0x0800U /**< 0x0800 CAN receiver overflow */ +#define CO_CAN_ERR_WARN_PASSIVE 0x0303U /**< 0x0303 combination */ /** @} */ /* CO_CAN_ERR_status_t */ @@ -531,7 +551,7 @@ void CO_CANmodule_disable(CO_CANmodule_t* CANmodule); * Return #CO_ReturnError_t: CO_ERROR_NO CO_ERROR_ILLEGAL_ARGUMENT or CO_ERROR_OUT_OF_MEMORY (not enough masks for * configuration). */ -CO_ReturnError_t CO_CANrxBufferInit(CO_CANmodule_t* CANmodule, uint16_t index, uint16_t ident, uint16_t mask, +CO_ReturnError_t CO_CANrxBufferInit(CO_CANmodule_t* CANmodule, uint16_t index, CO_CANident_t ident, CO_CANident_t mask, bool_t rtr, void* object, void (*CANrx_callback)(void* object, void* message)); /** @@ -551,8 +571,8 @@ CO_ReturnError_t CO_CANrxBufferInit(CO_CANmodule_t* CANmodule, uint16_t index, u * @return Pointer to CAN transmit message buffer. 8 bytes data array inside buffer should be written, before * CO_CANsend() function is called. Zero is returned in case of wrong arguments. */ -CO_CANtx_t* CO_CANtxBufferInit(CO_CANmodule_t* CANmodule, uint16_t index, uint16_t ident, bool_t rtr, uint8_t noOfBytes, - bool_t syncFlag); +CO_CANtx_t* CO_CANtxBufferInit(CO_CANmodule_t* CANmodule, uint16_t index, CO_CANident_t ident, bool_t rtr, + uint8_t noOfBytes, bool_t syncFlag); /** * Send CAN message. diff --git a/example/CO_driver_blank.c b/example/CO_driver_blank.c index 7eeeddc..ab170cd 100644 --- a/example/CO_driver_blank.c +++ b/example/CO_driver_blank.c @@ -97,8 +97,8 @@ CO_CANmodule_disable(CO_CANmodule_t* CANmodule) { } CO_ReturnError_t -CO_CANrxBufferInit(CO_CANmodule_t* CANmodule, uint16_t index, uint16_t ident, uint16_t mask, bool_t rtr, void* object, - void (*CANrx_callback)(void* object, void* message)) { +CO_CANrxBufferInit(CO_CANmodule_t* CANmodule, uint16_t index, CO_CANident_t ident, CO_CANident_t mask, bool_t rtr, + void* object, void (*CANrx_callback)(void* object, void* message)) { CO_ReturnError_t ret = CO_ERROR_NO; if ((CANmodule != NULL) && (object != NULL) && (CANrx_callback != NULL) && (index < CANmodule->rxSize)) { @@ -126,7 +126,7 @@ CO_CANrxBufferInit(CO_CANmodule_t* CANmodule, uint16_t index, uint16_t ident, ui } CO_CANtx_t* -CO_CANtxBufferInit(CO_CANmodule_t* CANmodule, uint16_t index, uint16_t ident, bool_t rtr, uint8_t noOfBytes, +CO_CANtxBufferInit(CO_CANmodule_t* CANmodule, uint16_t index, CO_CANident_t ident, bool_t rtr, uint8_t noOfBytes, bool_t syncFlag) { CO_CANtx_t* buffer = NULL; diff --git a/example/CO_driver_target.h b/example/CO_driver_target.h index a402357..a1e52ac 100644 --- a/example/CO_driver_target.h +++ b/example/CO_driver_target.h @@ -49,22 +49,24 @@ typedef uint_fast8_t bool_t; typedef float float32_t; typedef double float64_t; +typedef uint16_t CO_CANident_t; + /* Access to received CAN message */ -#define CO_CANrxMsg_readIdent(msg) ((uint16_t)0) +#define CO_CANrxMsg_readIdent(msg) ((CO_CANident_t)0) #define CO_CANrxMsg_readDLC(msg) ((uint8_t)0) #define CO_CANrxMsg_readData(msg) ((const uint8_t*)NULL) /* Received message object */ typedef struct { - uint16_t ident; - uint16_t mask; + CO_CANident_t ident; + CO_CANident_t mask; void* object; void (*CANrx_callback)(void* object, void* message); } CO_CANrx_t; /* Transmit message object */ typedef struct { - uint32_t ident; + CO_CANident_t ident; uint8_t DLC; uint8_t data[8]; volatile bool_t bufferFull;