nikon/CANopenNode
1
0
Fork 0
Code Activity Actions

added comments and CO_CONFIG_CAN macro

Browse source
This commit is contained in:
rgruening 2025-04-04 15:49:08 +02:00
parent 723412d6d2
commit 17f75bf684
9 changed files with 163 additions and 93 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

21
301/CO_Emergency.c
View file

@ -29,11 +29,14 @@
#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)
#if (((CO_CONFIG_CAN)&CO_CONFIG_FLAG_ALLOW_EXT_ID) == 0)
#error CO_CONFIG_CAN must have CO_CONFIG_FLAG_ALLOW_EXT_ID enabled
#endif
#define CO_COB_ID_MASK CO_COB_EXT_MASK
#define CO_CHECK_COB_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)
#define CO_COB_ID_MASK CO_COB_STD_MASK
#define CO_CHECK_COB_ID(cob) CO_CHECK_CAN_ID_IN_COB_ASSUME_STD(cob)
#endif
/* fifo buffer example for fifoSize = 7 (actual capacity = 6) *
@ -87,11 +90,11 @@ 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);
CO_CANident_t newCanId = (CO_CANident_t)(COB_IDEmergency32 & COB_CAN_ID_MASK);
CO_CANident_t newCanId = (CO_CANident_t)(COB_IDEmergency32 & CO_COB_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 (!CO_IS_VALID_CAN_ID(COB_IDEmergency32) || ((COB_IDEmergency32 & 0x40000000U) != 0)
if (!CO_CHECK_COB_ID(COB_IDEmergency32) || ((COB_IDEmergency32 & 0x40000000U) != 0)
|| CO_IS_RESTRICTED_CAN_ID(newCanId) || ((em->producerEnabled && newEnabled) && (newCanId != curCanId))) {
return ODR_INVALID_VALUE;
}
@ -372,7 +375,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) || !CO_IS_VALID_CAN_ID(COB_IDEmergency32) || ((COB_IDEmergency32 & 0x40000000U) != 0)) {
if ((odRet != ODR_OK) || !CO_CHECK_COB_ID(COB_IDEmergency32) || ((COB_IDEmergency32 & 0x40000000U) != 0)) {
if (errInfo != NULL) {
*errInfo = OD_getIndex(OD_1014_cobIdEm);
}
@ -383,7 +386,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
CO_CANident_t producerCanId = (CO_CANident_t)(COB_IDEmergency32 & COB_CAN_ID_MASK);
CO_CANident_t producerCanId = (CO_CANident_t)(COB_IDEmergency32 & CO_COB_ID_MASK);
em->producerEnabled = ((COB_IDEmergency32 & 0x80000000U) == 0U) && (producerCanId != 0U);
em->OD_1014_extension.object = em;
@ -465,7 +468,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_CONSUMER) != 0
em->pFunctSignalRx = NULL;
/* configure SDO server CAN reception */
ret = CO_CANrxBufferInit(CANdevRx, CANdevRxIdx, CO_CAN_ID_EMERGENCY, COB_CAN_ID_MASK ^ 0x7FU, false, (void*)em,
ret = CO_CANrxBufferInit(CANdevRx, CANdevRxIdx, CO_CAN_ID_EMERGENCY, CO_COB_ID_MASK ^ 0x7FU, false, (void*)em,
CO_EM_receive);
#endif /* (CO_CONFIG_EM) & CO_CONFIG_EM_CONSUMER */

35
301/CO_PDO.c
View file

@ -31,11 +31,14 @@
#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)
#if (((CO_CONFIG_CAN)&CO_CONFIG_FLAG_ALLOW_EXT_ID) == 0)
#error CO_CONFIG_CAN must have CO_CONFIG_FLAG_ALLOW_EXT_ID enabled
#endif
#define CO_COB_ID_MASK CO_COB_EXT_MASK
#define CO_CHECK_COB_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)
#define CO_COB_ID_MASK CO_COB_STD_MASK
#define CO_CHECK_COB_ID(cob) CO_CHECK_CAN_ID_IN_COB_ASSUME_STD(cob)
#endif
#if ((CO_CONFIG_PDO)&CO_CONFIG_PDO_OD_IO_ACCESS) != 0
@ -393,10 +396,10 @@ 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);
CO_CANident_t CAN_ID = (CO_CANident_t)(COB_ID & COB_CAN_ID_MASK);
CO_CANident_t CAN_ID = (CO_CANident_t)(COB_ID & CO_COB_ID_MASK);
/* If default CAN-ID is stored in OD (without Node-ID), add Node-ID */
if ((CAN_ID != 0U) && (CAN_ID == (PDO->preDefinedCanId & (COB_CAN_ID_MASK ^ 0x7FU)))) {
if ((CAN_ID != 0U) && (CAN_ID == (PDO->preDefinedCanId & (CO_COB_ID_MASK ^ 0x7FU)))) {
COB_ID = (COB_ID & (CO_COB_BIT31 | CO_COB_BIT30)) | PDO->preDefinedCanId;
}
@ -507,12 +510,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);
CO_CANident_t CAN_ID = (CO_CANident_t)(COB_ID & COB_CAN_ID_MASK);
CO_CANident_t CAN_ID = (CO_CANident_t)(COB_ID & CO_COB_ID_MASK);
bool_t valid = (COB_ID & 0x80000000U) == 0U;
/* PDO must be disabled on change, CAN_ID == 0 is
* not allowed, mapping must be configured before enabling the PDO */
if (!CO_IS_VALID_CAN_ID(COB_ID) || (valid && PDO->valid && (CAN_ID != PDO->configuredCanId))
if (!CO_CHECK_COB_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;
}
@ -527,7 +530,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, COB_CAN_ID_MASK, false,
CO_ReturnError_t ret = CO_CANrxBufferInit(PDO->CANdev, PDO->CANdevIdx, CAN_ID, CO_COB_ID_MASK, false,
(void*)RPDO, CO_PDO_receive);
if (valid && (ret == CO_ERROR_NO)) {
@ -629,7 +632,7 @@ CO_RPDO_init(CO_RPDO_t* RPDO, OD_t* OD, CO_EM_t* em,
}
bool_t valid = (COB_ID & 0x80000000U) == 0U;
CO_CANident_t CAN_ID = (CO_CANident_t)(COB_ID & COB_CAN_ID_MASK);
CO_CANident_t CAN_ID = (CO_CANident_t)(COB_ID & CO_COB_ID_MASK);
if (valid && ((PDO->mappedObjectsCount == 0U) || (CAN_ID == 0U))) {
valid = false;
if (erroneousMap == 0U) {
@ -646,11 +649,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 & COB_CAN_ID_MASK))) {
if ((CAN_ID != 0U) && (CAN_ID == (preDefinedCanId & CO_COB_ID_MASK))) {
CAN_ID = preDefinedCanId;
}
ret = CO_CANrxBufferInit(CANdevRx, CANdevRxIdx, CAN_ID, COB_CAN_ID_MASK, false, (void*)RPDO, CO_PDO_receive);
ret = CO_CANrxBufferInit(CANdevRx, CANdevRxIdx, CAN_ID, CO_COB_ID_MASK, false, (void*)RPDO, CO_PDO_receive);
if (ret != CO_ERROR_NO) {
return ret;
}
@ -896,12 +899,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);
CO_CANident_t CAN_ID = (CO_CANident_t)(COB_ID & COB_CAN_ID_MASK);
CO_CANident_t CAN_ID = (CO_CANident_t)(COB_ID & CO_COB_ID_MASK);
bool_t valid = (COB_ID & 0x80000000U) == 0U;
/* PDO must be disabled on change, CAN_ID == 0 is
* not allowed, mapping must be configured before enabling the PDO */
if (!CO_IS_VALID_CAN_ID(COB_ID) || (valid && (PDO->valid && (CAN_ID != PDO->configuredCanId)))
if (!CO_CHECK_COB_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;
}
@ -1053,7 +1056,7 @@ CO_TPDO_init(CO_TPDO_t* TPDO, OD_t* OD, CO_EM_t* em,
}
bool_t valid = (COB_ID & 0x80000000U) == 0U;
CO_CANident_t CAN_ID = (CO_CANident_t)(COB_ID & COB_CAN_ID_MASK);
CO_CANident_t CAN_ID = (CO_CANident_t)(COB_ID & CO_COB_ID_MASK);
if (valid && ((PDO->mappedObjectsCount == 0U) || (CAN_ID == 0U))) {
valid = false;
if (erroneousMap == 0U) {
@ -1070,7 +1073,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 & (COB_CAN_ID_MASK ^ 0x7FU)))) {
if ((CAN_ID != 0U) && (CAN_ID == (preDefinedCanId & (CO_COB_ID_MASK ^ 0x7FU)))) {
CAN_ID = preDefinedCanId;
}

29
301/CO_SDOclient.c
View file

@ -48,11 +48,14 @@
#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)
#if (((CO_CONFIG_CAN)&CO_CONFIG_FLAG_ALLOW_EXT_ID) == 0)
#error CO_CONFIG_CAN must have CO_CONFIG_FLAG_ALLOW_EXT_ID enabled
#endif
#define CO_COB_ID_MASK CO_COB_EXT_MASK
#define CO_CHECK_COB_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)
#define CO_COB_ID_MASK CO_COB_STD_MASK
#define CO_CHECK_COB_ID(cob) CO_CHECK_CAN_ID_IN_COB_ASSUME_STD(cob)
#endif
/*
@ -174,12 +177,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);
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);
CO_CANident_t CAN_ID = (CO_CANident_t)(COB_ID & CO_COB_ID_MASK);
CO_CANident_t CAN_ID_cur = (CO_CANident_t)(SDO_C->COB_IDClientToServer & CO_COB_ID_MASK);
bool_t valid = (COB_ID & 0x80000000U) == 0U;
/* SDO client must not be valid when changing COB_ID */
if (!CO_IS_VALID_CAN_ID(COB_ID) || (valid && SDO_C->valid && (CAN_ID != CAN_ID_cur))
if (!CO_CHECK_COB_ID(COB_ID) || (valid && SDO_C->valid && (CAN_ID != CAN_ID_cur))
|| (valid && CO_IS_RESTRICTED_CAN_ID(CAN_ID))) {
return ODR_INVALID_VALUE;
}
@ -189,12 +192,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);
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);
CO_CANident_t CAN_ID = (CO_CANident_t)(COB_ID & CO_COB_ID_MASK);
CO_CANident_t CAN_ID_cur = (CO_CANident_t)(SDO_C->COB_IDServerToClient & CO_COB_ID_MASK);
bool_t valid = (COB_ID & 0x80000000U) == 0U;
/* SDO client must not be valid when changing COB_ID */
if (!CO_IS_VALID_CAN_ID(COB_ID) || (valid && SDO_C->valid && (CAN_ID != CAN_ID_cur))
if (!CO_CHECK_COB_ID(COB_ID) || (valid && SDO_C->valid && (CAN_ID != CAN_ID_cur))
|| (valid && CO_IS_RESTRICTED_CAN_ID(CAN_ID))) {
return ODR_INVALID_VALUE;
}
@ -341,10 +344,10 @@ CO_SDOclient_setup(CO_SDOclient_t* SDO_C, uint32_t COB_IDClientToServer, uint32_
/* verify valid bit */
CO_CANident_t CanIdC2S = ((COB_IDClientToServer & 0x80000000UL) == 0U)
? (CO_CANident_t)(COB_IDClientToServer & COB_CAN_ID_MASK)
? (CO_CANident_t)(COB_IDClientToServer & CO_COB_ID_MASK)
: 0U;
CO_CANident_t CanIdS2C = ((COB_IDServerToClient & 0x80000000UL) == 0U)
? (CO_CANident_t)(COB_IDServerToClient & COB_CAN_ID_MASK)
? (CO_CANident_t)(COB_IDServerToClient & CO_COB_ID_MASK)
: 0U;
if ((CanIdC2S != 0U) && (CanIdS2C != 0U)) {
SDO_C->valid = true;
@ -355,7 +358,7 @@ 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, COB_CAN_ID_MASK, false,
CO_ReturnError_t ret = CO_CANrxBufferInit(SDO_C->CANdevRx, SDO_C->CANdevRxIdx, CanIdS2C, CO_COB_ID_MASK, false,
(void*)SDO_C, CO_SDOclient_receive);
/* configure SDO client CAN transmission */

38
301/CO_SDOserver.c
View file

@ -42,11 +42,14 @@
#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)
#if (((CO_CONFIG_CAN)&CO_CONFIG_FLAG_ALLOW_EXT_ID) == 0)
#error CO_CONFIG_CAN must have CO_CONFIG_FLAG_ALLOW_EXT_ID enabled
#endif
#define CO_COB_ID_MASK CO_COB_EXT_MASK
#define CO_CHECK_COB_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)
#define CO_COB_ID_MASK CO_COB_STD_MASK
#define CO_CHECK_COB_ID(cob) CO_CHECK_CAN_ID_IN_COB_ASSUME_STD(cob)
#endif
/*
@ -165,8 +168,12 @@ CO_SDOserver_init_canRxTx(CO_SDOserver_t* SDO, CO_CANmodule_t* CANdevRx, uint16_
#endif
/* verify valid bit */
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;
CO_CANident_t idC2S = ((COB_IDClientToServer & 0x80000000UL) == 0U)
? (CO_CANident_t)(COB_IDClientToServer & CO_COB_ID_MASK)
: 0U;
CO_CANident_t idS2C = ((COB_IDServerToClient & 0x80000000UL) == 0U)
? (CO_CANident_t)(COB_IDServerToClient & CO_COB_ID_MASK)
: 0U;
if ((idC2S != 0U) && (idS2C != 0U)) {
SDO->valid = true;
} else {
@ -176,7 +183,8 @@ 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, COB_CAN_ID_MASK, false, (void*)SDO, CO_SDO_receive);
CO_ReturnError_t ret = CO_CANrxBufferInit(CANdevRx, CANdevRxIdx, idC2S, CO_COB_ID_MASK, false, (void*)SDO,
CO_SDO_receive);
/* configure SDO server CAN transmission */
SDO->CANtxBuff = CO_CANtxBufferInit(SDO->CANdevTx, CANdevTxIdx, idS2C, false, 8, false);
@ -209,12 +217,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);
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);
CO_CANident_t CAN_ID = (CO_CANident_t)(COB_ID & CO_COB_ID_MASK);
CO_CANident_t CAN_ID_cur = (CO_CANident_t)(SDO->COB_IDClientToServer & CO_COB_ID_MASK);
bool_t valid = (COB_ID & 0x80000000U) == 0U;
/* SDO client must not be valid when changing COB_ID */
if (CO_IS_VALID_CAN_ID(COB_ID) || ((valid && SDO->valid) && (CAN_ID != CAN_ID_cur))
if (CO_CHECK_COB_ID(COB_ID) || ((valid && SDO->valid) && (CAN_ID != CAN_ID_cur))
|| (valid && CO_IS_RESTRICTED_CAN_ID(CAN_ID))) {
return ODR_INVALID_VALUE;
}
@ -225,12 +233,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);
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);
CO_CANident_t CAN_ID = (CO_CANident_t)(COB_ID & CO_COB_ID_MASK);
CO_CANident_t CAN_ID_cur = (CO_CANident_t)(SDO->COB_IDServerToClient & CO_COB_ID_MASK);
bool_t valid = (COB_ID & 0x80000000U) == 0U;
/* SDO client must not be valid when changing COB_ID */
if (CO_IS_VALID_CAN_ID(COB_ID) || (valid && (SDO->valid && (CAN_ID != CAN_ID_cur)))
if (CO_CHECK_COB_ID(COB_ID) || (valid && (SDO->valid && (CAN_ID != CAN_ID_cur)))
|| (valid && CO_IS_RESTRICTED_CAN_ID(CAN_ID))) {
return ODR_INVALID_VALUE;
}
@ -330,10 +338,10 @@ CO_SDOserver_init(CO_SDOserver_t* SDO, OD_t* OD, OD_entry_t* OD_1200_SDOsrvPar,
}
CanId_ClientToServer = ((COB_IDClientToServer32 & 0x80000000U) == 0U)
? (CO_CANident_t)(COB_IDClientToServer32 & COB_CAN_ID_MASK)
? (CO_CANident_t)(COB_IDClientToServer32 & CO_COB_ID_MASK)
: 0U;
CanId_ServerToClient = ((COB_IDServerToClient32 & 0x80000000U) == 0U)
? (CO_CANident_t)(COB_IDServerToClient32 & COB_CAN_ID_MASK)
? (CO_CANident_t)(COB_IDServerToClient32 & CO_COB_ID_MASK)
: 0U;
#if ((CO_CONFIG_SDO_SRV)&CO_CONFIG_FLAG_OD_DYNAMIC) != 0

28
301/CO_SYNC.c
View file

@ -23,11 +23,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)
#if (((CO_CONFIG_CAN)&CO_CONFIG_FLAG_ALLOW_EXT_ID) == 0)
#error CO_CONFIG_CAN must have CO_CONFIG_FLAG_ALLOW_EXT_ID enabled
#endif
#define CO_COB_ID_MASK CO_COB_EXT_MASK
#define CO_CHECK_COB_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)
#define CO_COB_ID_MASK CO_COB_STD_MASK
#define CO_CHECK_COB_ID(cob) CO_CHECK_CAN_ID_IN_COB_ASSUME_STD(cob)
#endif
/*
@ -88,24 +91,25 @@ 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);
CO_CANident_t CAN_ID = (CO_CANident_t)(cobIdSync & COB_CAN_ID_MASK);
CO_CANident_t CAN_ID = (CO_CANident_t)(cobIdSync & CO_COB_ID_MASK);
/* verify written value */
#if ((CO_CONFIG_SYNC)&CO_CONFIG_SYNC_PRODUCER) != 0
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)
if (!CO_CHECK_COB_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 (!CO_IS_VALID_CAN_ID(cobIdSync) || ((cobIdSync & (CO_COB_BIT31 | CO_COB_BIT30)) != 0) || CO_IS_RESTRICTED_CAN_ID(CAN_ID)) {
if (!CO_CHECK_COB_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, COB_CAN_ID_MASK, false,
CO_ReturnError_t CANret = CO_CANrxBufferInit(SYNC->CANdevRx, SYNC->CANdevRxIdx, CAN_ID, CO_COB_ID_MASK, false,
(void*)SYNC, CO_SYNC_receive);
if (CANret != CO_ERROR_NO) {
@ -280,7 +284,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 = (CO_CANident_t)(cobIdSync & COB_CAN_ID_MASK);
SYNC->CAN_ID = (CO_CANident_t)(cobIdSync & CO_COB_ID_MASK);
SYNC->CANdevRx = CANdevRx;
SYNC->CANdevRxIdx = CANdevRxIdx;
#if ((CO_CONFIG_SYNC)&CO_CONFIG_SYNC_PRODUCER) != 0
@ -289,14 +293,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, (CO_CANident_t)(cobIdSync & COB_CAN_ID_MASK), COB_CAN_ID_MASK, false,
(void*)SYNC, CO_SYNC_receive);
CO_ReturnError_t ret = CO_CANrxBufferInit(CANdevRx, CANdevRxIdx, (CO_CANident_t)(cobIdSync & CO_COB_ID_MASK),
CO_COB_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, (CO_CANident_t)(cobIdSync & COB_CAN_ID_MASK), false,
SYNC->CANtxBuff = CO_CANtxBufferInit(CANdevTx, CANdevTxIdx, (CO_CANident_t)(cobIdSync & CO_COB_ID_MASK), false,
(syncCounterOvf != 0U) ? 1U : 0U, false);
if (SYNC->CANtxBuff == NULL) {

19
301/CO_TIME.c
View file

@ -25,11 +25,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)
#if (((CO_CONFIG_CAN)&CO_CONFIG_FLAG_ALLOW_EXT_ID) == 0)
#error CO_CONFIG_CAN must have CO_CONFIG_FLAG_ALLOW_EXT_ID enabled
#endif
#define CO_COB_ID_MASK CO_COB_EXT_MASK
#define CO_CHECK_COB_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)
#define CO_COB_ID_MASK CO_COB_STD_MASK
#define CO_CHECK_COB_ID(cob) CO_CHECK_CAN_ID_IN_COB_ASSUME_STD(cob)
#endif
/*
@ -74,8 +77,8 @@ 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);
CO_CANident_t CAN_ID = (CO_CANident_t)(cobIdTimeStamp & COB_CAN_ID_MASK);
if (!CO_IS_VALID_CAN_ID(cobIdTimeStamp) || CO_IS_RESTRICTED_CAN_ID(CAN_ID)) {
CO_CANident_t CAN_ID = (CO_CANident_t)(cobIdTimeStamp & CO_COB_ID_MASK);
if (!CO_CHECK_COB_ID(cobIdTimeStamp) || CO_IS_RESTRICTED_CAN_ID(CAN_ID)) {
return ODR_INVALID_VALUE;
}
@ -122,14 +125,14 @@ CO_TIME_init(CO_TIME_t* TIME, OD_entry_t* OD_1012_cobIdTimeStamp, CO_CANmodule_t
#endif
/* Configure object variables */
CO_CANident_t cobId = (CO_CANident_t)(cobIdTimeStamp & COB_CAN_ID_MASK);
CO_CANident_t cobId = (CO_CANident_t)(cobIdTimeStamp & CO_COB_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, COB_CAN_ID_MASK, false, (void*)TIME,
CO_ReturnError_t ret = CO_CANrxBufferInit(CANdevRx, CANdevRxIdx, cobId, CO_COB_ID_MASK, false, (void*)TIME,
CO_TIME_receive);
if (ret != CO_ERROR_NO) {
return ret;

47
301/CO_config.h
View file

@ -96,11 +96,9 @@ extern "C" {
/**
* 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
* To use extended CAN identifiers, make sure your driver use the appropriate
* 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.
*/
@ -129,6 +127,27 @@ extern "C" {
#endif
/** @} */ /* CO_STACK_CONFIG_COMMON */
/** This flag may be set globally to @ref CO_CONFIG_FLAG_ALLOW_EXT_ID */
#ifdef CO_DOXYGEN
#define CO_CONFIG_GLOBAL_FLAG_ALLOW_EXT_ID (0)
#endif
/** @} */ /* CO_STACK_CONFIG_COMMON */
/**
* @defgroup CO_STACK_CONFIG_CAN CAN Driver
* @{
*/
/**
* Configuration of @ref CO_driver.
*
* Possible flags, can be ORed:
* - #CO_CONFIG_FLAG_ALLOW_EXT_ID - Enable extended CAN identifier
*/
#ifdef CO_DOXYGEN
#define CO_CONFIG_CAN (CO_CONFIG_GLOBAL_FLAG_ALLOW_EXT_ID)
#endif
/** @} */ /* CO_STACK_CONFIG_CAN */
/**
* @defgroup CO_STACK_CONFIG_NMT_HB NMT master/slave and HB producer/consumer
* Specified in standard CiA 301
@ -244,11 +263,12 @@ extern "C" {
* Callback is configured by CO_EM_initCallbackPre().
* - #CO_CONFIG_FLAG_TIMERNEXT - Enable calculation of timerNext_us variable
* inside CO_EM_process().
* - #CO_CONFIG_FLAG_ALLOW_EXT_ID - Enable extended CAN identifier
*/
#ifdef CO_DOXYGEN
#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
#define CO_CONFIG_EM_PRODUCER 0x01
#define CO_CONFIG_EM_PROD_CONFIGURABLE 0x02
@ -364,11 +384,12 @@ extern "C" {
* inside CO_SDOserver_process().
* - #CO_CONFIG_FLAG_OD_DYNAMIC - Enable dynamic configuration of additional SDO
* servers (Writing to object 0x1201+ re-configures the additional server).
* - #CO_CONFIG_FLAG_ALLOW_EXT_ID - Enable extended CAN identifier
*/
#ifdef CO_DOXYGEN
#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
#define CO_CONFIG_SDO_SRV_SEGMENTED 0x02
#define CO_CONFIG_SDO_SRV_BLOCK 0x04
@ -404,9 +425,10 @@ extern "C" {
* CO_SDOclientUploadInitiate(), CO_SDOclientUpload().
* - #CO_CONFIG_FLAG_OD_DYNAMIC - Enable dynamic configuration of SDO clients
* (Writing to object 0x1280+ re-configures the client).
* - #CO_CONFIG_FLAG_ALLOW_EXT_ID - Enable extended CAN identifier
*/
#ifdef CO_DOXYGEN
#define CO_CONFIG_SDO_CLI (0)
#define CO_CONFIG_SDO_CLI (CO_CONFIG_GLOBAL_FLAG_ALLOW_EXT_ID)
#endif
#define CO_CONFIG_SDO_CLI_ENABLE 0x01
#define CO_CONFIG_SDO_CLI_SEGMENTED 0x02
@ -445,9 +467,12 @@ extern "C" {
* Callback is configured by CO_TIME_initCallbackPre().
* - #CO_CONFIG_FLAG_OD_DYNAMIC - Enable dynamic configuration - writing to
* object 0x1012 enables / disables time producer or consumer.
* - #CO_CONFIG_FLAG_ALLOW_EXT_ID - Enable extended CAN identifier
*/
#ifdef CO_DOXYGEN
#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
#define CO_CONFIG_TIME_ENABLE 0x01
#define CO_CONFIG_TIME_PRODUCER 0x02
@ -470,11 +495,12 @@ extern "C" {
* - #CO_CONFIG_FLAG_TIMERNEXT - Enable calculation of timerNext_us variable
* inside CO_SYNC_process().
* - #CO_CONFIG_FLAG_OD_DYNAMIC - Enable dynamic configuration of SYNC.
* - #CO_CONFIG_FLAG_ALLOW_EXT_ID - Enable extended CAN identifier
*/
#ifdef CO_DOXYGEN
#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
#define CO_CONFIG_SYNC_ENABLE 0x01
#define CO_CONFIG_SYNC_PRODUCER 0x02
@ -501,12 +527,13 @@ extern "C" {
* - #CO_CONFIG_FLAG_TIMERNEXT - Enable calculation of timerNext_us variable
* inside CO_TPDO_process().
* - #CO_CONFIG_FLAG_OD_DYNAMIC - Enable dynamic configuration of PDO.
* - #CO_CONFIG_FLAG_ALLOW_EXT_ID - Enable extended CAN identifier
*/
#ifdef CO_DOXYGEN
#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
#define CO_CONFIG_RPDO_ENABLE 0x01
#define CO_CONFIG_TPDO_ENABLE 0x02

29
301/CO_driver.h
View file

@ -54,6 +54,9 @@ extern "C" {
#define CO_DEBUG_SDO_SERVER(msg) CO_DEBUG_COMMON(msg)
#endif
#endif
#ifndef CO_CONFIG_CAN
#define CO_CONFIG_CAN (CO_CONFIG_GLOBAL_FLAG_ALLOW_EXT_ID)
#endif
/**
* @defgroup CO_driver Driver
@ -135,9 +138,8 @@ 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 uint16_t CO_CANident_t; /**< Used for CAN Ids should be either 16 bit (std) or 32 bit (ext) */
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 */
/** @} */
/**
@ -180,7 +182,7 @@ void CANrx_callback(void* object, void* rxMsg);
* @param rxMsg Pointer to received message
* @return 11-bit CAN standard identifier.
*/
static inline CO_CANident_t
static inline uint16_t
CO_CANrxMsg_readIdent(void* rxMsg) {
return 0;
}
@ -427,9 +429,24 @@ typedef struct {
|| (((CAN_ID) >= 0x6E0U) && ((CAN_ID) <= 0x6FFU)) || ((CAN_ID) >= 0x701U))
#endif
/**
* Typedef to for CAN identifier
*/
#if (((CO_CONFIG_CAN)&CO_CONFIG_FLAG_ALLOW_EXT_ID) != 0)
typedef uint32_t CO_CANident_t; /**< Allow extended ids */
#else
typedef uint16_t CO_CANident_t; /**< Use std ids only */
#endif
/**
* Masks std and ext identifiers
*/
#define CO_CAN_STD_MASK 0x000007FFU
#define CO_CAN_EXT_MASK 0x1FFFFFFFU
/**
* Common masks for COB-IDs
*/
#define CO_COB_BIT29 0x20000000U
#define CO_COB_BIT30 0x40000000U
#define CO_COB_BIT31 0x80000000U
@ -440,6 +457,10 @@ typedef struct {
#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)
/**
* Helper to verify COB-IDs
*/
#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))

10
example/CO_driver_target.h
View file

@ -49,24 +49,22 @@ 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) ((CO_CANident_t)0)
#define CO_CANrxMsg_readIdent(msg) ((uint16_t)0)
#define CO_CANrxMsg_readDLC(msg) ((uint8_t)0)
#define CO_CANrxMsg_readData(msg) ((const uint8_t*)NULL)
/* Received message object */
typedef struct {
CO_CANident_t ident;
CO_CANident_t mask;
uint16_t ident;
uint16_t mask;
void* object;
void (*CANrx_callback)(void* object, void* message);
} CO_CANrx_t;
/* Transmit message object */
typedef struct {
CO_CANident_t ident;
uint32_t ident;
uint8_t DLC;
uint8_t data[8];
volatile bool_t bufferFull;