nikon/CANopenNode
1
0
Fork 0
Code Activity Actions

initial push to add extended can ids

Browse source
This commit is contained in:
rgruening 2025-04-03 14:53:33 +02:00
parent f454a3d82d
commit 7f86ce33ef
18 changed files with 190 additions and 101 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

42
301/CO_Emergency.c
View file

@ -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;
}

4
301/CO_Emergency.h
View file

@ -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

2
301/CO_Node_Guarding.c
View file

@ -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) {

2
301/CO_Node_Guarding.h
View file

@ -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 */

42
301/CO_PDO.c
View file

@ -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;
}

10
301/CO_PDO.h
View file

@ -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);
/**

32
301/CO_SDOclient.c
View file

@ -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);

2
301/CO_SDOclient.h
View file

@ -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

30
301/CO_SDOserver.c
View file

@ -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

2
301/CO_SDOserver.h
View file

@ -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

24
301/CO_SYNC.c
View file

@ -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) {

4
301/CO_SYNC.h
View file

@ -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() */

14
301/CO_TIME.c
View file

@ -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;

2
301/CO_TIME.h
View file

@ -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

13
301/CO_config.h
View file

@ -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

50
301/CO_driver.h
View file

@ -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.

6
example/CO_driver_blank.c
View file

@ -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;

10
example/CO_driver_target.h
View file

@ -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;