nikon/CANopenNode
1
0
Fork 0
Code Activity Actions

Misra (#501)

Browse source 
Make MISRA compliant for:
MISRA C 2004 rule 14.10
MISRA C 2004 rule 14.9
MISRA C 2004 rule 13.1
MISRA C 2004 rule 15.3

MISRA style guild update
This commit is contained in:
Brian Linari 2024-03-13 09:20:42 -07:00 committed by GitHub
parent 1204042a1f
commit a52db428f6
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
19 changed files with 249 additions and 133 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

67
301/CO_Emergency.c
View file

@ -209,6 +209,7 @@ static ODR_t OD_read_1003(OD_stream_t *stream, void *buf,
else if (index >= (em->fifoSize)) {
return ODR_DEV_INCOMPAT;
}
else { /* MISRA C 2004 14.10 */ }
CO_setUint32(buf, em->fifo[index].msg);
*countRead = sizeof(uint32_t);
@ -400,7 +401,7 @@ CO_ReturnError_t CO_EM_init(CO_EM_t *em,
/* get and verify "Error register" from Object Dictionary */
em->errorRegister = OD_getPtr(OD_1001_errReg, 0, sizeof(uint8_t), NULL);
if (em->errorRegister == NULL) {
if (errInfo != NULL) *errInfo = OD_getIndex(OD_1001_errReg);
if (errInfo != NULL) { *errInfo = OD_getIndex(OD_1001_errReg); }
return CO_ERROR_OD_PARAMETERS;
}
*em->errorRegister = 0;
@ -414,10 +415,9 @@ CO_ReturnError_t CO_EM_init(CO_EM_t *em,
uint32_t COB_IDEmergency32;
odRet = OD_get_u32(OD_1014_cobIdEm, 0, &COB_IDEmergency32, true);
if (odRet != ODR_OK || (COB_IDEmergency32 & 0x7FFFF800) != 0) {
if (errInfo != NULL) *errInfo = OD_getIndex(OD_1014_cobIdEm);
if (errInfo != NULL) { *errInfo = OD_getIndex(OD_1014_cobIdEm); }
/* don't break a program, if only value of a parameter is wrong */
if (odRet != ODR_OK)
return CO_ERROR_OD_PARAMETERS;
if (odRet != ODR_OK) { return CO_ERROR_OD_PARAMETERS; }
}
#if (CO_CONFIG_EM) & CO_CONFIG_EM_PROD_CONFIGURABLE
@ -449,7 +449,7 @@ CO_ReturnError_t CO_EM_init(CO_EM_t *em,
em->OD_1014_extension.write = OD_writeOriginal;
odRet = OD_extension_init(OD_1014_cobIdEm, &em->OD_1014_extension);
if (odRet != ODR_OK) {
if (errInfo != NULL) *errInfo = OD_getIndex(OD_1014_cobIdEm);
if (errInfo != NULL) { *errInfo = OD_getIndex(OD_1014_cobIdEm); }
return CO_ERROR_OD_PARAMETERS;
}
#endif
@ -564,60 +564,68 @@ 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 & (CO_CAN_ERRTX_WARNING | CO_CAN_ERRRX_WARNING)) {
CO_error(em,
(CANerrSt & (CO_CAN_ERRTX_WARNING | CO_CAN_ERRRX_WARNING)) != 0,
CO_EM_CAN_BUS_WARNING, CO_EMC_NO_ERROR, 0);
if (CANerrStChanged & CO_CAN_ERRTX_PASSIVE)
}
if (CANerrStChanged & CO_CAN_ERRTX_PASSIVE) {
CO_error(em, (CANerrSt & CO_CAN_ERRTX_PASSIVE) != 0,
CO_EM_CAN_TX_BUS_PASSIVE, CO_EMC_CAN_PASSIVE, 0);
if (CANerrStChanged & CO_CAN_ERRTX_BUS_OFF)
}
if (CANerrStChanged & CO_CAN_ERRTX_BUS_OFF) {
CO_error(em, (CANerrSt & CO_CAN_ERRTX_BUS_OFF) != 0,
CO_EM_CAN_TX_BUS_OFF, CO_EMC_BUS_OFF_RECOVERED, 0);
if (CANerrStChanged & CO_CAN_ERRTX_OVERFLOW)
}
if (CANerrStChanged & CO_CAN_ERRTX_OVERFLOW) {
CO_error(em, (CANerrSt & CO_CAN_ERRTX_OVERFLOW) != 0,
CO_EM_CAN_TX_OVERFLOW, CO_EMC_CAN_OVERRUN, 0);
if (CANerrStChanged & CO_CAN_ERRTX_PDO_LATE)
}
if (CANerrStChanged & CO_CAN_ERRTX_PDO_LATE) {
CO_error(em, (CANerrSt & CO_CAN_ERRTX_PDO_LATE) != 0,
CO_EM_TPDO_OUTSIDE_WINDOW, CO_EMC_COMMUNICATION, 0);
if (CANerrStChanged & CO_CAN_ERRRX_PASSIVE)
}
if (CANerrStChanged & CO_CAN_ERRRX_PASSIVE) {
CO_error(em, (CANerrSt & CO_CAN_ERRRX_PASSIVE) != 0,
CO_EM_CAN_RX_BUS_PASSIVE, CO_EMC_CAN_PASSIVE, 0);
if (CANerrStChanged & CO_CAN_ERRRX_OVERFLOW)
}
if (CANerrStChanged & CO_CAN_ERRRX_OVERFLOW) {
CO_error(em, (CANerrSt & CO_CAN_ERRRX_OVERFLOW) != 0,
CO_EM_CAN_RXB_OVERFLOW, CO_EM_CAN_RXB_OVERFLOW, 0);
}
}
/* calculate Error register */
uint8_t errorRegister = 0U;
if (CO_CONFIG_ERR_CONDITION_GENERIC)
if (CO_CONFIG_ERR_CONDITION_GENERIC) {
errorRegister |= CO_ERR_REG_GENERIC_ERR;
}
#ifdef CO_CONFIG_ERR_CONDITION_CURRENT
if (CO_CONFIG_ERR_CONDITION_CURRENT)
if (CO_CONFIG_ERR_CONDITION_CURRENT) {
errorRegister |= CO_ERR_REG_CURRENT;
}
#endif
#ifdef CO_CONFIG_ERR_CONDITION_VOLTAGE
if (CO_CONFIG_ERR_CONDITION_VOLTAGE)
if (CO_CONFIG_ERR_CONDITION_VOLTAGE) {
errorRegister |= CO_ERR_REG_VOLTAGE;
}
#endif
#ifdef CO_CONFIG_ERR_CONDITION_TEMPERATURE
if (CO_CONFIG_ERR_CONDITION_TEMPERATURE)
if (CO_CONFIG_ERR_CONDITION_TEMPERATURE) {
errorRegister |= CO_ERR_REG_TEMPERATURE;
}
#endif
if (CO_CONFIG_ERR_CONDITION_COMMUNICATION)
if (CO_CONFIG_ERR_CONDITION_COMMUNICATION) {
errorRegister |= CO_ERR_REG_COMMUNICATION;
}
#ifdef CO_CONFIG_ERR_CONDITION_DEV_PROFILE
if (CO_CONFIG_ERR_CONDITION_DEV_PROFILE)
if (CO_CONFIG_ERR_CONDITION_DEV_PROFILE) {
errorRegister |= CO_ERR_REG_DEV_PROFILE;
}
#endif
if (CO_CONFIG_ERR_CONDITION_MANUFACTURER)
if (CO_CONFIG_ERR_CONDITION_MANUFACTURER) {
errorRegister |= CO_ERR_REG_MANUFACTURER;
}
*em->errorRegister = errorRegister;
if (!NMTisPreOrOperational) {
@ -675,6 +683,7 @@ void CO_EM_process(CO_EM_t *em,
em->fifoOverflow = 0;
CO_errorReset(em, CO_EM_EMERGENCY_BUFFER_FULL, 0);
}
else { /* MISRA C 2004 14.10 */ }
}
#if (CO_CONFIG_EM) & CO_CONFIG_EM_PROD_INHIBIT
#if (CO_CONFIG_EM) & CO_CONFIG_FLAG_TIMERNEXT
@ -713,7 +722,7 @@ void CO_EM_process(CO_EM_t *em,
void CO_error(CO_EM_t *em, bool_t setError, const uint8_t errorBit,
uint16_t errorCode, uint32_t infoCode)
{
if (em == NULL) return;
if (em == NULL) { return; }
uint8_t index = errorBit >> 3;
uint8_t bitmask = 1 << (errorBit & 0x7);
@ -753,8 +762,8 @@ void CO_error(CO_EM_t *em, bool_t setError, const uint8_t errorBit,
/* safely write data, and increment pointers */
CO_LOCK_EMCY(em->CANdevTx);
if (setError) *errorStatusBits |= bitmask;
else *errorStatusBits &= ~bitmask;
if (setError) { *errorStatusBits |= bitmask; }
else { *errorStatusBits &= ~bitmask; }
#if (CO_CONFIG_EM) & (CO_CONFIG_EM_PRODUCER | CO_CONFIG_EM_HISTORY)
if (em->fifoSize >= 2) {
@ -773,7 +782,7 @@ void CO_error(CO_EM_t *em, bool_t setError, const uint8_t errorBit,
em->fifo[fifoWrPtr].info = infoCodeSwapped;
#endif
em->fifoWrPtr = fifoWrPtrNext;
if (em->fifoCount < (em->fifoSize - 1)) em->fifoCount++;
if (em->fifoCount < (em->fifoSize - 1)) { em->fifoCount++; }
}
}
#endif /* (CO_CONFIG_EM) & (CO_CONFIG_EM_PRODUCER | CO_CONFIG_EM_HISTORY) */

10
301/CO_HBconsumer.c
View file

@ -146,7 +146,7 @@ CO_ReturnError_t CO_HBconsumer_init(CO_HBconsumer_t *HBcons,
uint32_t val;
odRet = OD_get_u32(OD_1016_HBcons, i + 1, &val, true);
if (odRet != ODR_OK) {
if (errInfo != NULL) *errInfo = OD_getIndex(OD_1016_HBcons);
if (errInfo != NULL) { *errInfo = OD_getIndex(OD_1016_HBcons); }
return CO_ERROR_OD_PARAMETERS;
}
@ -154,10 +154,9 @@ CO_ReturnError_t CO_HBconsumer_init(CO_HBconsumer_t *HBcons,
uint16_t time = val & 0xFFFF;
CO_ReturnError_t ret = CO_HBconsumer_initEntry(HBcons, i, nodeId, time);
if (ret != CO_ERROR_NO) {
if (errInfo != NULL) *errInfo = OD_getIndex(OD_1016_HBcons);
if (errInfo != NULL) { *errInfo = OD_getIndex(OD_1016_HBcons); }
/* don't break a program, if only value of a parameter is wrong */
if (ret != CO_ERROR_OD_PARAMETERS)
return ret;
if (ret != CO_ERROR_OD_PARAMETERS) { return ret; }
}
}
@ -168,7 +167,7 @@ CO_ReturnError_t CO_HBconsumer_init(CO_HBconsumer_t *HBcons,
HBcons->OD_1016_extension.write = OD_write_1016;
odRet = OD_extension_init(OD_1016_HBcons, &HBcons->OD_1016_extension);
if (odRet != ODR_OK) {
if (errInfo != NULL) *errInfo = OD_getIndex(OD_1016_HBcons);
if (errInfo != NULL) { *errInfo = OD_getIndex(OD_1016_HBcons); }
return CO_ERROR_OD_PARAMETERS;
}
#endif
@ -488,6 +487,7 @@ void CO_HBconsumer_process(
allMonitoredActiveCurrent = false;
allMonitoredOperationalCurrent = false;
}
else { /* MISRA C 2004 14.10 */ }
/* Clear emergencies when all monitored nodes becomes active.
* We only have one emergency index for all monitored nodes! */

7
301/CO_NMT_Heartbeat.c
View file

@ -126,7 +126,7 @@ CO_ReturnError_t CO_NMT_init(CO_NMT_t *NMT,
uint16_t HBprodTime_ms;
ODR_t odRet = OD_get_u16(OD_1017_ProducerHbTime, 0, &HBprodTime_ms, true);
if (odRet != ODR_OK) {
if (errInfo != NULL) *errInfo = OD_getIndex(OD_1017_ProducerHbTime);
if (errInfo != NULL) { *errInfo = OD_getIndex(OD_1017_ProducerHbTime); }
return CO_ERROR_OD_PARAMETERS;
}
NMT->HBproducerTime_us = (uint32_t)HBprodTime_ms * 1000;
@ -136,7 +136,7 @@ CO_ReturnError_t CO_NMT_init(CO_NMT_t *NMT,
NMT->OD_1017_extension.write = OD_write_1017;
odRet = OD_extension_init(OD_1017_ProducerHbTime, &NMT->OD_1017_extension);
if (odRet != ODR_OK) {
if (errInfo != NULL) *errInfo = OD_getIndex(OD_1017_ProducerHbTime);
if (errInfo != NULL) { *errInfo = OD_getIndex(OD_1017_ProducerHbTime); }
return CO_ERROR_OD_PARAMETERS;
}
@ -298,6 +298,7 @@ CO_NMT_reset_cmd_t CO_NMT_process(CO_NMT_t *NMT,
) {
NMTstateCpy = CO_NMT_OPERATIONAL;
}
else { /* MISRA C 2004 14.10 */ }
#if (CO_CONFIG_NMT) & CO_CONFIG_NMT_CALLBACK_CHANGE
/* Notify operating state change */
@ -321,7 +322,7 @@ CO_NMT_reset_cmd_t CO_NMT_process(CO_NMT_t *NMT,
#endif
NMT->operatingState = NMTstateCpy;
if (NMTstate != NULL) *NMTstate = NMTstateCpy;
if (NMTstate != NULL) { *NMTstate = NMTstateCpy; }
return resetCommand;
}

2
301/CO_NMT_Heartbeat.h
View file

@ -331,7 +331,7 @@ static inline CO_NMT_internalState_t CO_NMT_getInternalState(CO_NMT_t *NMT) {
static inline void CO_NMT_sendInternalCommand(CO_NMT_t *NMT,
CO_NMT_command_t command)
{
if (NMT != NULL) NMT->internalCommand = command;
if (NMT != NULL) { NMT->internalCommand = command; }
}

23
301/CO_ODinterface.c
View file

@ -182,15 +182,15 @@ OD_entry_t *OD_find(OD_t *od, uint16_t index) {
ODR_t OD_getSub(const OD_entry_t *entry, uint8_t subIndex,
OD_IO_t *io, bool_t odOrig)
{
if (entry == NULL || entry->odObject == NULL) return ODR_IDX_NOT_EXIST;
if (io == NULL) return ODR_DEV_INCOMPAT;
if (entry == NULL || entry->odObject == NULL) { return ODR_IDX_NOT_EXIST; }
if (io == NULL) { return ODR_DEV_INCOMPAT; }
OD_stream_t *stream = &io->stream;
/* attribute, dataOrig and dataLength, depends on object type */
switch (entry->odObjectType & ODT_TYPE_MASK) {
case ODT_VAR: {
if (subIndex > 0) return ODR_SUB_NOT_EXIST;
if (subIndex > 0) { return ODR_SUB_NOT_EXIST; }
CO_PROGMEM OD_obj_var_t *odo = entry->odObject;
@ -200,7 +200,7 @@ ODR_t OD_getSub(const OD_entry_t *entry, uint8_t subIndex,
break;
}
case ODT_ARR: {
if (subIndex >= entry->subEntriesCount) return ODR_SUB_NOT_EXIST;
if (subIndex >= entry->subEntriesCount) { return ODR_SUB_NOT_EXIST; }
CO_PROGMEM OD_obj_array_t *odo = entry->odObject;
if (subIndex == 0) {
@ -226,7 +226,7 @@ ODR_t OD_getSub(const OD_entry_t *entry, uint8_t subIndex,
break;
}
}
if (odo == NULL) return ODR_SUB_NOT_EXIST;
if (odo == NULL) { return ODR_SUB_NOT_EXIST; }
stream->attribute = odo->attribute;
stream->dataOrig = odo->dataOrig;
@ -303,7 +303,7 @@ uint32_t OD_getSDOabCode(ODR_t returnCode) {
ODR_t OD_get_value(const OD_entry_t *entry, uint8_t subIndex,
void *val, OD_size_t len, bool_t odOrig)
{
if (val == NULL) return ODR_DEV_INCOMPAT;
if (val == NULL) { return ODR_DEV_INCOMPAT; }
OD_IO_t io;
OD_stream_t *stream = (OD_stream_t *)&io;
@ -311,8 +311,8 @@ ODR_t OD_get_value(const OD_entry_t *entry, uint8_t subIndex,
ODR_t ret = OD_getSub(entry, subIndex, &io, odOrig);
if (ret != ODR_OK) return ret;
if (stream->dataLength != len) return ODR_TYPE_MISMATCH;
if (ret != ODR_OK) { return ret; }
if (stream->dataLength != len) { return ODR_TYPE_MISMATCH; }
return io.read(stream, val, len, &countRd);
}
@ -326,8 +326,8 @@ ODR_t OD_set_value(const OD_entry_t *entry, uint8_t subIndex, void *val,
ODR_t ret = OD_getSub(entry, subIndex, &io, odOrig);
if (ret != ODR_OK) return ret;
if (stream->dataLength != len) return ODR_TYPE_MISMATCH;
if (ret != ODR_OK) { return ret; }
if (stream->dataLength != len) { return ODR_TYPE_MISMATCH; }
return io.write(stream, val, len, &countWritten);
}
@ -348,9 +348,10 @@ void *OD_getPtr(const OD_entry_t *entry, uint8_t subIndex, OD_size_t len,
else if (len != 0 && len != stream->dataLength) {
errCopy = ODR_TYPE_MISMATCH;
}
else { /* MISRA C 2004 14.10 */ }
}
if (err != NULL) *err = errCopy;
if (err != NULL) { *err = errCopy; }
return errCopy == ODR_OK ? stream->dataOrig : NULL;
}

4
301/CO_ODinterface.h
View file

@ -467,7 +467,7 @@ static inline bool_t OD_mappable(OD_stream_t *stream) {
* @param stream Object Dictionary stream object.
*/
static inline void OD_rwRestart(OD_stream_t *stream) {
if (stream != NULL) stream->dataOffset = 0;
if (stream != NULL) { stream->dataOffset = 0; }
}
@ -588,7 +588,7 @@ uint32_t OD_getSDOabCode(ODR_t returnCode);
static inline ODR_t OD_extension_init(OD_entry_t *entry,
OD_extension_t *extension)
{
if (entry == NULL) return ODR_IDX_NOT_EXIST;
if (entry == NULL) { return ODR_IDX_NOT_EXIST; }
entry->extension = extension;
return ODR_OK;
}

40
301/CO_PDO.c
View file

@ -45,7 +45,7 @@ static ODR_t OD_write_dummy(OD_stream_t *stream, const void *buf,
OD_size_t count, OD_size_t *countWritten)
{
(void) stream; (void) buf;
if (countWritten != NULL) *countWritten = count;
if (countWritten != NULL) { *countWritten = count; }
return ODR_OK;
}
@ -201,7 +201,7 @@ static CO_ReturnError_t PDO_initMapping(CO_PDO_common_t *PDO,
/* indicate erroneous mapping in initialization phase */
OD_IO->stream.dataLength = 0;
OD_IO->stream.dataOffset = 0xFF;
if (*erroneousMap == 0) *erroneousMap = map;
if (*erroneousMap == 0) { *erroneousMap = map; }
}
if (i < mappedObjectsCount) {
@ -211,7 +211,7 @@ static CO_ReturnError_t PDO_initMapping(CO_PDO_common_t *PDO,
if (pdoDataLength > CO_PDO_MAX_SIZE
|| (pdoDataLength == 0 && mappedObjectsCount > 0)
) {
if (*erroneousMap == 0) *erroneousMap = 1;
if (*erroneousMap == 0) { *erroneousMap = 1; }
}
if (*erroneousMap == 0) {
@ -428,7 +428,7 @@ static ODR_t OD_read_PDO_commParam(OD_stream_t *stream, void *buf,
}
/* If PDO is not valid, set bit 31 */
if (!PDO->valid) COB_ID |= 0x80000000;
if (!PDO->valid) { COB_ID |= 0x80000000; }
CO_setUint32(buf, COB_ID);
}
@ -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 == 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 == CO_RPDO_RX_ACK_NO_ERROR) { err = CO_RPDO_RX_LONG; }
}
/* Determine, to which of the two rx buffers copy the message. */
@ -505,6 +505,7 @@ static void CO_PDO_receive(void *object, void *msg) {
else if (err == CO_RPDO_RX_ACK_NO_ERROR) {
err = CO_RPDO_RX_SHORT;
}
else { /* MISRA C 2004 14.10 */ }
}
RPDO->receiveError = err;
@ -616,6 +617,9 @@ static ODR_t OD_write_14xx(OD_stream_t *stream, const void *buf,
break;
}
#endif
default:
/* MISRA C 2004 15.3 */
break;
}
/* write value to the original location in the Object Dictionary */
@ -683,7 +687,7 @@ CO_ReturnError_t CO_RPDO_init(CO_RPDO_t *RPDO,
uint16_t CAN_ID = (uint16_t)(COB_ID & 0x7FF);
if (valid && (PDO->mappedObjectsCount == 0 || CAN_ID == 0)) {
valid = false;
if (erroneousMap == 0) erroneousMap = 1;
if (erroneousMap == 0) { erroneousMap = 1; }
}
if (erroneousMap != 0) {
@ -804,8 +808,10 @@ void CO_RPDO_process(CO_RPDO_t *RPDO,
/* Determine, which of the two rx buffers contains relevant message. */
uint8_t bufNo = 0;
#if (CO_CONFIG_PDO) & CO_CONFIG_PDO_SYNC_ENABLE
if (RPDO->synchronous && RPDO->SYNC != NULL && !RPDO->SYNC->CANrxToggle)
if (RPDO->synchronous && RPDO->SYNC != NULL
&& !RPDO->SYNC->CANrxToggle) {
bufNo = 1;
}
#endif
/* copy RPDO into OD variables according to mappings */
@ -828,9 +834,9 @@ void CO_RPDO_process(CO_RPDO_t *RPDO,
/* length of OD variable may be larger than mappedLength */
OD_size_t ODdataLength = OD_IO->stream.dataLength;
if (ODdataLength > CO_PDO_MAX_SIZE)
if (ODdataLength > CO_PDO_MAX_SIZE) {
ODdataLength = CO_PDO_MAX_SIZE;
}
/* Prepare data for writing into OD variable. If mappedLength
* is smaller than ODdataLength, then use auxiliary buffer */
uint8_t buf[CO_PDO_MAX_SIZE];
@ -898,6 +904,7 @@ void CO_RPDO_process(CO_RPDO_t *RPDO,
CO_EMC_RPDO_TIMEOUT, RPDO->timeoutTimer);
}
}
else { /* MISRA C 2004 14.10 */ }
#if (CO_CONFIG_PDO) & CO_CONFIG_FLAG_TIMERNEXT
if (timerNext_us != NULL
&& RPDO->timeoutTimer < RPDO->timeoutTime_us
@ -1056,6 +1063,9 @@ static ODR_t OD_write_18xx(OD_stream_t *stream, const void *buf,
break;
}
#endif
default:
/* MISRA C 2004 15.3 */
break;
}
/* write value to the original location in the Object Dictionary */
@ -1141,7 +1151,7 @@ CO_ReturnError_t CO_TPDO_init(CO_TPDO_t *TPDO,
uint16_t CAN_ID = (uint16_t)(COB_ID & 0x7FF);
if (valid && (PDO->mappedObjectsCount == 0 || CAN_ID == 0)) {
valid = false;
if (erroneousMap == 0) erroneousMap = 1;
if (erroneousMap == 0) { erroneousMap = 1; }
}
if (erroneousMap != 0) {
@ -1243,9 +1253,9 @@ static CO_ReturnError_t CO_TPDOsend(CO_TPDO_t *TPDO) {
/* length of OD variable may be larger than mappedLength */
OD_size_t ODdataLength = stream->dataLength;
if (ODdataLength > CO_PDO_MAX_SIZE)
if (ODdataLength > CO_PDO_MAX_SIZE) {
ODdataLength = CO_PDO_MAX_SIZE;
}
/* If mappedLength is smaller than ODdataLength, use auxiliary buffer */
uint8_t buf[CO_PDO_MAX_SIZE];
uint8_t *dataTPDOCopy;
@ -1402,7 +1412,7 @@ void CO_TPDO_process(CO_TPDO_t *TPDO,
else if (TPDO->SYNC != NULL && syncWas) {
/* send synchronous acyclic TPDO */
if (TPDO->transmissionType == CO_PDO_TRANSM_TYPE_SYNC_ACYCLIC) {
if (TPDO->sendRequest) CO_TPDOsend(TPDO);
if (TPDO->sendRequest) { CO_TPDOsend(TPDO); }
}
/* send synchronous cyclic TPDO */
else {
@ -1432,8 +1442,10 @@ void CO_TPDO_process(CO_TPDO_t *TPDO,
TPDO->syncCounter = TPDO->transmissionType;
CO_TPDOsend(TPDO);
}
else { /* MISRA C 2004 14.10 */ }
}
} /* else if (TPDO->SYNC && syncWas) */
else { /* MISRA C 2004 14.10 */ }
#endif
}

2
301/CO_PDO.h
View file

@ -451,7 +451,7 @@ CO_ReturnError_t CO_TPDO_init(CO_TPDO_t *TPDO,
* @param TPDO TPDO object.
*/
static inline void CO_TPDOsendRequest(CO_TPDO_t *TPDO) {
if (TPDO != NULL) TPDO->sendRequest = true;
if (TPDO != NULL) { TPDO->sendRequest = true; }
}

40
301/CO_SDOserver.c
View file

@ -245,6 +245,7 @@ static ODR_t OD_write_1201_additional(OD_stream_t *stream, const void *buf,
switch (stream->subIndex) {
case 0: /* Highest sub-index supported */
return ODR_READONLY;
break;
case 1: { /* COB-ID client -> server */
uint32_t COB_ID = CO_getUint32(buf);
@ -349,7 +350,7 @@ CO_ReturnError_t CO_SDOserver_init(CO_SDOserver_t *SDO,
if (OD_1200_SDOsrvPar == NULL) {
/* configure default SDO channel */
if (nodeId < 1 || nodeId > 127) return CO_ERROR_ILLEGAL_ARGUMENT;
if (nodeId < 1 || nodeId > 127) { return CO_ERROR_ILLEGAL_ARGUMENT; }
CanId_ClientToServer = CO_CAN_ID_SDO_CLI + nodeId;
CanId_ServerToClient = CO_CAN_ID_SDO_SRV + nodeId;
@ -360,7 +361,9 @@ CO_ReturnError_t CO_SDOserver_init(CO_SDOserver_t *SDO,
if (OD_SDOsrvParIdx == OD_H1200_SDO_SERVER_1_PARAM) {
/* configure default SDO channel and SDO server parameters for it */
if (nodeId < 1 || nodeId > 127) return CO_ERROR_ILLEGAL_ARGUMENT;
if (nodeId < 1 || nodeId > 127) {
return CO_ERROR_ILLEGAL_ARGUMENT;
}
CanId_ClientToServer = CO_CAN_ID_SDO_CLI + nodeId;
CanId_ServerToClient = CO_CAN_ID_SDO_SRV + nodeId;
@ -386,7 +389,7 @@ CO_ReturnError_t CO_SDOserver_init(CO_SDOserver_t *SDO,
if (odRet0 != ODR_OK || (maxSubIndex != 2 && maxSubIndex != 3)
|| odRet1 != ODR_OK || odRet2 != ODR_OK
) {
if (errInfo != NULL) *errInfo = OD_SDOsrvParIdx;
if (errInfo != NULL) { *errInfo = OD_SDOsrvParIdx; }
return CO_ERROR_OD_PARAMETERS;
}
@ -403,7 +406,7 @@ CO_ReturnError_t CO_SDOserver_init(CO_SDOserver_t *SDO,
ODR_t odRetE = OD_extension_init(OD_1200_SDOsrvPar,
&SDO->OD_1200_extension);
if (odRetE != ODR_OK) {
if (errInfo != NULL) *errInfo = OD_SDOsrvParIdx;
if (errInfo != NULL) { *errInfo = OD_SDOsrvParIdx; }
return CO_ERROR_OD_PARAMETERS;
}
#endif
@ -525,6 +528,7 @@ static bool_t validateAndWriteToOD(CO_SDOserver_t *SDO,
SDO->state = CO_SDO_ST_ABORT;
return false;
}
else { /* MISRA C 2004 14.10 */ }
}
else {
/* Verify if size of data downloaded is not too large. */
@ -577,6 +581,7 @@ static bool_t validateAndWriteToOD(CO_SDOserver_t *SDO,
SDO->state = CO_SDO_ST_ABORT;
return false;
}
else { /* MISRA C 2004 14.10 */ }
return true;
}
@ -628,7 +633,7 @@ static bool_t readFromOd(CO_SDOserver_t *SDO,
if (countRd > 0 && (SDO->OD_IO.stream.attribute & ODA_STR) != 0) {
bufShifted[countRd] = 0; /* (SDO->buf is one byte larger) */
OD_size_t countStr = (OD_size_t)strlen((char *)bufShifted);
if (countStr == 0) countStr = 1; /* zero length is not allowed */
if (countStr == 0) { countStr = 1; }/* zero length is not allowed */
if (countStr < countRd) {
/* string terminator found, read is finished, shorten data */
countRd = countStr;
@ -763,6 +768,7 @@ CO_SDO_return_t CO_SDOserver_process(CO_SDOserver_t *SDO,
abortCode = CO_SDO_AB_READONLY;
SDO->state = CO_SDO_ST_ABORT;
}
else { /* MISRA C 2004 14.10 */ }
}
}
@ -787,6 +793,7 @@ CO_SDO_return_t CO_SDOserver_process(CO_SDOserver_t *SDO,
abortCode = CO_SDO_AB_DEVICE_INCOMPAT;
SDO->state = CO_SDO_ST_ABORT;
}
else { /* MISRA C 2004 14.10 */ }
}
else {
/* If data type is string, size is not known */
@ -799,7 +806,7 @@ CO_SDO_return_t CO_SDOserver_process(CO_SDOserver_t *SDO,
#endif /* (CO_CONFIG_SDO_SRV) & CO_CONFIG_SDO_SRV_SEGMENTED */
} /* (SDO->state == CO_SDO_ST_IDLE) */
if (SDO->state != CO_SDO_ST_IDLE && SDO->state != CO_SDO_ST_ABORT)
if (SDO->state != CO_SDO_ST_IDLE && SDO->state != CO_SDO_ST_ABORT) {
switch (SDO->state) {
case CO_SDO_ST_DOWNLOAD_INITIATE_REQ: {
if (SDO->CANrxData[0] & 0x02) {
@ -810,10 +817,13 @@ CO_SDO_return_t CO_SDOserver_process(CO_SDOserver_t *SDO,
/* Get SDO data size (indicated by SDO client or get from OD) */
OD_size_t dataSizeToWrite = 4;
if (SDO->CANrxData[0] & 0x01)
if (SDO->CANrxData[0] & 0x01) {
dataSizeToWrite -= (SDO->CANrxData[0] >> 2) & 0x03;
else if (sizeInOd > 0 && sizeInOd < 4)
}
else if (sizeInOd > 0 && sizeInOd < 4) {
dataSizeToWrite = sizeInOd;
}
else { /* MISRA C 2004 14.10 */ }
/* copy data to the temp buffer, swap data if necessary */
uint8_t buf[6] = {0};
@ -845,6 +855,7 @@ CO_SDO_return_t CO_SDOserver_process(CO_SDOserver_t *SDO,
SDO->state = CO_SDO_ST_ABORT;
break;
}
else { /* MISRA C 2004 14.10 */ }
/* Copy data */
OD_size_t countWritten = 0;
@ -891,6 +902,7 @@ CO_SDO_return_t CO_SDOserver_process(CO_SDOserver_t *SDO,
SDO->state = CO_SDO_ST_ABORT;
break;
}
else { /* MISRA C 2004 14.10 */ }
}
}
else {
@ -938,8 +950,9 @@ CO_SDO_return_t CO_SDOserver_process(CO_SDOserver_t *SDO,
if (SDO->finished
|| (CO_CONFIG_SDO_SRV_BUFFER_SIZE - SDO->bufOffsetWr)<(7+2)
) {
if (!validateAndWriteToOD(SDO, &abortCode, 0, 0))
if (!validateAndWriteToOD(SDO, &abortCode, 0, 0)) {
break;
}
}
SDO->state = CO_SDO_ST_DOWNLOAD_SEGMENT_RSP;
@ -1151,14 +1164,17 @@ CO_SDO_return_t CO_SDOserver_process(CO_SDOserver_t *SDO,
/* unknown message received */
abortCode = CO_SDO_AB_CMD;
SDO->state = CO_SDO_ST_ABORT;
break;
}
} /* switch (SDO->state) */
} /* if (SDO->state != CO_SDO_ST_IDLE && SDO->state != CO_SDO_ST_ABORT) */
#if (CO_CONFIG_SDO_SRV) & CO_CONFIG_SDO_SRV_SEGMENTED
SDO->timeoutTimer = 0;
#endif
timeDifference_us = 0;
CO_FLAG_CLEAR(SDO->CANrxNew);
} /* if (isNew) */
} /* else if (isNew) */
else { /* MISRA C 2004 14.10 */ }
/* Timeout timers and transmit bufferFull flag ****************************/
#if (CO_CONFIG_SDO_SRV) & CO_CONFIG_SDO_SRV_SEGMENTED
@ -1338,8 +1354,9 @@ CO_SDO_return_t CO_SDOserver_process(CO_SDOserver_t *SDO,
#if (CO_CONFIG_SDO_SRV) & CO_CONFIG_SDO_SRV_SEGMENTED
case CO_SDO_ST_UPLOAD_SEGMENT_RSP: {
/* refill the data buffer if necessary */
if (!readFromOd(SDO, &abortCode, 7, false))
if (!readFromOd(SDO, &abortCode, 7, false)) {
break;
}
/* SDO command specifier with toggle bit */
SDO->CANtxBuff->data[0] = SDO->toggle;
@ -1380,6 +1397,7 @@ CO_SDO_return_t CO_SDOserver_process(CO_SDOserver_t *SDO,
SDO->state = CO_SDO_ST_ABORT;
break;
}
else { /* MISRA C 2004 14.10 */ }
}
/* send message */

36
301/CO_SYNC.c
View file

@ -236,7 +236,7 @@ CO_ReturnError_t CO_SYNC_init(CO_SYNC_t *SYNC,
odRet = OD_get_u32(OD_1005_cobIdSync, 0, &cobIdSync, true);
if (odRet != ODR_OK) {
if (errInfo != NULL) *errInfo = OD_getIndex(OD_1005_cobIdSync);
if (errInfo != NULL) { *errInfo = OD_getIndex(OD_1005_cobIdSync); }
return CO_ERROR_OD_PARAMETERS;
}
#if (CO_CONFIG_SYNC) & CO_CONFIG_FLAG_OD_DYNAMIC
@ -251,12 +251,16 @@ CO_ReturnError_t CO_SYNC_init(CO_SYNC_t *SYNC,
sizeof(uint32_t), NULL);
#if (CO_CONFIG_SYNC) & CO_CONFIG_SYNC_PRODUCER
if (SYNC->OD_1006_period == NULL) {
if (errInfo != NULL) *errInfo = OD_getIndex(OD_1006_commCyclePeriod);
if (errInfo != NULL) {
*errInfo = OD_getIndex(OD_1006_commCyclePeriod);
}
return CO_ERROR_OD_PARAMETERS;
}
#else
if (OD_1006_commCyclePeriod != NULL && SYNC->OD_1006_period == NULL) {
if (errInfo != NULL) *errInfo = OD_getIndex(OD_1006_commCyclePeriod);
if (errInfo != NULL) {
*errInfo = OD_getIndex(OD_1006_commCyclePeriod);
}
return CO_ERROR_OD_PARAMETERS;
}
#endif
@ -265,7 +269,9 @@ CO_ReturnError_t CO_SYNC_init(CO_SYNC_t *SYNC,
SYNC->OD_1007_window = OD_getPtr(OD_1007_syncWindowLen, 0,
sizeof(uint32_t), NULL);
if (OD_1007_syncWindowLen != NULL && SYNC->OD_1007_window == NULL) {
if (errInfo != NULL) *errInfo = OD_getIndex(OD_1007_syncWindowLen);
if (errInfo != NULL) {
*errInfo = OD_getIndex(OD_1007_syncWindowLen);
}
return CO_ERROR_OD_PARAMETERS;
}
@ -276,11 +282,14 @@ CO_ReturnError_t CO_SYNC_init(CO_SYNC_t *SYNC,
if (OD_1019_syncCounterOvf != NULL) {
odRet = OD_get_u8(OD_1019_syncCounterOvf, 0, &syncCounterOvf, true);
if (odRet != ODR_OK) {
if (errInfo != NULL) *errInfo = OD_getIndex(OD_1019_syncCounterOvf);
if (errInfo != NULL) {
*errInfo = OD_getIndex(OD_1019_syncCounterOvf);
}
return CO_ERROR_OD_PARAMETERS;
}
if (syncCounterOvf == 1) syncCounterOvf = 2;
else if (syncCounterOvf > 240) syncCounterOvf = 240;
if (syncCounterOvf == 1) { syncCounterOvf = 2; }
else if (syncCounterOvf > 240) { syncCounterOvf = 240; }
else { /* MISRA C 2004 14.10 */ }
#if (CO_CONFIG_SYNC) & CO_CONFIG_FLAG_OD_DYNAMIC
#if (CO_CONFIG_SYNC) & CO_CONFIG_SYNC_PRODUCER
@ -317,8 +326,9 @@ CO_ReturnError_t CO_SYNC_init(CO_SYNC_t *SYNC,
0, /* rtr */
(void*)SYNC, /* object passed to receive function */
CO_SYNC_receive); /* this function will process received message*/
if (ret != CO_ERROR_NO)
if (ret != CO_ERROR_NO) {
return ret;
}
#if (CO_CONFIG_SYNC) & CO_CONFIG_SYNC_PRODUCER
SYNC->CANtxBuff = CO_CANtxBufferInit(
@ -329,8 +339,9 @@ CO_ReturnError_t CO_SYNC_init(CO_SYNC_t *SYNC,
syncCounterOvf != 0 ? 1 : 0, /* number of data bytes */
0); /* synchronous message flag bit */
if (SYNC->CANtxBuff == NULL)
if (SYNC->CANtxBuff == NULL) {
return CO_ERROR_ILLEGAL_ARGUMENT;
}
#endif
return CO_ERROR_NO;
@ -365,7 +376,7 @@ CO_SYNC_status_t CO_SYNC_process(CO_SYNC_t *SYNC,
if (NMTisPreOrOperational) {
/* update sync timer, no overflow */
uint32_t timerNew = SYNC->timer + timeDifference_us;
if (timerNew > SYNC->timer) SYNC->timer = timerNew;
if (timerNew > SYNC->timer) { SYNC->timer = timerNew; }
/* was SYNC just received */
if (CO_FLAG_READ(SYNC->CANrxNew)) {
@ -401,7 +412,9 @@ CO_SYNC_status_t CO_SYNC_process(CO_SYNC_t *SYNC,
if (SYNC->timeoutError == 1) {
/* periodTimeout is 1,5 * OD_1006_period, no overflow */
uint32_t periodTimeout = OD_1006_period + (OD_1006_period >> 1);
if (periodTimeout < OD_1006_period) periodTimeout = 0xFFFFFFFF;
if (periodTimeout < OD_1006_period) {
periodTimeout = 0xFFFFFFFF;
}
if (SYNC->timer > periodTimeout) {
CO_errorReport(SYNC->em, CO_EM_SYNC_TIME_OUT,
@ -417,6 +430,7 @@ CO_SYNC_status_t CO_SYNC_process(CO_SYNC_t *SYNC,
}
#endif
}
else { /* MISRA C 2004 14.10 */ }
} /* if (OD_1006_period > 0) */
/* Synchronous PDOs are allowed only inside time window */

2
301/CO_SYNC.h
View file

@ -223,7 +223,7 @@ void CO_SYNC_initCallbackPre(CO_SYNC_t *SYNC,
* @return Same as CO_CANsend().
*/
static inline CO_ReturnError_t CO_SYNCsend(CO_SYNC_t *SYNC) {
if (++SYNC->counter > SYNC->counterOverflowValue) SYNC->counter = 1;
if (++SYNC->counter > SYNC->counterOverflowValue) { SYNC->counter = 1; }
SYNC->timer = 0;
SYNC->CANrxToggle = SYNC->CANrxToggle ? false : true;
SYNC->CANtxBuff->data[0] = SYNC->counter;

5
301/CO_TIME.c
View file

@ -114,7 +114,7 @@ CO_ReturnError_t CO_TIME_init(CO_TIME_t *TIME,
uint32_t cobIdTimeStamp;
ODR_t odRet = OD_get_u32(OD_1012_cobIdTimeStamp, 0, &cobIdTimeStamp, true);
if (odRet != ODR_OK) {
if (errInfo != NULL) *errInfo = OD_getIndex(OD_1012_cobIdTimeStamp);
if (errInfo != NULL) { *errInfo = OD_getIndex(OD_1012_cobIdTimeStamp); }
return CO_ERROR_OD_PARAMETERS;
}
#if (CO_CONFIG_TIME) & CO_CONFIG_FLAG_OD_DYNAMIC
@ -140,8 +140,9 @@ CO_ReturnError_t CO_TIME_init(CO_TIME_t *TIME,
0, /* rtr */
(void*)TIME, /* object passed to receive function */
CO_TIME_receive);/*this function will process received message*/
if (ret != CO_ERROR_NO)
if (ret != CO_ERROR_NO) {
return ret;
}
}
#if (CO_CONFIG_TIME) & CO_CONFIG_TIME_PRODUCER

9
301/CO_fifo.c
View file

@ -398,6 +398,9 @@ size_t CO_fifo_readToken(CO_fifo_t *fifo,
delimCommandFound = true;
}
break;
default:
/* MISRA C 2004 15.3 */
break;
}
if (delimCommentFound == true) {
/* Comment delimiter found, clear all till end of the line. */
@ -745,6 +748,9 @@ size_t CO_fifo_readB642a(CO_fifo_t *fifo, char *buf, size_t count, bool_t end) {
buf[len++] = base64EncTable[(word >> 6) & 0x3F];
buf[len++] = '=';
break;
default:
/* MISRA C 2004 15.3 */
break;
}
}
break;
@ -1344,6 +1350,9 @@ size_t CO_fifo_cpyTok2B64(CO_fifo_t *dest, CO_fifo_t *src, CO_fifo_st *status) {
CO_fifo_putc(dest, (uint8_t)(dword >> 2));
destSpace -= 2;
break;
default:
/* MISRA C 2004 15.3 */
break;
}
bool_t insideComment = false;

40
303/CO_LEDs.c
View file

@ -75,8 +75,8 @@ 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 & CO_LED_blink) == 0) { rd |= CO_LED_blink; }
else { gr |= CO_LED_blink; }
switch (++LEDs->LEDtmrflash_1) {
case 1: rd |= CO_LED_flash_1; break;
@ -110,8 +110,8 @@ void CO_LEDs_process(CO_LEDs_t *LEDs,
}
/* calculate 10Hz flickering */
if (rdFlickerNext) rd |= CO_LED_flicker;
else gr |= CO_LED_flicker;
if (rdFlickerNext) { rd |= CO_LED_flicker; }
else { gr |= CO_LED_flicker; }
} /* while (LEDs->LEDtmr50ms >= 50000) */
@ -119,25 +119,25 @@ void CO_LEDs_process(CO_LEDs_t *LEDs,
uint8_t rd_co, gr_co;
/* 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 rd_co = 0;
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 { 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;
else if (NMTstate == CO_NMT_OPERATIONAL) gr_co = 1;
else gr_co = 0;
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;}
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 != 0) { rd |= CO_LED_CANopen; }
if (gr_co != 0) { gr |= CO_LED_CANopen; }
LEDs->LEDred = rd;
LEDs->LEDgreen = gr;
} /* if (tick) */

1
305/CO_LSSslave.c
View file

@ -163,6 +163,7 @@ static void CO_LSSslave_receive(void *object, void *msg)
}
}
}
else { /* MISRA C 2004 14.10 */ }
if (ack) {
#if (CO_CONFIG_LSS) & CO_CONFIG_LSS_SLAVE_FASTSCAN_DIRECT_RESPOND
LSSslave->TXbuff->data[0] = CO_LSS_IDENT_SLAVE;

3
309/CO_gateway_ascii.c
View file

@ -742,6 +742,9 @@ void CO_GTWA_process(CO_GTWA_t *gtwa,
case 3: /* <command> token contains digit */
err = true;
break;
default:
/* MISRA C 2004 15.3 */
break;
}
if (err) break;

48
CANopen.c
View file

@ -331,7 +331,9 @@
#endif
/* Define macros for allocation */
#define CO_alloc_break_on_fail(var, num, size) if (((var) = CO_alloc((num), (size))) != NULL) { mem += (size) * (num); } else { break; }
#define CO_alloc_break_on_fail(var, num, size) { \
var = CO_alloc((num), (size)); \
if((var) != NULL) { mem += (size) * (num); } else { break; } }
#ifdef CO_MULTIPLE_OD
#define ON_MULTI_OD(sentence) sentence
@ -893,7 +895,7 @@ bool_t CO_isLSSslaveEnabled(CO_t *co) {
(void) co; /* may be unused */
bool_t en = false;
#if (CO_CONFIG_LSS) & CO_CONFIG_LSS_SLAVE
if (CO_GET_CNT(LSS_SLV) == 1) en = true;
if (CO_GET_CNT(LSS_SLV) == 1) { en = true; }
#endif
return en;
}
@ -902,7 +904,7 @@ bool_t CO_isLSSslaveEnabled(CO_t *co) {
CO_ReturnError_t CO_CANinit(CO_t *co, void *CANptr, uint16_t bitRate) {
CO_ReturnError_t err;
if (co == NULL) return CO_ERROR_ILLEGAL_ARGUMENT;
if (co == NULL) { return CO_ERROR_ILLEGAL_ARGUMENT; }
co->CANmodule->CANnormal = false;
CO_CANsetConfigurationMode(CANptr);
@ -993,11 +995,12 @@ CO_ReturnError_t CO_CANopenInit(CO_t *co,
if (nodeId < 1 || nodeId > 127) {
return CO_ERROR_ILLEGAL_ARGUMENT;
}
else { /* MISRA C 2004 14.10 */ }
#if (CO_CONFIG_LEDS) & CO_CONFIG_LEDS_ENABLE
if (CO_GET_CNT(LEDS) == 1) {
err = CO_LEDs_init(co->LEDs);
if (err) return err;
if (err) { return err; }
}
#endif
@ -1034,7 +1037,7 @@ CO_ReturnError_t CO_CANopenInit(CO_t *co,
#endif
nodeId,
errInfo);
if (err) return err;
if (err) { return err; }
}
/* NMT_Heartbeat */
@ -1057,7 +1060,7 @@ CO_ReturnError_t CO_CANopenInit(CO_t *co,
CO_GET_CO(TX_IDX_HB_PROD),
CO_CAN_ID_HEARTBEAT + nodeId,
errInfo);
if (err) return err;
if (err) { return err; }
}
#if (CO_CONFIG_HB_CONS) & CO_CONFIG_HB_CONS_ENABLE
@ -1070,7 +1073,7 @@ CO_ReturnError_t CO_CANopenInit(CO_t *co,
co->CANmodule,
CO_GET_CO(RX_IDX_HB_CONS),
errInfo);
if (err) return err;
if (err) { return err; }
}
#endif
@ -1085,7 +1088,7 @@ CO_ReturnError_t CO_CANopenInit(CO_t *co,
co->CANmodule,
CO_GET_CO(TX_IDX_NG_SLV),
errInfo);
if (err) return err;
if (err) { return err; }
#endif
#if (CO_CONFIG_NODE_GUARDING) & CO_CONFIG_NODE_GUARDING_MASTER_ENABLE
err = CO_nodeGuardingMaster_init(co->NGmaster,
@ -1094,7 +1097,7 @@ CO_ReturnError_t CO_CANopenInit(CO_t *co,
CO_GET_CO(RX_IDX_NG_MST),
co->CANmodule,
CO_GET_CO(TX_IDX_NG_MST));
if (err) return err;
if (err) { return err; }
#endif
/* SDOserver */
@ -1111,7 +1114,7 @@ CO_ReturnError_t CO_CANopenInit(CO_t *co,
co->CANmodule,
CO_GET_CO(TX_IDX_SDO_SRV) + i,
errInfo);
if (err) return err;
if (err) { return err; }
}
}
@ -1128,7 +1131,7 @@ CO_ReturnError_t CO_CANopenInit(CO_t *co,
co->CANmodule,
CO_GET_CO(TX_IDX_SDO_CLI) + i,
errInfo);
if (err) return err;
if (err) { return err; }
}
}
#endif
@ -1144,7 +1147,7 @@ CO_ReturnError_t CO_CANopenInit(CO_t *co,
CO_GET_CO(TX_IDX_TIME),
#endif
errInfo);
if (err) return err;
if (err) { return err; }
}
#endif
@ -1163,7 +1166,7 @@ CO_ReturnError_t CO_CANopenInit(CO_t *co,
CO_GET_CO(TX_IDX_SYNC),
#endif
errInfo);
if (err) return err;
if (err) { return err; }
}
#endif
@ -1177,7 +1180,7 @@ CO_ReturnError_t CO_CANopenInit(CO_t *co,
co->CANmodule,
CO_GET_CO(TX_IDX_GFC),
CO_CAN_ID_GFC);
if (err) return err;
if (err) { return err; }
}
#endif
@ -1189,7 +1192,7 @@ CO_ReturnError_t CO_CANopenInit(CO_t *co,
&OD_configurationValid,
OD_H13FE_SRDO_VALID,
OD_H13FF_SRDO_CHECKSUM);
if (err) return err;
if (err) { return err; }
OD_entry_t *SRDOcomm = OD_GET(H1301, OD_H1301_SRDO_1_PARAM);
OD_entry_t *SRDOmap = OD_GET(H1318, OD_H1381_SRDO_1_MAPPING);
@ -1214,7 +1217,7 @@ CO_ReturnError_t CO_CANopenInit(CO_t *co,
co->CANmodule,
CANdevTxIdx,
CANdevTxIdx + 1);
if (err) return err;
if (err) { return err; }
}
}
#endif
@ -1229,7 +1232,7 @@ CO_ReturnError_t CO_CANopenInit(CO_t *co,
co->CANmodule,
CO_GET_CO(TX_IDX_LSS_MST),
CO_CAN_ID_LSS_MST);
if (err) return err;
if (err) { return err; }
}
#endif
@ -1251,7 +1254,7 @@ CO_ReturnError_t CO_CANopenInit(CO_t *co,
co->LEDs,
#endif
0);
if (err) return err;
if (err) { return err; }
}
#endif
@ -1274,7 +1277,7 @@ CO_ReturnError_t CO_CANopenInit(CO_t *co,
&OD_trace[i].triggerTime,
OD_INDEX_TRACE_CONFIG + i,
OD_INDEX_TRACE + i);
if (err) return err;
if (err) { return err; }
}
}
#endif
@ -1327,7 +1330,7 @@ CO_ReturnError_t CO_CANopenInitPDO(CO_t *co,
co->CANmodule,
CO_GET_CO(RX_IDX_RPDO) + i,
errInfo);
if (err) return err;
if (err) { return err; }
}
}
#endif
@ -1361,7 +1364,7 @@ CO_ReturnError_t CO_CANopenInitPDO(CO_t *co,
co->CANmodule,
CO_GET_CO(TX_IDX_TPDO) + i,
errInfo);
if (err) return err;
if (err) { return err; }
}
}
#endif
@ -1525,6 +1528,9 @@ bool_t CO_process_SYNC(CO_t *co,
case CO_SYNC_PASSED_WINDOW:
CO_CANclearPendingSyncPDOs(co->CANmodule);
break;
default:
/* MISRA C 2004 15.3 */
break;
}
}

37
codingStyle
View file

@ -91,19 +91,54 @@ int32_t foo1(object1_t *thisObj,
* comment.
*/
/* All if and else statement must have use { } around their bodies
* (MISRA C 2004 rule 14.9)
*/
if (xy == yz) { /* Comment. '//' comments are not allowed */
a = b;
} else {
} else if (xy < yz) {
a = c;
}
else {
/* To stay compliant with MISRA C 2004 14.10
* all else if statements need a final else even if empty
*/
}
/* Assignment operators shall not be used in expressions which return
* boolean values (MISRA C 2004 rule 13.1)
* This is true for: 'if' and 'while' statements.
* For instance:
*/
if (xy = yz){
}
while (xy = yz){
}
switch (zx) {
case 1:
a = b;
break
default:
/* To stay compliant with MISRA C 2004 15.3
* the default case must be present */
break;
}
}
/* MISRA C 2004 Rule E14.4.3
* There should be no more than one break or goto statement used to terminate
* any iteration statement.
*/
/* MISRA C 2004 Rule 14.5
* The continue statement shall not be used.
*/
/* More about MISRA C
* https://www.ibm.com/docs/en/devops-test-embedded/9.0.0?topic=review-code-misra-2004-rules
*/
/** @} */
#ifdef __cplusplus

6
extra/CO_trace.c
View file

@ -236,6 +236,9 @@ static CO_SDO_abortCode_t CO_ODF_traceConfig(CO_ODF_arg_t *ODF_arg) {
}
}
break;
default:
/* MISRA C 2004 15.3 */
break;
}
return ret;
@ -387,6 +390,9 @@ static CO_SDO_abortCode_t CO_ODF_trace(CO_ODF_arg_t *ODF_arg) {
}
}
break;
default:
/* MISRA C 2004 15.3 */
break;
}
return ret;