nikon/CANopenNode
1
0
Fork 0
Code Activity Actions

static analysis: an enum value is not an appropriate left operand [MISRA 2012 Rule 10.1, required]

Browse source
This commit is contained in:
temi54c1l8 2024-06-10 17:59:05 +02:00
parent 446925be63
commit 0142f41857
14 changed files with 169 additions and 169 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

50
301/CO_Emergency.c
View file

@ -137,8 +137,8 @@ static ODR_t OD_read_1014_default(OD_stream_t *stream, void *buf,
CO_EM_t *em = (CO_EM_t *)stream->object;
COB_IDEmergency32 |= CO_CAN_ID_EMERGENCY + em->nodeId;
uint32_t COB_IDEmergency32 = em->producerEnabled ? 0U : 0x80000000U;
COB_IDEmergency32 |= (uint32_t)CO_CAN_ID_EMERGENCY + em->nodeId;
(void)CO_setUint32(buf, COB_IDEmergency32);
*countRead = sizeof(uint32_t);
@ -441,7 +441,7 @@ CO_ReturnError_t CO_EM_init(CO_EM_t *em,
* to add nodeId of this node to the stored value. */
if (producerCanId == CO_CAN_ID_EMERGENCY) producerCanId += nodeId;
#else
uint16_t producerCanId = CO_CAN_ID_EMERGENCY + nodeId;
uint32_t producerCanId = (uint32_t)CO_CAN_ID_EMERGENCY + nodeId;
em->producerEnabled = (COB_IDEmergency32 & 0x80000000U) == 0U;
em->OD_1014_extension.object = em;
@ -564,33 +564,33 @@ void CO_EM_process(CO_EM_t *em,
uint16_t CANerrStChanged = CANerrSt ^ em->CANerrorStatusOld;
em->CANerrorStatusOld = CANerrSt;
if (CANerrStChanged & (CO_CAN_ERRTX_WARNING | CO_CAN_ERRRX_WARNING)) {
if (CANerrStChanged & ((uint16_t)CO_CAN_ERRTX_WARNING | (uint16_t)CO_CAN_ERRRX_WARNING)) {
CO_error(em,
(CANerrSt & (CO_CAN_ERRTX_WARNING | CO_CAN_ERRRX_WARNING)) != 0,
(CANerrSt & ((uint16_t)CO_CAN_ERRTX_WARNING | (uint16_t)CO_CAN_ERRRX_WARNING)) != 0U,
CO_EM_CAN_BUS_WARNING, CO_EMC_NO_ERROR, 0);
}
if (CANerrStChanged & CO_CAN_ERRTX_PASSIVE) {
CO_error(em, (CANerrSt & CO_CAN_ERRTX_PASSIVE) != 0,
if (CANerrStChanged & (uint16_t)CO_CAN_ERRTX_PASSIVE) {
CO_error(em, (CANerrSt & (uint16_t)CO_CAN_ERRTX_PASSIVE) != 0U,
CO_EM_CAN_TX_BUS_PASSIVE, CO_EMC_CAN_PASSIVE, 0);
}
if (CANerrStChanged & CO_CAN_ERRTX_BUS_OFF) {
CO_error(em, (CANerrSt & CO_CAN_ERRTX_BUS_OFF) != 0,
if (CANerrStChanged & (uint16_t)CO_CAN_ERRTX_BUS_OFF) {
CO_error(em, (CANerrSt & (uint16_t)CO_CAN_ERRTX_BUS_OFF) != 0U,
CO_EM_CAN_TX_BUS_OFF, CO_EMC_BUS_OFF_RECOVERED, 0);
}
if (CANerrStChanged & CO_CAN_ERRTX_OVERFLOW) {
CO_error(em, (CANerrSt & CO_CAN_ERRTX_OVERFLOW) != 0,
if (CANerrStChanged & (uint16_t)CO_CAN_ERRTX_OVERFLOW) {
CO_error(em, (CANerrSt & (uint16_t)CO_CAN_ERRTX_OVERFLOW) != 0U,
CO_EM_CAN_TX_OVERFLOW, CO_EMC_CAN_OVERRUN, 0);
}
if (CANerrStChanged & CO_CAN_ERRTX_PDO_LATE) {
CO_error(em, (CANerrSt & CO_CAN_ERRTX_PDO_LATE) != 0,
if (CANerrStChanged & (uint16_t)CO_CAN_ERRTX_PDO_LATE) {
CO_error(em, (CANerrSt & (uint16_t)CO_CAN_ERRTX_PDO_LATE) != 0U,
CO_EM_TPDO_OUTSIDE_WINDOW, CO_EMC_COMMUNICATION, 0);
}
if (CANerrStChanged & CO_CAN_ERRRX_PASSIVE) {
CO_error(em, (CANerrSt & CO_CAN_ERRRX_PASSIVE) != 0,
if (CANerrStChanged & (uint16_t)CO_CAN_ERRRX_PASSIVE) {
CO_error(em, (CANerrSt & (uint16_t)CO_CAN_ERRRX_PASSIVE) != 0U,
CO_EM_CAN_RX_BUS_PASSIVE, CO_EMC_CAN_PASSIVE, 0);
}
if (CANerrStChanged & CO_CAN_ERRRX_OVERFLOW) {
CO_error(em, (CANerrSt & CO_CAN_ERRRX_OVERFLOW) != 0,
if (CANerrStChanged & (uint16_t)CO_CAN_ERRRX_OVERFLOW) {
CO_error(em, (CANerrSt & (uint16_t)CO_CAN_ERRRX_OVERFLOW) != 0U,
CO_EM_CAN_RXB_OVERFLOW, CO_EMC_CAN_OVERRUN, 0);
}
}
@ -598,33 +598,33 @@ void CO_EM_process(CO_EM_t *em,
/* calculate Error register */
uint8_t errorRegister = 0U;
if (CO_CONFIG_ERR_CONDITION_GENERIC) {
errorRegister |= CO_ERR_REG_GENERIC_ERR;
errorRegister |= (uint8_t)CO_ERR_REG_GENERIC_ERR;
}
#ifdef CO_CONFIG_ERR_CONDITION_CURRENT
if (CO_CONFIG_ERR_CONDITION_CURRENT) {
errorRegister |= CO_ERR_REG_CURRENT;
errorRegister |= (uint8_t)CO_ERR_REG_CURRENT;
}
#endif
#ifdef CO_CONFIG_ERR_CONDITION_VOLTAGE
if (CO_CONFIG_ERR_CONDITION_VOLTAGE) {
errorRegister |= CO_ERR_REG_VOLTAGE;
errorRegister |= (uint8_t)CO_ERR_REG_VOLTAGE;
}
#endif
#ifdef CO_CONFIG_ERR_CONDITION_TEMPERATURE
if (CO_CONFIG_ERR_CONDITION_TEMPERATURE) {
errorRegister |= CO_ERR_REG_TEMPERATURE;
errorRegister |= (uint8_t)CO_ERR_REG_TEMPERATURE;
}
#endif
if (CO_CONFIG_ERR_CONDITION_COMMUNICATION) {
errorRegister |= CO_ERR_REG_COMMUNICATION;
errorRegister |= (uint8_t)CO_ERR_REG_COMMUNICATION;
}
#ifdef CO_CONFIG_ERR_CONDITION_DEV_PROFILE
if (CO_CONFIG_ERR_CONDITION_DEV_PROFILE) {
errorRegister |= CO_ERR_REG_DEV_PROFILE;
errorRegister |= (uint8_t)CO_ERR_REG_DEV_PROFILE;
}
#endif
if (CO_CONFIG_ERR_CONDITION_MANUFACTURER) {
errorRegister |= CO_ERR_REG_MANUFACTURER;
errorRegister |= (uint8_t)CO_ERR_REG_MANUFACTURER;
}
*em->errorRegister = errorRegister;
@ -681,7 +681,7 @@ void CO_EM_process(CO_EM_t *em,
}
else if ((em->fifoOverflow == 2U) && (em->fifoPpPtr == em->fifoWrPtr)) {
em->fifoOverflow = 0;
CO_errorReset(em, CO_EM_EMERGENCY_BUFFER_FULL, 0);
CO_errorReset(em, (uint8_t)CO_EM_EMERGENCY_BUFFER_FULL, 0);
}
else { /* MISRA C 2004 14.10 */ }
}
@ -719,7 +719,7 @@ void CO_EM_process(CO_EM_t *em,
/******************************************************************************/
void CO_error(CO_EM_t *em, bool_t setError, const uint8_t errorBit,
void CO_error(CO_EM_t *em, bool_t setError, const CO_EM_errorStatusBits_t errorBit,
uint16_t errorCode, uint32_t infoCode)
{
if (em == NULL) { return; }

10
301/CO_HBconsumer.c
View file

@ -214,8 +214,8 @@ static CO_ReturnError_t CO_HBconsumer_initEntry(CO_HBconsumer_t *HBcons,
CO_FLAG_CLEAR(monitoredNode->CANrxNew);
/* is channel used */
COB_ID = monitoredNode->nodeId + CO_CAN_ID_HEARTBEAT;
if ((monitoredNode->nodeId != 0U) && (monitoredNode->time_us != 0U)) {
COB_ID = monitoredNode->nodeId + (uint16_t)CO_CAN_ID_HEARTBEAT;
monitoredNode->HBstate = CO_HBconsumer_UNKNOWN;
}
else {
@ -388,7 +388,7 @@ void CO_HBconsumer_process(
#endif
if (monitoredNode->HBstate == CO_HBconsumer_ACTIVE) {
CO_errorReport(HBcons->em,
CO_EM_HB_CONSUMER_REMOTE_RESET,
(uint8_t)CO_EM_HB_CONSUMER_REMOTE_RESET,
CO_EMC_HEARTBEAT, i);
}
monitoredNode->HBstate = CO_HBconsumer_UNKNOWN;
@ -425,7 +425,7 @@ void CO_HBconsumer_process(
monitoredNode->functSignalObjectTimeout);
}
#endif
CO_errorReport(HBcons->em, CO_EM_HEARTBEAT_CONSUMER,
CO_errorReport(HBcons->em, (uint8_t)CO_EM_HEARTBEAT_CONSUMER,
CO_EMC_HEARTBEAT, i);
monitoredNode->NMTstate = CO_NMT_UNKNOWN;
monitoredNode->HBstate = CO_HBconsumer_TIMEOUT;
@ -492,8 +492,8 @@ void CO_HBconsumer_process(
/* Clear emergencies when all monitored nodes becomes active.
* We only have one emergency index for all monitored nodes! */
if (!HBcons->allMonitoredActive && allMonitoredActiveCurrent) {
CO_errorReset(HBcons->em, CO_EM_HEARTBEAT_CONSUMER, 0);
CO_errorReset(HBcons->em, CO_EM_HB_CONSUMER_REMOTE_RESET, 0);
CO_errorReset(HBcons->em, (uint8_t)CO_EM_HEARTBEAT_CONSUMER, 0);
CO_errorReset(HBcons->em, (uint8_t)CO_EM_HB_CONSUMER_REMOTE_RESET, 0);
}
HBcons->allMonitoredActive = allMonitoredActiveCurrent;

12
301/CO_NMT_Heartbeat.c
View file

@ -243,7 +243,7 @@ CO_NMT_reset_cmd_t CO_NMT_process(CO_NMT_t *NMT,
if (NMTstateCpy == CO_NMT_INITIALIZING) {
/* NMT slave self starting */
NMTstateCpy = ((NMT->NMTcontrol & CO_NMT_STARTUP_TO_OPERATIONAL) != 0)
NMTstateCpy = (((uint16_t)NMT->NMTcontrol & (uint16_t)CO_NMT_STARTUP_TO_OPERATIONAL) != 0U)
? CO_NMT_OPERATIONAL : CO_NMT_PRE_OPERATIONAL;
}
else {
@ -282,18 +282,18 @@ CO_NMT_reset_cmd_t CO_NMT_process(CO_NMT_t *NMT,
}
/* verify NMT transitions based on error register */
bool_t busOff_HB = ((NMT->NMTcontrol & CO_NMT_ERR_ON_BUSOFF_HB) != 0)
bool_t busOff_HB = (((uint16_t)NMT->NMTcontrol & (uint16_t)CO_NMT_ERR_ON_BUSOFF_HB) != 0U)
&& (CO_isError(NMT->em, CO_EM_CAN_TX_BUS_OFF)
|| CO_isError(NMT->em, CO_EM_HEARTBEAT_CONSUMER)
|| CO_isError(NMT->em, CO_EM_HB_CONSUMER_REMOTE_RESET));
bool_t errRegMasked = ((NMT->NMTcontrol & CO_NMT_ERR_ON_ERR_REG) != 0)
&& ((CO_getErrorRegister(NMT->em) & NMT->NMTcontrol) != 0);
bool_t errRegMasked = (((uint16_t)NMT->NMTcontrol & (uint16_t)CO_NMT_ERR_ON_ERR_REG) != 0U)
&& ((CO_getErrorRegister(NMT->em) & (uint8_t)NMT->NMTcontrol) != 0U);
if ((NMTstateCpy == CO_NMT_OPERATIONAL) && (busOff_HB || errRegMasked)) {
NMTstateCpy = ((NMT->NMTcontrol & CO_NMT_ERR_TO_STOPPED) != 0)
NMTstateCpy = (((uint16_t)NMT->NMTcontrol & (uint16_t)CO_NMT_ERR_TO_STOPPED) != 0U)
? CO_NMT_STOPPED : CO_NMT_PRE_OPERATIONAL;
}
else if (((NMT->NMTcontrol & CO_NMT_ERR_FREE_TO_OPERATIONAL) != 0)
else if ((((uint16_t)NMT->NMTcontrol & (uint16_t)CO_NMT_ERR_FREE_TO_OPERATIONAL) != 0U)
&& (NMTstateCpy == CO_NMT_PRE_OPERATIONAL) && (!busOff_HB && !errRegMasked)
) {
NMTstateCpy = CO_NMT_OPERATIONAL;

8
301/CO_Node_Guarding.c
View file

@ -229,7 +229,7 @@ void CO_nodeGuardingSlave_process(CO_nodeGuardingSlave_t *ngs,
if (ngs->lifeTimeTimeout) {
/* error bit is shared with HB consumer */
CO_errorReset(ngs->em, CO_EM_HEARTBEAT_CONSUMER, 0);
CO_errorReset(ngs->em, (uint8_t)CO_EM_HEARTBEAT_CONSUMER, 0);
ngs->lifeTimeTimeout = false;
}
@ -252,7 +252,7 @@ void CO_nodeGuardingSlave_process(CO_nodeGuardingSlave_t *ngs,
ngs->lifeTimeTimeout = true;
/* error bit is shared with HB consumer */
CO_errorReport(ngs->em, CO_EM_HEARTBEAT_CONSUMER,
CO_errorReport(ngs->em, (uint8_t)CO_EM_HEARTBEAT_CONSUMER,
CO_EMC_HEARTBEAT, 0);
}
}
@ -415,12 +415,12 @@ void CO_nodeGuardingMaster_process(CO_nodeGuardingMaster_t *ngm,
if (!node->responseRecived) {
node->monitoringActive = false;
/* error bit is shared with HB consumer */
CO_errorReport(ngm->em, CO_EM_HEARTBEAT_CONSUMER,
CO_errorReport(ngm->em, (uint8_t)CO_EM_HEARTBEAT_CONSUMER,
CO_EMC_HEARTBEAT, node->ident & 0x7F);
}
else if (node->NMTstate != CO_NMT_UNKNOWN) {
node->monitoringActive = true;
CO_errorReset(ngm->em, CO_EM_HEARTBEAT_CONSUMER,
CO_errorReset(ngm->em, (uint8_t)CO_EM_HEARTBEAT_CONSUMER,
node->ident & 0x7F);
}
}

6
301/CO_ODinterface.c
View file

@ -188,7 +188,7 @@ ODR_t OD_getSub(const OD_entry_t *entry, uint8_t subIndex,
OD_stream_t *stream = &io->stream;
/* attribute, dataOrig and dataLength, depends on object type */
switch (entry->odObjectType & ODT_TYPE_MASK) {
switch (entry->odObjectType & (uint8_t)ODT_TYPE_MASK) {
case ODT_VAR: {
if (subIndex > 0U) { return ODR_SUB_NOT_EXIST; }
CO_PROGMEM OD_obj_var_t *odo = entry->odObject;
@ -212,7 +212,7 @@ ODR_t OD_getSub(const OD_entry_t *entry, uint8_t subIndex,
stream->attribute = odo->attribute;
uint8_t *ptr = odo->dataOrig;
stream->dataOrig = (ptr == NULL) ? ptr
: (ptr + (odo->dataElementSizeof * (subIndex - 1)));
: (ptr + (odo->dataElementSizeof * (uint8_t)(subIndex - 1U)));
stream->dataLength = odo->dataElementLength;
}
break;
@ -294,7 +294,7 @@ uint32_t OD_getSDOabCode(ODR_t returnCode) {
0x08000024UL /* No data available */
};
return ((returnCode < 0) || (returnCode >= ODR_COUNT)) ?
return ((returnCode < ODR_OK) || (returnCode >= ODR_COUNT)) ?
abortCodes[ODR_DEV_INCOMPAT] : abortCodes[returnCode];
}

2
301/CO_ODinterface.h
View file

@ -453,7 +453,7 @@ static inline uint16_t OD_getIndex(const OD_entry_t *entry) {
*/
static inline bool_t OD_mappable(OD_stream_t *stream) {
return (stream != NULL)
? ((stream->attribute & (ODA_TRPDO | ODA_TRSRDO)) != 0) : false;
? ((stream->attribute & ((OD_attr_t)ODA_TRPDO | (OD_attr_t)ODA_TRSRDO)) != 0U) : false;
}

56
301/CO_PDO.c
View file

@ -474,10 +474,10 @@ static void CO_PDO_receive(void *object, void *msg) {
if (DLC >= PDO->dataLength) {
/* indicate errors in PDO length */
if (DLC == PDO->dataLength) {
if (err == CO_RPDO_RX_ACK_ERROR) { err = CO_RPDO_RX_OK; }
if (err == (uint8_t)CO_RPDO_RX_ACK_ERROR) { err = CO_RPDO_RX_OK; }
}
else {
if (err == CO_RPDO_RX_ACK_NO_ERROR) { err = CO_RPDO_RX_LONG; }
if (err == (uint8_t)CO_RPDO_RX_ACK_NO_ERROR) { err = CO_RPDO_RX_LONG; }
}
/* Determine, to which of the two rx buffers copy the message. */
@ -502,7 +502,7 @@ static void CO_PDO_receive(void *object, void *msg) {
}
#endif
}
else if (err == CO_RPDO_RX_ACK_NO_ERROR) {
else if (err == (uint8_t)CO_RPDO_RX_ACK_NO_ERROR) {
err = CO_RPDO_RX_SHORT;
}
else { /* MISRA C 2004 14.10 */ }
@ -588,13 +588,13 @@ static ODR_t OD_write_14xx(OD_stream_t *stream, const void *buf,
case 2: { /* transmission type */
uint8_t transmissionType = CO_getUint8(buf);
#if (CO_CONFIG_PDO) & CO_CONFIG_PDO_SYNC_ENABLE
if ((transmissionType > CO_PDO_TRANSM_TYPE_SYNC_240)
&& (transmissionType < CO_PDO_TRANSM_TYPE_SYNC_EVENT_LO)
if ((transmissionType > (uint8_t)CO_PDO_TRANSM_TYPE_SYNC_240)
&& (transmissionType < (uint8_t)CO_PDO_TRANSM_TYPE_SYNC_EVENT_LO)
) {
return ODR_INVALID_VALUE;
}
bool_t synchronous = transmissionType <= CO_PDO_TRANSM_TYPE_SYNC_240;
bool_t synchronous = transmissionType <= (uint8_t)CO_PDO_TRANSM_TYPE_SYNC_240;
/* Remove old message from the second buffer. */
if (RPDO->synchronous != synchronous) {
CO_FLAG_CLEAR(RPDO->CANrxNew[1]);
@ -692,7 +692,7 @@ CO_ReturnError_t CO_RPDO_init(CO_RPDO_t *RPDO,
if (erroneousMap != 0U) {
CO_errorReport(PDO->em,
CO_EM_PDO_WRONG_MAPPING, CO_EMC_PROTOCOL_ERROR,
(uint8_t)CO_EM_PDO_WRONG_MAPPING, CO_EMC_PROTOCOL_ERROR,
(erroneousMap != 1U) ? erroneousMap : COB_ID);
}
if (!valid) {
@ -731,7 +731,7 @@ CO_ReturnError_t CO_RPDO_init(CO_RPDO_t *RPDO,
}
RPDO->SYNC = SYNC;
RPDO->synchronous = transmissionType <= CO_PDO_TRANSM_TYPE_SYNC_240;
RPDO->synchronous = transmissionType <= (uint8_t)CO_PDO_TRANSM_TYPE_SYNC_240;
#endif
@ -795,9 +795,9 @@ void CO_RPDO_process(CO_RPDO_t *RPDO,
#endif
) {
/* Verify errors in length of received RPDO CAN message */
if (RPDO->receiveError > CO_RPDO_RX_ACK) {
bool_t setError = RPDO->receiveError != CO_RPDO_RX_OK;
uint16_t code = (RPDO->receiveError == CO_RPDO_RX_SHORT)
if (RPDO->receiveError > (uint8_t)CO_RPDO_RX_ACK) {
bool_t setError = RPDO->receiveError != (uint8_t)CO_RPDO_RX_OK;
uint16_t code = (RPDO->receiveError == (uint8_t)CO_RPDO_RX_SHORT)
? CO_EMC_PDO_LENGTH : CO_EMC_PDO_LENGTH_EXC;
CO_error(PDO->em, setError, CO_EM_RPDO_WRONG_LENGTH,
code, PDO->dataLength);
@ -888,7 +888,7 @@ void CO_RPDO_process(CO_RPDO_t *RPDO,
if (RPDO->timeoutTime_us > 0U) {
if (rpdoReceived) {
if (RPDO->timeoutTimer > RPDO->timeoutTime_us) {
CO_errorReset(PDO->em, CO_EM_RPDO_TIME_OUT,
CO_errorReset(PDO->em, (uint8_t)CO_EM_RPDO_TIME_OUT,
RPDO->timeoutTimer);
}
/* enable monitoring */
@ -900,7 +900,7 @@ void CO_RPDO_process(CO_RPDO_t *RPDO,
RPDO->timeoutTimer += timeDifference_us;
if (RPDO->timeoutTimer > RPDO->timeoutTime_us) {
CO_errorReport(PDO->em, CO_EM_RPDO_TIME_OUT,
CO_errorReport(PDO->em, (uint8_t)CO_EM_RPDO_TIME_OUT,
CO_EMC_RPDO_TIMEOUT, RPDO->timeoutTimer);
}
}
@ -995,7 +995,7 @@ static ODR_t OD_write_18xx(OD_stream_t *stream, const void *buf,
CAN_ID, /* CAN identifier */
0, /* rtr */
PDO->dataLength, /* number of data bytes */
TPDO->transmissionType <= CO_PDO_TRANSM_TYPE_SYNC_240);
TPDO->transmissionType <= (uint8_t)CO_PDO_TRANSM_TYPE_SYNC_240);
/* synchronous message flag */
if (CANtxBuff == NULL) {
@ -1012,13 +1012,13 @@ static ODR_t OD_write_18xx(OD_stream_t *stream, const void *buf,
case 2: { /* transmission type */
uint8_t transmissionType = CO_getUint8(buf);
#if (CO_CONFIG_PDO) & CO_CONFIG_PDO_SYNC_ENABLE
if ((transmissionType > CO_PDO_TRANSM_TYPE_SYNC_240)
&& (transmissionType < CO_PDO_TRANSM_TYPE_SYNC_EVENT_LO)
if ((transmissionType > (uint8_t)CO_PDO_TRANSM_TYPE_SYNC_240)
&& (transmissionType < (uint8_t)CO_PDO_TRANSM_TYPE_SYNC_EVENT_LO)
) {
return ODR_INVALID_VALUE;
}
TPDO->CANtxBuff->syncFlag =
transmissionType <= CO_PDO_TRANSM_TYPE_SYNC_240;
transmissionType <= (uint8_t)CO_PDO_TRANSM_TYPE_SYNC_240;
TPDO->syncCounter = 255;
#else
if (transmissionType < CO_PDO_TRANSM_TYPE_SYNC_EVENT_LO) {
@ -1123,13 +1123,13 @@ CO_ReturnError_t CO_TPDO_init(CO_TPDO_t *TPDO,
odRet = OD_get_u8(OD_18xx_TPDOCommPar, 2, &transmissionType, true);
if (odRet != ODR_OK) {
if (errInfo != NULL) {
*errInfo = (((uint32_t)OD_getIndex(OD_18xx_TPDOCommPar)) << 8) | 2;
*errInfo = (((uint32_t)OD_getIndex(OD_18xx_TPDOCommPar)) << 8) | 2U;
}
return CO_ERROR_OD_PARAMETERS;
}
if ((transmissionType < CO_PDO_TRANSM_TYPE_SYNC_EVENT_LO)
if ((transmissionType < (uint8_t)CO_PDO_TRANSM_TYPE_SYNC_EVENT_LO)
#if (CO_CONFIG_PDO) & CO_CONFIG_PDO_SYNC_ENABLE
&& (transmissionType > CO_PDO_TRANSM_TYPE_SYNC_240)
&& (transmissionType > (uint8_t)CO_PDO_TRANSM_TYPE_SYNC_240)
#endif
) {
transmissionType = CO_PDO_TRANSM_TYPE_SYNC_EVENT_LO;
@ -1156,7 +1156,7 @@ CO_ReturnError_t CO_TPDO_init(CO_TPDO_t *TPDO,
if (erroneousMap != 0U) {
CO_errorReport(PDO->em,
CO_EM_PDO_WRONG_MAPPING, CO_EMC_PROTOCOL_ERROR,
(uint8_t)CO_EM_PDO_WRONG_MAPPING, CO_EMC_PROTOCOL_ERROR,
(erroneousMap != 1U) ? erroneousMap : COB_ID);
}
if (!valid) {
@ -1174,7 +1174,7 @@ CO_ReturnError_t CO_TPDO_init(CO_TPDO_t *TPDO,
CAN_ID, /* CAN identifier */
0, /* rtr */
PDO->dataLength, /* number of data bytes */
TPDO->transmissionType <= CO_PDO_TRANSM_TYPE_SYNC_240);
TPDO->transmissionType <= (uint8_t)CO_PDO_TRANSM_TYPE_SYNC_240);
/* synchronous message flag bit */
if (TPDO->CANtxBuff == NULL) {
return CO_ERROR_ILLEGAL_ARGUMENT;
@ -1239,8 +1239,8 @@ static CO_ReturnError_t CO_TPDOsend(CO_TPDO_t *TPDO) {
uint8_t *dataTPDO = &TPDO->CANtxBuff->data[0];
#if OD_FLAGS_PDO_SIZE > 0
bool_t eventDriven =
((TPDO->transmissionType == CO_PDO_TRANSM_TYPE_SYNC_ACYCLIC)
|| (TPDO->transmissionType >= CO_PDO_TRANSM_TYPE_SYNC_EVENT_LO));
((TPDO->transmissionType == (uint8_t)CO_PDO_TRANSM_TYPE_SYNC_ACYCLIC)
|| (TPDO->transmissionType >= (uint8_t)CO_PDO_TRANSM_TYPE_SYNC_EVENT_LO));
#endif
#if (CO_CONFIG_PDO) & CO_CONFIG_PDO_OD_IO_ACCESS
@ -1344,8 +1344,8 @@ void CO_TPDO_process(CO_TPDO_t *TPDO,
/* check for event timer or application event */
#if ((CO_CONFIG_PDO) & CO_CONFIG_TPDO_TIMERS_ENABLE) || (OD_FLAGS_PDO_SIZE > 0)
if ((TPDO->transmissionType == CO_PDO_TRANSM_TYPE_SYNC_ACYCLIC)
|| (TPDO->transmissionType >= CO_PDO_TRANSM_TYPE_SYNC_EVENT_LO)
if ((TPDO->transmissionType == (uint8_t)CO_PDO_TRANSM_TYPE_SYNC_ACYCLIC)
|| (TPDO->transmissionType >= (uint8_t)CO_PDO_TRANSM_TYPE_SYNC_EVENT_LO)
) {
/* event timer */
#if (CO_CONFIG_PDO) & CO_CONFIG_TPDO_TIMERS_ENABLE
@ -1382,7 +1382,7 @@ void CO_TPDO_process(CO_TPDO_t *TPDO,
/* Send PDO by application request or by Event timer */
if (TPDO->transmissionType >= CO_PDO_TRANSM_TYPE_SYNC_EVENT_LO) {
if (TPDO->transmissionType >= (uint8_t)CO_PDO_TRANSM_TYPE_SYNC_EVENT_LO) {
#if (CO_CONFIG_PDO) & CO_CONFIG_TPDO_TIMERS_ENABLE
TPDO->inhibitTimer = (TPDO->inhibitTimer > timeDifference_us)
? (TPDO->inhibitTimer - timeDifference_us) : 0U;
@ -1411,7 +1411,7 @@ void CO_TPDO_process(CO_TPDO_t *TPDO,
#if (CO_CONFIG_PDO) & CO_CONFIG_PDO_SYNC_ENABLE
else if ((TPDO->SYNC != NULL) && syncWas) {
/* send synchronous acyclic TPDO */
if (TPDO->transmissionType == CO_PDO_TRANSM_TYPE_SYNC_ACYCLIC) {
if (TPDO->transmissionType == (uint8_t)CO_PDO_TRANSM_TYPE_SYNC_ACYCLIC) {
if (TPDO->sendRequest) { CO_TPDOsend(TPDO); }
}
/* send synchronous cyclic TPDO */

10
301/CO_SDOserver.c
View file

@ -365,15 +365,15 @@ CO_ReturnError_t CO_SDOserver_init(CO_SDOserver_t *SDO,
return CO_ERROR_ILLEGAL_ARGUMENT;
}
CanId_ClientToServer = CO_CAN_ID_SDO_CLI + nodeId;
CanId_ServerToClient = CO_CAN_ID_SDO_SRV + nodeId;
CanId_ClientToServer = (uint16_t)CO_CAN_ID_SDO_CLI + nodeId;
CanId_ServerToClient = (uint16_t)CO_CAN_ID_SDO_SRV + nodeId;
SDO->valid = true;
OD_set_u32(OD_1200_SDOsrvPar, 1, CanId_ClientToServer, true);
OD_set_u32(OD_1200_SDOsrvPar, 2, CanId_ServerToClient, true);
}
else if ((OD_SDOsrvParIdx > OD_H1200_SDO_SERVER_1_PARAM)
&& (OD_SDOsrvParIdx <= (OD_H1200_SDO_SERVER_1_PARAM + 0x7F))
else if ((OD_SDOsrvParIdx > (uint16_t)OD_H1200_SDO_SERVER_1_PARAM)
&& (OD_SDOsrvParIdx <= ((uint16_t)OD_H1200_SDO_SERVER_1_PARAM + 0x7FU))
) {
/* configure additional SDO channel and SDO server parameters for it */
uint8_t maxSubIndex;
@ -896,7 +896,7 @@ CO_SDO_return_t CO_SDOserver_process(CO_SDOserver_t *SDO,
}
/* strings are allowed to be shorter */
else if ((SDO->sizeInd < sizeInOd)
&& ((SDO->OD_IO.stream.attribute & ODA_STR) == 0)
&& ((SDO->OD_IO.stream.attribute & (OD_attr_t)ODA_STR) == 0U)
) {
abortCode = CO_SDO_AB_DATA_SHORT;
SDO->state = CO_SDO_ST_ABORT;

4
301/CO_SYNC.c
View file

@ -447,8 +447,8 @@ CO_SYNC_status_t CO_SYNC_process(CO_SYNC_t *SYNC,
}
/* verify error from receive function */
CO_errorReport(SYNC->em, CO_EM_SYNC_LENGTH,
if (SYNC->receiveError != 0U) {
CO_errorReport(SYNC->em, (uint8_t)CO_EM_SYNC_LENGTH,
CO_EMC_SYNC_DATA_LENGTH, SYNC->receiveError);
SYNC->receiveError = 0;
}
@ -461,8 +461,8 @@ CO_SYNC_status_t CO_SYNC_process(CO_SYNC_t *SYNC,
}
if (syncStatus == CO_SYNC_RX_TX) {
CO_errorReset(SYNC->em, CO_EM_SYNC_TIME_OUT, 0);
if (SYNC->timeoutError == 2U) {
CO_errorReset(SYNC->em, (uint8_t)CO_EM_SYNC_TIME_OUT, 0);
}
SYNC->timeoutError = 1;
}

4
301/CO_fifo.c
View file

@ -794,7 +794,7 @@ size_t CO_fifo_cpyTok2U8(CO_fifo_t *dest, CO_fifo_t *src, CO_fifo_st *status) {
else {
char *sRet;
uint32_t u32 = strtoul(buf, &sRet, 0);
if ((sRet != strchr(buf, '\0')) || (u32 > UINT8_MAX)) st |= CO_fifo_st_errVal;
if ((sRet != strchr(buf, '\0')) || (u32 > (uint32_t)UINT8_MAX)) st |= CO_fifo_st_errVal;
else {
uint8_t num = (uint8_t) u32;
nWr = CO_fifo_write(dest, &num, sizeof(num), NULL);
@ -816,7 +816,7 @@ size_t CO_fifo_cpyTok2U16(CO_fifo_t *dest, CO_fifo_t *src, CO_fifo_st *status) {
else {
char *sRet;
uint32_t u32 = strtoul(buf, &sRet, 0);
if ((sRet != strchr(buf, '\0')) || (u32 > UINT16_MAX)) st |= CO_fifo_st_errVal;
if ((sRet != strchr(buf, '\0')) || (u32 > (uint32_t)UINT16_MAX)) st |= CO_fifo_st_errVal;
else {
uint16_t num = CO_SWAP_16((uint16_t) u32);
nWr = CO_fifo_write(dest, (uint8_t *)&num, sizeof(num), NULL);

54
303/CO_LEDs.c
View file

@ -64,8 +64,8 @@ void CO_LEDs_process(CO_LEDs_t *LEDs,
bool_t tick = false;
LEDs->LEDtmr50ms += timeDifference_us;
bool_t rdFlickerNext = (LEDs->LEDred & CO_LED_flicker) == 0;
while (LEDs->LEDtmr50ms >= 50000U) {
bool_t rdFlickerNext = (LEDs->LEDred & (uint8_t)CO_LED_flicker) == 0U;
tick = true;
LEDs->LEDtmr50ms -= 50000U;
@ -75,43 +75,43 @@ void CO_LEDs_process(CO_LEDs_t *LEDs,
LEDs->LEDtmr200ms = 0;
rd = gr = 0;
if ((LEDs->LEDred & CO_LED_blink) == 0) { rd |= CO_LED_blink; }
else { gr |= CO_LED_blink; }
if ((LEDs->LEDred & (uint8_t)CO_LED_blink) == 0U) { rd |= (uint8_t)CO_LED_blink; }
else { gr |= (uint8_t)CO_LED_blink; }
switch (++LEDs->LEDtmrflash_1) {
case 1: rd |= CO_LED_flash_1; break;
case 2: gr |= CO_LED_flash_1; break;
case 1: rd |= (uint8_t)CO_LED_flash_1; break;
case 2: gr |= (uint8_t)CO_LED_flash_1; break;
case 6: LEDs->LEDtmrflash_1 = 0; break;
default: break;
}
switch (++LEDs->LEDtmrflash_2) {
case 1: case 3: rd |= CO_LED_flash_2; break;
case 2: case 4: gr |= CO_LED_flash_2; break;
case 1: case 3: rd |= (uint8_t)CO_LED_flash_2; break;
case 2: case 4: gr |= (uint8_t)CO_LED_flash_2; break;
case 8: LEDs->LEDtmrflash_2 = 0; break;
default: break;
}
switch (++LEDs->LEDtmrflash_3) {
case 1: case 3: case 5: rd |= CO_LED_flash_3; break;
case 2: case 4: case 6: gr |= CO_LED_flash_3; break;
case 1: case 3: case 5: rd |= (uint8_t)CO_LED_flash_3; break;
case 2: case 4: case 6: gr |= (uint8_t)CO_LED_flash_3; break;
case 10: LEDs->LEDtmrflash_3 = 0; break;
default: break;
}
switch (++LEDs->LEDtmrflash_4) {
case 1: case 3: case 5: case 7: rd |= CO_LED_flash_4; break;
case 2: case 4: case 6: case 8: gr |= CO_LED_flash_4; break;
case 1: case 3: case 5: case 7: rd |= (uint8_t)CO_LED_flash_4; break;
case 2: case 4: case 6: case 8: gr |= (uint8_t)CO_LED_flash_4; break;
case 12: LEDs->LEDtmrflash_4 = 0; break;
default: break;
}
}
else {
/* clear flicker and CANopen bits, keep others */
rd = LEDs->LEDred & (0xFF ^ (CO_LED_flicker | CO_LED_CANopen));
gr = LEDs->LEDgreen & (0xFF ^ (CO_LED_flicker | CO_LED_CANopen));
rd = LEDs->LEDred & (0xFFU ^ ((uint8_t)CO_LED_flicker | (uint8_t)CO_LED_CANopen));
gr = LEDs->LEDgreen & (0xFFU ^ ((uint8_t)CO_LED_flicker | (uint8_t)CO_LED_CANopen));
}
/* calculate 10Hz flickering */
if (rdFlickerNext) { rd |= CO_LED_flicker; }
else { gr |= CO_LED_flicker; }
if (rdFlickerNext) { rd |= (uint8_t)CO_LED_flicker; }
else { gr |= (uint8_t)CO_LED_flicker; }
} /* while (LEDs->LEDtmr50ms >= 50000) */
@ -120,24 +120,24 @@ void CO_LEDs_process(CO_LEDs_t *LEDs,
/* CANopen red ERROR LED */
if (ErrCANbusOff) { rd_co = 1;}
else if (NMTstate == CO_NMT_INITIALIZING){ rd_co = rd & CO_LED_flicker;}
else if (ErrRpdo) { rd_co = rd & CO_LED_flash_4;}
else if (ErrSync) { rd_co = rd & CO_LED_flash_3;}
else if (ErrHbCons) { rd_co = rd & CO_LED_flash_2;}
else if (ErrCANbusWarn) { rd_co = rd & CO_LED_flash_1;}
else if (ErrOther) { rd_co = rd & CO_LED_blink;}
else if (NMTstate == CO_NMT_INITIALIZING){ rd_co = rd & (uint8_t)CO_LED_flicker;}
else if (ErrRpdo) { rd_co = rd & (uint8_t)CO_LED_flash_4;}
else if (ErrSync) { rd_co = rd & (uint8_t)CO_LED_flash_3;}
else if (ErrHbCons) { rd_co = rd & (uint8_t)CO_LED_flash_2;}
else if (ErrCANbusWarn) { rd_co = rd & (uint8_t)CO_LED_flash_1;}
else if (ErrOther) { rd_co = rd & (uint8_t)CO_LED_blink;}
else { rd_co = 0;}
/* CANopen green RUN LED */
if (LSSconfig) {gr_co = gr & CO_LED_flicker;}
else if (firmwareDownload) {gr_co = gr & CO_LED_flash_3;}
else if (NMTstate == CO_NMT_STOPPED) {gr_co = gr & CO_LED_flash_1;}
else if (NMTstate == CO_NMT_PRE_OPERATIONAL){gr_co = gr & CO_LED_blink;}
if (LSSconfig) {gr_co = gr & (uint8_t)CO_LED_flicker;}
else if (firmwareDownload) {gr_co = gr & (uint8_t)CO_LED_flash_3;}
else if (NMTstate == CO_NMT_STOPPED) {gr_co = gr & (uint8_t)CO_LED_flash_1;}
else if (NMTstate == CO_NMT_PRE_OPERATIONAL){gr_co = gr & (uint8_t)CO_LED_blink;}
else if (NMTstate == CO_NMT_OPERATIONAL) {gr_co = 1;}
else {gr_co = 0;}
if (rd_co != 0) { rd |= CO_LED_CANopen; }
if (gr_co != 0) { gr |= CO_LED_CANopen; }
if (rd_co != 0U) { rd |= (uint8_t)CO_LED_CANopen; }
if (gr_co != 0U) { gr |= (uint8_t)CO_LED_CANopen; }
LEDs->LEDred = rd;
LEDs->LEDgreen = gr;
} /* if (tick) */

4
304/CO_SRDO.c
View file

@ -703,7 +703,7 @@ CO_SRDO_init(CO_SRDO_t* SRDO, uint8_t SRDO_Index, CO_SRDOGuard_t* SRDOGuard, OD_
}
else {
if (ret == CO_ERROR_NO) {
CO_errorReport(em, CO_EM_SRDO_CONFIGURATION, CO_EMC_DATA_SET, err);
CO_errorReport(em, (uint8_t)CO_EM_SRDO_CONFIGURATION, CO_EMC_DATA_SET, err);
configurationValidUnset(SRDO->SRDOGuard);
}
}
@ -868,7 +868,7 @@ CO_SRDO_process(CO_SRDO_t* SRDO, uint32_t timeDifference_us, uint32_t* timerNext
else { /* CO_SRDO_RX */
/* verify error from receive function */
if (SRDO->rxSrdoShort) {
CO_errorReport(SRDO->em, CO_EM_RPDO_WRONG_LENGTH, CO_EMC_PDO_LENGTH, 0);
CO_errorReport(SRDO->em, (uint8_t)CO_EM_RPDO_WRONG_LENGTH, CO_EMC_PDO_LENGTH, 0);
SRDO->internalState = CO_SRDO_state_error_rxShort;
}
else if (CO_FLAG_READ(SRDO->CANrxNew[SRDO->nextIsNormal ? 0 : 1])) {

8
305/CO_LSSslave.c
View file

@ -32,11 +32,11 @@
#include <string.h>
/* 'bit' must be unsigned or additional range check must be added: bit>=CO_LSS_FASTSCAN_BIT0 */
#define CO_LSS_FASTSCAN_BITCHECK_VALID(bit) ((bit<=CO_LSS_FASTSCAN_BIT31) || (bit==CO_LSS_FASTSCAN_CONFIRM))
#define CO_LSS_FASTSCAN_BITCHECK_VALID(bit) ((bit<=(uint8_t)CO_LSS_FASTSCAN_BIT31) || (bit==(uint8_t)CO_LSS_FASTSCAN_CONFIRM))
/* 'index' must be unsigned or additional range check must be added: index>=CO_LSS_FASTSCAN_VENDOR_ID */
#define CO_LSS_FASTSCAN_LSS_SUB_NEXT_VALID(index) (index<=CO_LSS_FASTSCAN_SERIAL)
#define CO_LSS_FASTSCAN_LSS_SUB_NEXT_VALID(index) (index<=(uint8_t)CO_LSS_FASTSCAN_SERIAL)
/* 'index' must be unsigned or additional range check must be added: index>=CO_LSS_BIT_TIMING_1000 */
#define CO_LSS_BIT_TIMING_VALID(index) ((index != 5) && (index <= CO_LSS_BIT_TIMING_AUTO))
#define CO_LSS_BIT_TIMING_VALID(index) ((index != 5U) && (index <= (uint8_t)CO_LSS_BIT_TIMING_AUTO))
/*
* Read received message from CAN module.
@ -136,7 +136,7 @@ static void CO_LSSslave_receive(void *object, void *msg)
idNumber = CO_SWAP_32(valSw);
ack = false;
if (bitCheck == CO_LSS_FASTSCAN_CONFIRM) {
if (bitCheck == (uint8_t)CO_LSS_FASTSCAN_CONFIRM) {
/* Confirm, Reset */
ack = true;
LSSslave->fastscanPos = CO_LSS_FASTSCAN_VENDOR_ID;

110
CANopen.c
View file

@ -33,8 +33,8 @@
#else
#include "OD.h"
#define CO_GET_CO(obj) CO_##obj
#define CO_GET_CNT(obj) OD_CNT_##obj
#define CO_GET_CO(obj) ((uint16_t)(CO_##obj))
#define CO_GET_CNT(obj) ((uint16_t)(OD_CNT_##obj))
#define OD_GET(entry, index) OD_ENTRY_##entry
/* Verify parameters from "OD.h" and calculate necessary values for each object:
@ -272,37 +272,37 @@
/* Indexes of CO_CANrx_t and CO_CANtx_t objects in CO_CANmodule_t and total
* number of them. Indexes are sorted in a way, that objects with highest
* priority of the CAN identifier are listed first. */
#define CO_RX_IDX_NMT_SLV 0
#define CO_RX_IDX_GFC (CO_RX_IDX_NMT_SLV + CO_RX_CNT_NMT_SLV)
#define CO_RX_IDX_SYNC (CO_RX_IDX_GFC + CO_RX_CNT_GFC)
#define CO_RX_IDX_EM_CONS (CO_RX_IDX_SYNC + CO_RX_CNT_SYNC)
#define CO_RX_IDX_TIME (CO_RX_IDX_EM_CONS + CO_RX_CNT_EM_CONS)
#define CO_RX_IDX_SRDO (CO_RX_IDX_TIME + CO_RX_CNT_TIME)
#define CO_RX_IDX_RPDO (CO_RX_IDX_SRDO + CO_RX_CNT_SRDO * 2)
#define CO_RX_IDX_SDO_SRV (CO_RX_IDX_RPDO + CO_RX_CNT_RPDO)
#define CO_RX_IDX_SDO_CLI (CO_RX_IDX_SDO_SRV + CO_RX_CNT_SDO_SRV)
#define CO_RX_IDX_HB_CONS (CO_RX_IDX_SDO_CLI + CO_RX_CNT_SDO_CLI)
#define CO_RX_IDX_NG_SLV (CO_RX_IDX_HB_CONS + CO_RX_CNT_HB_CONS)
#define CO_RX_IDX_NG_MST (CO_RX_IDX_NG_SLV + CO_RX_CNT_NG_SLV)
#define CO_RX_IDX_LSS_SLV (CO_RX_IDX_NG_MST + CO_RX_CNT_NG_MST)
#define CO_RX_IDX_LSS_MST (CO_RX_IDX_LSS_SLV + CO_RX_CNT_LSS_SLV)
#define CO_CNT_ALL_RX_MSGS (CO_RX_IDX_LSS_MST + CO_RX_CNT_LSS_MST)
#define CO_RX_IDX_NMT_SLV 0U
#define CO_RX_IDX_GFC (CO_RX_IDX_NMT_SLV + (uint16_t)CO_RX_CNT_NMT_SLV)
#define CO_RX_IDX_SYNC (CO_RX_IDX_GFC + (uint16_t)CO_RX_CNT_GFC)
#define CO_RX_IDX_EM_CONS (CO_RX_IDX_SYNC + (uint16_t)CO_RX_CNT_SYNC)
#define CO_RX_IDX_TIME (CO_RX_IDX_EM_CONS + (uint16_t)CO_RX_CNT_EM_CONS)
#define CO_RX_IDX_SRDO (CO_RX_IDX_TIME + (uint16_t)CO_RX_CNT_TIME)
#define CO_RX_IDX_RPDO (CO_RX_IDX_SRDO + ((uint16_t)CO_RX_CNT_SRDO * 2U))
#define CO_RX_IDX_SDO_SRV (CO_RX_IDX_RPDO + (uint16_t)CO_RX_CNT_RPDO)
#define CO_RX_IDX_SDO_CLI (CO_RX_IDX_SDO_SRV + (uint16_t)CO_RX_CNT_SDO_SRV)
#define CO_RX_IDX_HB_CONS (CO_RX_IDX_SDO_CLI + (uint16_t)CO_RX_CNT_SDO_CLI)
#define CO_RX_IDX_NG_SLV (CO_RX_IDX_HB_CONS + (uint16_t)CO_RX_CNT_HB_CONS)
#define CO_RX_IDX_NG_MST (CO_RX_IDX_NG_SLV + (uint16_t)CO_RX_CNT_NG_SLV)
#define CO_RX_IDX_LSS_SLV (CO_RX_IDX_NG_MST + (uint16_t)CO_RX_CNT_NG_MST)
#define CO_RX_IDX_LSS_MST (CO_RX_IDX_LSS_SLV + (uint16_t)CO_RX_CNT_LSS_SLV)
#define CO_CNT_ALL_RX_MSGS (CO_RX_IDX_LSS_MST + (uint16_t)CO_RX_CNT_LSS_MST)
#define CO_TX_IDX_NMT_MST 0
#define CO_TX_IDX_GFC (CO_TX_IDX_NMT_MST + CO_TX_CNT_NMT_MST)
#define CO_TX_IDX_SYNC (CO_TX_IDX_GFC + CO_TX_CNT_GFC)
#define CO_TX_IDX_EM_PROD (CO_TX_IDX_SYNC + CO_TX_CNT_SYNC)
#define CO_TX_IDX_TIME (CO_TX_IDX_EM_PROD + CO_TX_CNT_EM_PROD)
#define CO_TX_IDX_SRDO (CO_TX_IDX_TIME + CO_TX_CNT_TIME)
#define CO_TX_IDX_TPDO (CO_TX_IDX_SRDO + CO_TX_CNT_SRDO * 2)
#define CO_TX_IDX_SDO_SRV (CO_TX_IDX_TPDO + CO_TX_CNT_TPDO)
#define CO_TX_IDX_SDO_CLI (CO_TX_IDX_SDO_SRV + CO_TX_CNT_SDO_SRV)
#define CO_TX_IDX_HB_PROD (CO_TX_IDX_SDO_CLI + CO_TX_CNT_SDO_CLI)
#define CO_TX_IDX_NG_SLV (CO_TX_IDX_HB_PROD + CO_TX_CNT_HB_PROD)
#define CO_TX_IDX_NG_MST (CO_TX_IDX_NG_SLV + CO_TX_CNT_NG_SLV)
#define CO_TX_IDX_LSS_SLV (CO_TX_IDX_NG_MST + CO_TX_CNT_NG_MST)
#define CO_TX_IDX_LSS_MST (CO_TX_IDX_LSS_SLV + CO_TX_CNT_LSS_SLV)
#define CO_CNT_ALL_TX_MSGS (CO_TX_IDX_LSS_MST + CO_TX_CNT_LSS_MST)
#define CO_TX_IDX_NMT_MST 0U
#define CO_TX_IDX_GFC (CO_TX_IDX_NMT_MST + (uint16_t)CO_TX_CNT_NMT_MST)
#define CO_TX_IDX_SYNC (CO_TX_IDX_GFC + (uint16_t)CO_TX_CNT_GFC)
#define CO_TX_IDX_EM_PROD (CO_TX_IDX_SYNC + (uint16_t)CO_TX_CNT_SYNC)
#define CO_TX_IDX_TIME (CO_TX_IDX_EM_PROD + (uint16_t)CO_TX_CNT_EM_PROD)
#define CO_TX_IDX_SRDO (CO_TX_IDX_TIME + (uint16_t)CO_TX_CNT_TIME)
#define CO_TX_IDX_TPDO (CO_TX_IDX_SRDO + ((uint16_t)CO_TX_CNT_SRDO * 2U))
#define CO_TX_IDX_SDO_SRV (CO_TX_IDX_TPDO + (uint16_t)CO_TX_CNT_TPDO)
#define CO_TX_IDX_SDO_CLI (CO_TX_IDX_SDO_SRV + (uint16_t)CO_TX_CNT_SDO_SRV)
#define CO_TX_IDX_HB_PROD (CO_TX_IDX_SDO_CLI + (uint16_t)CO_TX_CNT_SDO_CLI)
#define CO_TX_IDX_NG_SLV (CO_TX_IDX_HB_PROD + (uint16_t)CO_TX_CNT_HB_PROD)
#define CO_TX_IDX_NG_MST (CO_TX_IDX_NG_SLV + (uint16_t)CO_TX_CNT_NG_SLV)
#define CO_TX_IDX_LSS_SLV (CO_TX_IDX_NG_MST + (uint16_t)CO_TX_CNT_NG_MST)
#define CO_TX_IDX_LSS_MST (CO_TX_IDX_LSS_SLV + (uint16_t)CO_TX_CNT_LSS_SLV)
#define CO_CNT_ALL_TX_MSGS (CO_TX_IDX_LSS_MST + (uint16_t)CO_TX_CNT_LSS_MST)
#endif /* #ifdef #else CO_MULTIPLE_OD */
@ -1058,7 +1058,7 @@ CO_ReturnError_t CO_CANopenInit(CO_t *co,
#endif
co->CANmodule,
CO_GET_CO(TX_IDX_HB_PROD),
CO_CAN_ID_HEARTBEAT + nodeId,
(uint16_t)CO_CAN_ID_HEARTBEAT + nodeId,
errInfo);
if (err) { return err; }
}
@ -1082,7 +1082,7 @@ CO_ReturnError_t CO_CANopenInit(CO_t *co,
OD_GET(H100C, OD_H100C_GUARD_TIME),
OD_GET(H100D, OD_H100D_LIFETIME_FACTOR),
em,
CO_CAN_ID_HEARTBEAT + nodeId,
(uint16_t)CO_CAN_ID_HEARTBEAT + nodeId,
co->CANmodule,
CO_GET_CO(RX_IDX_NG_SLV),
co->CANmodule,
@ -1103,7 +1103,7 @@ CO_ReturnError_t CO_CANopenInit(CO_t *co,
/* SDOserver */
if (CO_GET_CNT(SDO_SRV) > 0U) {
OD_entry_t *SDOsrvPar = OD_GET(H1200, OD_H1200_SDO_SERVER_1_PARAM);
for (int16_t i = 0; i < CO_GET_CNT(SDO_SRV); i++) {
for (uint16_t i = 0; i < CO_GET_CNT(SDO_SRV); i++) {
err = CO_SDOserver_init(&co->SDOserver[i],
od,
SDOsrvPar++,
@ -1121,7 +1121,7 @@ CO_ReturnError_t CO_CANopenInit(CO_t *co,
#if (CO_CONFIG_SDO_CLI) & CO_CONFIG_SDO_CLI_ENABLE
if (CO_GET_CNT(SDO_CLI) > 0) {
OD_entry_t *SDOcliPar = OD_GET(H1280, OD_H1280_SDO_CLIENT_1_PARAM);
for (int16_t i = 0; i < CO_GET_CNT(SDO_CLI); i++) {
for (uint16_t i = 0; i < CO_GET_CNT(SDO_CLI); i++) {
err = CO_SDOclient_init(&co->SDOclient[i],
od,
SDOcliPar++,
@ -1253,12 +1253,12 @@ CO_ReturnError_t CO_CANopenInitPDO(CO_t *co,
if (CO_GET_CNT(RPDO) > 0U) {
OD_entry_t *RPDOcomm = OD_GET(H1400, OD_H1400_RXPDO_1_PARAM);
OD_entry_t *RPDOmap = OD_GET(H1600, OD_H1600_RXPDO_1_MAPPING);
for (int16_t i = 0; i < CO_GET_CNT(RPDO); i++) {
for (uint16_t i = 0; i < CO_GET_CNT(RPDO); i++) {
CO_ReturnError_t err;
uint16_t preDefinedCanId = 0;
if (i < CO_RPDO_DEFAULT_CANID_COUNT) {
#if CO_RPDO_DEFAULT_CANID_COUNT <= 4
preDefinedCanId = (CO_CAN_ID_RPDO_1 + i * 0x100) + nodeId;
preDefinedCanId = ((uint16_t)CO_CAN_ID_RPDO_1 + (i * 0x100U)) + nodeId;
#else
uint16_t pdoOffset = i % 4;
uint16_t nodeIdOffset = i / 4;
@ -1287,12 +1287,12 @@ CO_ReturnError_t CO_CANopenInitPDO(CO_t *co,
if (CO_GET_CNT(TPDO) > 0U) {
OD_entry_t *TPDOcomm = OD_GET(H1800, OD_H1800_TXPDO_1_PARAM);
OD_entry_t *TPDOmap = OD_GET(H1A00, OD_H1A00_TXPDO_1_MAPPING);
for (int16_t i = 0; i < CO_GET_CNT(TPDO); i++) {
for (uint16_t i = 0; i < CO_GET_CNT(TPDO); i++) {
CO_ReturnError_t err;
uint16_t preDefinedCanId = 0;
if (i < CO_TPDO_DEFAULT_CANID_COUNT) {
#if CO_TPDO_DEFAULT_CANID_COUNT <= 4
preDefinedCanId = (CO_CAN_ID_TPDO_1 + i * 0x100) + nodeId;
preDefinedCanId = ((uint16_t)CO_CAN_ID_TPDO_1 + (i * 0x100U)) + nodeId;
#else
uint16_t pdoOffset = i % 4;
uint16_t nodeIdOffset = i / 4;
@ -1364,9 +1364,9 @@ CO_ReturnError_t CO_CANopenInitSRDO(CO_t *co,
OD_entry_t *SRDOcomm = OD_GET(H1301, OD_H1301_SRDO_1_PARAM);
OD_entry_t *SRDOmap = OD_GET(H1381, OD_H1381_SRDO_1_MAPPING);
for (int16_t i = 0; i < CO_GET_CNT(SRDO); i++) {
uint16_t CANdevRxIdx = CO_GET_CO(RX_IDX_SRDO) + 2 * i;
uint16_t CANdevTxIdx = CO_GET_CO(TX_IDX_SRDO) + 2 * i;
for (uint16_t i = 0; i < CO_GET_CNT(SRDO); i++) {
uint16_t CANdevRxIdx = CO_GET_CO(RX_IDX_SRDO) + (2U * i);
uint16_t CANdevTxIdx = CO_GET_CO(TX_IDX_SRDO) + (2U * i);
err = CO_SRDO_init(&co->SRDO[i],
i,
@ -1374,7 +1374,7 @@ CO_ReturnError_t CO_CANopenInitSRDO(CO_t *co,
od,
em,
nodeId,
((i == 0) ? CO_CAN_ID_SRDO_1 : 0),
((i == 0U) ? (uint16_t)CO_CAN_ID_SRDO_1 : 0U),
SRDOcomm++,
SRDOmap++,
OD_GET(H13FE, OD_H13FE_SRDO_VALID),
@ -1408,8 +1408,8 @@ CO_NMT_reset_cmd_t CO_process(CO_t *co,
(void) enableGateway; /* may be unused */
CO_NMT_reset_cmd_t reset = CO_RESET_NOT;
CO_NMT_internalState_t NMTstate = CO_NMT_getInternalState(co->NMT);
bool_t NMTisPreOrOperational = (NMTstate == CO_NMT_PRE_OPERATIONAL
|| NMTstate == CO_NMT_OPERATIONAL);
bool_t NMTisPreOrOperational = ((NMTstate == CO_NMT_PRE_OPERATIONAL)
|| (NMTstate == CO_NMT_OPERATIONAL));
/* CAN module */
CO_CANmodule_process(co->CANmodule);
@ -1427,8 +1427,8 @@ CO_NMT_reset_cmd_t CO_process(CO_t *co,
uint16_t CANerrorStatus = co->CANmodule->CANerrorStatus;
bool_t LSSslave_configuration = false;
#if (CO_CONFIG_LSS) & CO_CONFIG_LSS_SLAVE
if (CO_GET_CNT(LSS_SLV) == 1
&& CO_LSSslave_getState(co->LSSslave) == CO_LSS_STATE_CONFIGURATION
if ((CO_GET_CNT(LSS_SLV) == 1U)
&& (CO_LSSslave_getState(co->LSSslave) == CO_LSS_STATE_CONFIGURATION)
) {
LSSslave_configuration = true;
}
@ -1443,8 +1443,8 @@ CO_NMT_reset_cmd_t CO_process(CO_t *co,
timeDifference_us,
unc ? CO_NMT_INITIALIZING : NMTstate,
LSSslave_configuration,
(CANerrorStatus & CO_CAN_ERRTX_BUS_OFF) != 0,
(CANerrorStatus & CO_CAN_ERR_WARN_PASSIVE) != 0,
(CANerrorStatus & (uint16_t)CO_CAN_ERRTX_BUS_OFF) != 0U,
(CANerrorStatus & (uint16_t)CO_CAN_ERR_WARN_PASSIVE) != 0U,
0, /* RPDO event timer timeout */
unc ? false : CO_isError(co->em, CO_EM_SYNC_TIME_OUT),
unc ? false : (CO_isError(co->em, CO_EM_HEARTBEAT_CONSUMER)
@ -1475,8 +1475,8 @@ CO_NMT_reset_cmd_t CO_process(CO_t *co,
timeDifference_us,
timerNext_us);
}
NMTisPreOrOperational = (NMTstate == CO_NMT_PRE_OPERATIONAL
|| NMTstate == CO_NMT_OPERATIONAL);
NMTisPreOrOperational = ((NMTstate == CO_NMT_PRE_OPERATIONAL)
|| (NMTstate == CO_NMT_OPERATIONAL));
/* SDOserver */
for (uint8_t i = 0; i < CO_GET_CNT(SDO_SRV); i++) {
@ -1580,7 +1580,7 @@ void CO_process_RPDO(CO_t *co,
bool_t NMTisOperational =
CO_NMT_getInternalState(co->NMT) == CO_NMT_OPERATIONAL;
for (int16_t i = 0; i < CO_GET_CNT(RPDO); i++) {
for (uint16_t i = 0; i < CO_GET_CNT(RPDO); i++) {
CO_RPDO_process(&co->RPDO[i],
#if (CO_CONFIG_PDO) & CO_CONFIG_RPDO_TIMERS_ENABLE
timeDifference_us,
@ -1608,7 +1608,7 @@ void CO_process_TPDO(CO_t *co,
bool_t NMTisOperational =
CO_NMT_getInternalState(co->NMT) == CO_NMT_OPERATIONAL;
for (int16_t i = 0; i < CO_GET_CNT(TPDO); i++) {
for (uint16_t i = 0; i < CO_GET_CNT(TPDO); i++) {
CO_TPDO_process(&co->TPDO[i],
#if (CO_CONFIG_PDO) & CO_CONFIG_TPDO_TIMERS_ENABLE
timeDifference_us,
@ -1637,7 +1637,7 @@ CO_SRDO_state_t CO_process_SRDO(CO_t *co,
CO_SRDO_state_t lowestState = CO_SRDO_state_deleted;
for (int16_t i = 0; i < CO_GET_CNT(SRDO); i++) {
for (Uint16_t i = 0; i < CO_GET_CNT(SRDO); i++) {
CO_SRDO_state_t state = CO_SRDO_process(&co->SRDO[i],
timeDifference_us,
timerNext_us,