nikon/CANopenNode
1
0
Fork 0
Code Activity Actions

static analysis: Aggiunte parentesi per la dipendenza posta sulla precedenza dell'operatore [MISRA 2012 Rule 12.1, advisory]

Browse source
This commit is contained in:
temi54c1l8 2024-06-10 14:20:16 +02:00
parent a17b9fa209
commit dc10900ad5
20 changed files with 480 additions and 480 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

20
301/CO_Emergency.c
View file

@ -129,8 +129,8 @@ static ODR_t OD_write_1014(OD_stream_t *stream, const void *buf,
static ODR_t OD_read_1014_default(OD_stream_t *stream, void *buf,
OD_size_t count, OD_size_t *countRead)
{
if (stream == NULL || stream->subIndex != 0 || buf == NULL
|| count < sizeof(uint32_t) || countRead == NULL
if ((stream == NULL) || (stream->subIndex != 0) || (buf == NULL)
|| (count < sizeof(uint32_t)) || (countRead == NULL)
) {
return ODR_DEV_INCOMPAT;
}
@ -373,13 +373,13 @@ CO_ReturnError_t CO_EM_init(CO_EM_t *em,
CO_ReturnError_t ret = CO_ERROR_NO;
/* verify arguments */
if (em == NULL || OD_1001_errReg == NULL
if ((em == NULL) || (OD_1001_errReg == NULL)
#if (CO_CONFIG_EM) & (CO_CONFIG_EM_PRODUCER | CO_CONFIG_EM_HISTORY)
|| (fifo == NULL && fifoSize >= 2)
|| ((fifo == NULL) && (fifoSize >= 2))
#endif
#if (CO_CONFIG_EM) & CO_CONFIG_EM_PRODUCER
|| OD_1014_cobIdEm == NULL || CANdevTx == NULL
|| nodeId < 1 || nodeId > 127
|| (OD_1014_cobIdEm == NULL) || (CANdevTx == NULL)
|| (nodeId < 1) || (nodeId > 127)
#endif
#if (CO_CONFIG_EM) & CO_CONFIG_EM_HISTORY
|| OD_1003_preDefErr == NULL
@ -414,7 +414,7 @@ CO_ReturnError_t CO_EM_init(CO_EM_t *em,
uint32_t COB_IDEmergency32;
ODR_t odRet;
odRet = OD_get_u32(OD_1014_cobIdEm, 0, &COB_IDEmergency32, true);
if (odRet != ODR_OK || (COB_IDEmergency32 & 0x7FFFF800) != 0) {
if ((odRet != ODR_OK) || ((COB_IDEmergency32 & 0x7FFFF800) != 0)) {
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; }
@ -647,7 +647,7 @@ void CO_EM_process(CO_EM_t *em,
) {
em->inhibitEmTimer = 0;
#else
if (fifoPpPtr != em->fifoWrPtr && !em->CANtxBuff->bufferFull) {
if ((fifoPpPtr != em->fifoWrPtr) && (!em->CANtxBuff->bufferFull)) {
#endif
/* add error register to emergency message */
em->fifo[fifoPpPtr].msg |= (uint32_t) errorRegister << 16;
@ -679,7 +679,7 @@ void CO_EM_process(CO_EM_t *em,
CO_errorReport(em, CO_EM_EMERGENCY_BUFFER_FULL,
CO_EMC_GENERIC, 0);
}
else if (em->fifoOverflow == 2 && em->fifoPpPtr == em->fifoWrPtr) {
else if ((em->fifoOverflow == 2) && (em->fifoPpPtr == em->fifoWrPtr)) {
em->fifoOverflow = 0;
CO_errorReset(em, CO_EM_EMERGENCY_BUFFER_FULL, 0);
}
@ -754,7 +754,7 @@ void CO_error(CO_EM_t *em, bool_t setError, const uint8_t errorBit,
#if (CO_CONFIG_EM) & (CO_CONFIG_EM_PRODUCER | CO_CONFIG_EM_HISTORY)
/* prepare emergency message. Error register will be added in post-process*/
uint32_t errMsg = (uint32_t)errorBit << 24 | CO_SWAP_16(errorCode);
uint32_t errMsg = ((uint32_t)errorBit << 24) | CO_SWAP_16(errorCode);
#if (CO_CONFIG_EM) & CO_CONFIG_EM_PRODUCER
uint32_t infoCodeSwapped = CO_SWAP_32(infoCode);
#endif

24
301/CO_HBconsumer.c
View file

@ -88,10 +88,10 @@ static ODR_t OD_write_1016(OD_stream_t *stream, const void *buf,
{
CO_HBconsumer_t *HBcons = stream->object;
if (stream == NULL || buf == NULL
|| stream->subIndex < 1
|| stream->subIndex > HBcons->numberOfMonitoredNodes
|| count != sizeof(uint32_t) || countWritten == NULL
if ((stream == NULL) || (buf == NULL)
|| (stream->subIndex < 1)
|| (stream->subIndex > HBcons->numberOfMonitoredNodes)
|| (count != sizeof(uint32_t)) || (countWritten == NULL)
) {
return ODR_DEV_INCOMPAT;
}
@ -124,8 +124,8 @@ CO_ReturnError_t CO_HBconsumer_init(CO_HBconsumer_t *HBcons,
ODR_t odRet;
/* verify arguments */
if (HBcons == NULL || em == NULL || monitoredNodes == NULL
|| OD_1016_HBcons == NULL || CANdevRx == NULL
if ((HBcons == NULL) || (em == NULL) || (monitoredNodes == NULL)
|| (OD_1016_HBcons == NULL) || (CANdevRx == NULL)
) {
return CO_ERROR_ILLEGAL_ARGUMENT;
}
@ -139,8 +139,8 @@ CO_ReturnError_t CO_HBconsumer_init(CO_HBconsumer_t *HBcons,
/* get actual number of monitored nodes */
HBcons->numberOfMonitoredNodes =
OD_1016_HBcons->subEntriesCount-1 < monitoredNodesCount ?
OD_1016_HBcons->subEntriesCount-1 : monitoredNodesCount;
((OD_1016_HBcons->subEntriesCount-1) < monitoredNodesCount) ?
(OD_1016_HBcons->subEntriesCount-1) : monitoredNodesCount;
for (uint8_t i = 0; i < HBcons->numberOfMonitoredNodes; i++) {
uint32_t val;
@ -185,15 +185,15 @@ static CO_ReturnError_t CO_HBconsumer_initEntry(CO_HBconsumer_t *HBcons,
CO_ReturnError_t ret = CO_ERROR_NO;
/* verify arguments */
if (HBcons == NULL || idx >= HBcons->numberOfMonitoredNodes) {
if ((HBcons == NULL) || (idx >= HBcons->numberOfMonitoredNodes)) {
return CO_ERROR_ILLEGAL_ARGUMENT;
}
/* verify for duplicate entries */
if(consumerTime_ms != 0 && nodeId != 0) {
if((consumerTime_ms != 0) && (nodeId != 0)) {
for (uint8_t i = 0; i < HBcons->numberOfMonitoredNodes; i++) {
CO_HBconsNode_t node = HBcons->monitoredNodes[i];
if(idx != i && node.time_us != 0 && node.nodeId == nodeId) {
if((idx != i) && (node.time_us != 0) && (node.nodeId == nodeId)) {
ret = CO_ERROR_OD_PARAMETERS;
}
}
@ -214,7 +214,7 @@ static CO_ReturnError_t CO_HBconsumer_initEntry(CO_HBconsumer_t *HBcons,
CO_FLAG_CLEAR(monitoredNode->CANrxNew);
/* is channel used */
if (monitoredNode->nodeId != 0 && monitoredNode->time_us != 0) {
if ((monitoredNode->nodeId != 0) && (monitoredNode->time_us != 0)) {
COB_ID = monitoredNode->nodeId + CO_CAN_ID_HEARTBEAT;
monitoredNode->HBstate = CO_HBconsumer_UNKNOWN;
}

34
301/CO_NMT_Heartbeat.c
View file

@ -41,7 +41,7 @@ static void CO_NMT_receive(void *object, void *msg) {
CO_NMT_t *NMT = (CO_NMT_t*)object;
if (DLC == 2 && (nodeId == 0 || nodeId == NMT->nodeId)) {
if ((DLC == 2) && ((nodeId == 0) || (nodeId == NMT->nodeId))) {
NMT->internalCommand = command;
#if (CO_CONFIG_NMT) & CO_CONFIG_FLAG_CALLBACK_PRE
@ -62,8 +62,8 @@ static void CO_NMT_receive(void *object, void *msg) {
static ODR_t OD_write_1017(OD_stream_t *stream, const void *buf,
OD_size_t count, OD_size_t *countWritten)
{
if (stream == NULL || stream->subIndex != 0 || buf == NULL
|| count != sizeof(uint16_t) || countWritten == NULL
if ((stream == NULL) || (stream->subIndex != 0) || (buf == NULL)
|| (count != sizeof(uint16_t)) || (countWritten == NULL)
) {
return ODR_DEV_INCOMPAT;
}
@ -102,10 +102,10 @@ CO_ReturnError_t CO_NMT_init(CO_NMT_t *NMT,
CO_ReturnError_t ret = CO_ERROR_NO;
/* verify arguments */
if (NMT == NULL || OD_1017_ProducerHbTime == NULL || em == NULL
|| NMT_CANdevRx == NULL || HB_CANdevTx == NULL
if ((NMT == NULL) || (OD_1017_ProducerHbTime == NULL) || (em == NULL)
|| (NMT_CANdevRx == NULL) || (HB_CANdevTx == NULL)
#if (CO_CONFIG_NMT) & CO_CONFIG_NMT_MASTER
|| NMT_CANdevTx == NULL
|| (NMT_CANdevTx == NULL)
#endif
) {
return CO_ERROR_ILLEGAL_ARGUMENT;
@ -234,16 +234,16 @@ CO_NMT_reset_cmd_t CO_NMT_process(CO_NMT_t *NMT,
/* Send heartbeat producer message if:
* - First start, send bootup message or
* - HB producer enabled and: Timer expired or NMT->operatingState changed*/
if (NNTinit || (NMT->HBproducerTime_us != 0
&& (NMT->HBproducerTimer == 0
|| NMTstateCpy != NMT->operatingStatePrev)
if (NNTinit || ((NMT->HBproducerTime_us != 0)
&& ((NMT->HBproducerTimer == 0)
|| (NMTstateCpy != NMT->operatingStatePrev))
)) {
NMT->HB_TXbuff->data[0] = (uint8_t) NMTstateCpy;
CO_CANsend(NMT->HB_CANdevTx, NMT->HB_TXbuff);
if (NMTstateCpy == CO_NMT_INITIALIZING) {
/* NMT slave self starting */
NMTstateCpy = (NMT->NMTcontrol & CO_NMT_STARTUP_TO_OPERATIONAL) != 0
NMTstateCpy = ((NMT->NMTcontrol & CO_NMT_STARTUP_TO_OPERATIONAL) != 0)
? CO_NMT_OPERATIONAL : CO_NMT_PRE_OPERATIONAL;
}
else {
@ -282,19 +282,19 @@ 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 = ((NMT->NMTcontrol & CO_NMT_ERR_ON_BUSOFF_HB) != 0)
&& (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 = ((NMT->NMTcontrol & CO_NMT_ERR_ON_ERR_REG) != 0)
&& ((CO_getErrorRegister(NMT->em) & NMT->NMTcontrol) != 0);
if (NMTstateCpy == CO_NMT_OPERATIONAL && (busOff_HB || errRegMasked)) {
NMTstateCpy = (NMT->NMTcontrol & CO_NMT_ERR_TO_STOPPED) != 0
if ((NMTstateCpy == CO_NMT_OPERATIONAL) && (busOff_HB || errRegMasked)) {
NMTstateCpy = ((NMT->NMTcontrol & CO_NMT_ERR_TO_STOPPED) != 0)
? CO_NMT_STOPPED : CO_NMT_PRE_OPERATIONAL;
}
else if ((NMT->NMTcontrol & CO_NMT_ERR_FREE_TO_OPERATIONAL) != 0
&& NMTstateCpy == CO_NMT_PRE_OPERATIONAL && !busOff_HB && !errRegMasked
else if (((NMT->NMTcontrol & CO_NMT_ERR_FREE_TO_OPERATIONAL) != 0)
&& (NMTstateCpy == CO_NMT_PRE_OPERATIONAL) && (!busOff_HB && !errRegMasked)
) {
NMTstateCpy = CO_NMT_OPERATIONAL;
}

12
301/CO_Node_Guarding.c
View file

@ -50,8 +50,8 @@ static void CO_ngs_receive(void *object, void *msg) {
static ODR_t OD_write_100C(OD_stream_t *stream, const void *buf,
OD_size_t count, OD_size_t *countWritten)
{
if (stream == NULL || stream->subIndex != 0 || buf == NULL
|| count != sizeof(uint16_t) || countWritten == NULL
if ((stream == NULL) || (stream->subIndex != 0) || (buf == NULL)
|| (count != sizeof(uint16_t)) || (countWritten == NULL)
) {
return ODR_DEV_INCOMPAT;
}
@ -80,8 +80,8 @@ static ODR_t OD_write_100C(OD_stream_t *stream, const void *buf,
static ODR_t OD_write_100D(OD_stream_t *stream, const void *buf,
OD_size_t count, OD_size_t *countWritten)
{
if (stream == NULL || stream->subIndex != 0 || buf == NULL
|| count != sizeof(uint8_t) || countWritten == NULL
if ((stream == NULL) || (stream->subIndex != 0) || (buf == NULL)
|| (count != sizeof(uint8_t)) || (countWritten == NULL)
) {
return ODR_DEV_INCOMPAT;
}
@ -117,8 +117,8 @@ CO_ReturnError_t CO_nodeGuardingSlave_init(CO_nodeGuardingSlave_t *ngs,
CO_ReturnError_t ret = CO_ERROR_NO;
/* verify arguments */
if (ngs == NULL || em == NULL || CANdevRx == NULL || CANdevTx == NULL
|| OD_100C_GuardTime == NULL || OD_100D_LifeTimeFactor == NULL
if ((ngs == NULL) || (em == NULL) || (CANdevRx == NULL) || (CANdevTx == NULL)
|| (OD_100C_GuardTime == NULL) || (OD_100D_LifeTimeFactor == NULL)
) {
return CO_ERROR_ILLEGAL_ARGUMENT;
}

30
301/CO_ODinterface.c
View file

@ -31,7 +31,7 @@
ODR_t OD_readOriginal(OD_stream_t *stream, void *buf,
OD_size_t count, OD_size_t *countRead)
{
if (stream == NULL || buf == NULL || countRead == NULL) {
if ((stream == NULL) || (buf == NULL) || (countRead == NULL)) {
return ODR_DEV_INCOMPAT;
}
@ -46,7 +46,7 @@ ODR_t OD_readOriginal(OD_stream_t *stream, void *buf,
/* If previous read was partial or OD variable length is larger than
* current buffer size, then data was (will be) read in several segments */
if (stream->dataOffset > 0 || dataLenToCopy > count) {
if ((stream->dataOffset > 0) || (dataLenToCopy > count)) {
if (stream->dataOffset >= dataLenToCopy) {
return ODR_DEV_INCOMPAT;
}
@ -75,7 +75,7 @@ ODR_t OD_readOriginal(OD_stream_t *stream, void *buf,
ODR_t OD_writeOriginal(OD_stream_t *stream, const void *buf,
OD_size_t count, OD_size_t *countWritten)
{
if (stream == NULL || buf == NULL || countWritten == NULL) {
if ((stream == NULL) || (buf == NULL) || (countWritten == NULL)) {
return ODR_DEV_INCOMPAT;
}
@ -91,7 +91,7 @@ ODR_t OD_writeOriginal(OD_stream_t *stream, const void *buf,
/* If previous write was partial or OD variable length is larger than
* current buffer size, then data was (will be) written in several
* segments */
if (stream->dataOffset > 0 || dataLenToCopy > count) {
if ((stream->dataOffset > 0) || (dataLenToCopy > count)) {
if (stream->dataOffset >= dataLenToCopy) {
return ODR_DEV_INCOMPAT;
}
@ -141,7 +141,7 @@ static ODR_t OD_writeDisabled(OD_stream_t *stream, const void *buf,
/******************************************************************************/
OD_entry_t *OD_find(OD_t *od, uint16_t index) {
if (od == NULL || od->size == 0) {
if ((od == NULL) || (od->size == 0)) {
return NULL;
}
@ -182,7 +182,7 @@ 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 ((entry == NULL) || (entry->odObject == NULL)) { return ODR_IDX_NOT_EXIST; }
if (io == NULL) { return ODR_DEV_INCOMPAT; }
OD_stream_t *stream = &io->stream;
@ -211,8 +211,8 @@ ODR_t OD_getSub(const OD_entry_t *entry, uint8_t subIndex,
else {
stream->attribute = odo->attribute;
uint8_t *ptr = odo->dataOrig;
stream->dataOrig = ptr == NULL ? ptr
: ptr + odo->dataElementSizeof * (subIndex - 1);
stream->dataOrig = (ptr == NULL) ? ptr
: (ptr + (odo->dataElementSizeof * (subIndex - 1)));
stream->dataLength = odo->dataElementLength;
}
break;
@ -239,16 +239,16 @@ ODR_t OD_getSub(const OD_entry_t *entry, uint8_t subIndex,
}
/* Access data from the original OD location */
if (entry->extension == NULL || odOrig) {
if ((entry->extension == NULL) || odOrig) {
io->read = OD_readOriginal;
io->write = OD_writeOriginal;
stream->object = NULL;
}
/* Access data from extension specified by application */
else {
io->read = entry->extension->read != NULL ?
io->read = (entry->extension->read != NULL) ?
entry->extension->read : OD_readDisabled;
io->write = entry->extension->write != NULL ?
io->write = (entry->extension->write != NULL) ?
entry->extension->write : OD_writeDisabled;
stream->object = entry->extension->object;
}
@ -294,7 +294,7 @@ uint32_t OD_getSDOabCode(ODR_t returnCode) {
0x08000024UL /* No data available */
};
return (returnCode < 0 || returnCode >= ODR_COUNT) ?
return ((returnCode < 0) || (returnCode >= ODR_COUNT)) ?
abortCodes[ODR_DEV_INCOMPAT] : abortCodes[returnCode];
}
@ -342,10 +342,10 @@ void *OD_getPtr(const OD_entry_t *entry, uint8_t subIndex, OD_size_t len,
errCopy = OD_getSub(entry, subIndex, &io, true);
if (errCopy == ODR_OK) {
if (stream->dataOrig == NULL || stream->dataLength == 0) {
if ((stream->dataOrig == NULL) || (stream->dataLength == 0)) {
errCopy = ODR_DEV_INCOMPAT;
}
else if (len != 0 && len != stream->dataLength) {
else if ((len != 0) && (len != stream->dataLength)) {
errCopy = ODR_TYPE_MISMATCH;
}
else { /* MISRA C 2004 14.10 */ }
@ -353,5 +353,5 @@ void *OD_getPtr(const OD_entry_t *entry, uint8_t subIndex, OD_size_t len,
if (err != NULL) { *err = errCopy; }
return errCopy == ODR_OK ? stream->dataOrig : NULL;
return (errCopy == ODR_OK) ? stream->dataOrig : NULL;
}

8
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 & (ODA_TRPDO | ODA_TRSRDO)) != 0) : false;
}
@ -482,7 +482,7 @@ static inline void OD_rwRestart(OD_stream_t *stream) {
*/
static inline uint8_t *OD_getFlagsPDO(OD_entry_t *entry) {
#if OD_FLAGS_PDO_SIZE > 0
if (entry != NULL && entry->extension != NULL) {
if ((entry != NULL) && (entry->extension != NULL)) {
return &entry->extension->flagsPDO[0];
}
#endif
@ -509,7 +509,7 @@ static inline uint8_t *OD_getFlagsPDO(OD_entry_t *entry) {
*/
static inline void OD_requestTPDO(uint8_t *flagsPDO, uint8_t subIndex) {
#if OD_FLAGS_PDO_SIZE > 0
if (flagsPDO != NULL && subIndex < (OD_FLAGS_PDO_SIZE * 8)) {
if ((flagsPDO != NULL) && (subIndex < (OD_FLAGS_PDO_SIZE * 8))) {
/* clear subIndex-th bit */
uint8_t mask = ~(1 << (subIndex & 0x07));
flagsPDO[subIndex >> 3] &= mask;
@ -531,7 +531,7 @@ static inline void OD_requestTPDO(uint8_t *flagsPDO, uint8_t subIndex) {
*/
static inline bool_t OD_TPDOtransmitted(uint8_t *flagsPDO, uint8_t subIndex) {
#if OD_FLAGS_PDO_SIZE > 0
if (flagsPDO != NULL && subIndex < (OD_FLAGS_PDO_SIZE * 8)) {
if ((flagsPDO != NULL) && (subIndex < (OD_FLAGS_PDO_SIZE * 8))) {
/* return true, if subIndex-th bit is set */
uint8_t mask = 1 << (subIndex & 0x07);
if ((flagsPDO[subIndex >> 3] & mask) != 0) {

114
301/CO_PDO.c
View file

@ -57,7 +57,7 @@ static ODR_t OD_write_dummy(OD_stream_t *stream, const void *buf,
static ODR_t OD_read_dummy(OD_stream_t *stream, void *buf,
OD_size_t count, OD_size_t *countRead)
{
if (buf == NULL || stream == NULL || countRead == NULL) {
if ((buf == NULL) || (stream == NULL) || (countRead == NULL)) {
return ODR_DEV_INCOMPAT;
}
@ -102,7 +102,7 @@ static ODR_t PDOconfigMap(CO_PDO_common_t *PDO,
}
/* is there a reference to the dummy entry */
if (index < 0x20 && subIndex == 0) {
if ((index < 0x20) && (subIndex == 0)) {
OD_stream_t *stream = &OD_IO->stream;
(void)memset(stream, 0, sizeof(OD_stream_t));
stream->dataLength = stream->dataOffset = mappedLength;
@ -121,9 +121,9 @@ static ODR_t PDOconfigMap(CO_PDO_common_t *PDO,
/* verify access attributes, byte alignment and length */
OD_attr_t testAttribute = isRPDO ? ODA_RPDO : ODA_TPDO;
if ((OD_IOcopy.stream.attribute & testAttribute) == 0
|| (mappedLengthBits & 0x07) != 0
|| OD_IOcopy.stream.dataLength < mappedLength
if (((OD_IOcopy.stream.attribute & testAttribute) == 0)
|| ((mappedLengthBits & 0x07) != 0)
|| (OD_IOcopy.stream.dataLength < mappedLength)
) {
return ODR_NO_MAP; /* Object cannot be mapped to the PDO. */
}
@ -135,7 +135,7 @@ static ODR_t PDOconfigMap(CO_PDO_common_t *PDO,
/* get TPDO request flag byte from extension */
#if OD_FLAGS_PDO_SIZE > 0
if (!isRPDO) {
if (subIndex < (OD_FLAGS_PDO_SIZE * 8) && entry->extension != NULL) {
if ((subIndex < (OD_FLAGS_PDO_SIZE * 8)) && (entry->extension != NULL)) {
PDO->flagPDObyte[mapIndex] =
&entry->extension->flagsPDO[subIndex >> 3];
PDO->flagPDObitmask[mapIndex] = 1 << (subIndex & 0x07);
@ -208,8 +208,8 @@ static CO_ReturnError_t PDO_initMapping(CO_PDO_common_t *PDO,
pdoDataLength += OD_IO->stream.dataOffset;
}
}
if (pdoDataLength > CO_PDO_MAX_SIZE
|| (pdoDataLength == 0 && mappedObjectsCount > 0)
if ((pdoDataLength > CO_PDO_MAX_SIZE)
|| ((pdoDataLength == 0) && (mappedObjectsCount > 0))
) {
if (*erroneousMap == 0) { *erroneousMap = 1; }
}
@ -232,8 +232,8 @@ static ODR_t OD_write_PDO_mapping(OD_stream_t *stream, const void *buf,
OD_size_t count, OD_size_t *countWritten)
{
/* "count" is already verified in *_init() function */
if (stream == NULL || buf == NULL || countWritten == NULL
|| stream->subIndex > CO_PDO_MAX_MAPPED_ENTRIES
if ((stream == NULL) || (buf == NULL) || (countWritten == NULL)
|| (stream->subIndex > CO_PDO_MAX_MAPPED_ENTRIES)
) {
return ODR_DEV_INCOMPAT;
}
@ -242,7 +242,7 @@ static ODR_t OD_write_PDO_mapping(OD_stream_t *stream, const void *buf,
CO_PDO_common_t *PDO = stream->object;
/* PDO must be disabled before mapping configuration */
if (PDO->valid || (PDO->mappedObjectsCount != 0 && stream->subIndex > 0)) {
if ((PDO->valid) || ((PDO->mappedObjectsCount != 0) && (stream->subIndex > 0))) {
return ODR_UNSUPP_ACCESS;
}
@ -270,7 +270,7 @@ static ODR_t OD_write_PDO_mapping(OD_stream_t *stream, const void *buf,
if (pdoDataLength > CO_PDO_MAX_SIZE) {
return ODR_MAP_LEN;
}
if (pdoDataLength == 0 && mappedObjectsCount > 0) {
if ((pdoDataLength == 0) && (mappedObjectsCount > 0)) {
return ODR_INVALID_VALUE;
}
@ -416,14 +416,14 @@ static ODR_t OD_read_PDO_commParam(OD_stream_t *stream, void *buf,
ODR_t returnCode = OD_readOriginal(stream, buf, count, countRead);
/* When reading COB_ID, add Node-Id to the read value, if necessary */
if (returnCode == ODR_OK && stream->subIndex == 1 && *countRead == 4) {
if ((returnCode == ODR_OK) && (stream->subIndex == 1) && (*countRead == 4)) {
/* Only common part of the CO_RPDO_t or CO_TPDO_t will be used */
CO_PDO_common_t *PDO = stream->object;
uint32_t COB_ID = CO_getUint32(buf);
uint16_t CAN_ID = (uint16_t)(COB_ID & 0x7FF);
/* If default CAN-ID is stored in OD (without Node-ID), add Node-ID */
if (CAN_ID != 0 && CAN_ID == (PDO->preDefinedCanId & 0xFF80)) {
if ((CAN_ID != 0) && (CAN_ID == (PDO->preDefinedCanId & 0xFF80))) {
COB_ID = (COB_ID & 0xFFFF0000) | PDO->preDefinedCanId;
}
@ -483,7 +483,7 @@ static void CO_PDO_receive(void *object, void *msg) {
/* Determine, to which of the two rx buffers copy the message. */
uint8_t bufNo = 0;
#if (CO_CONFIG_PDO) & CO_CONFIG_PDO_SYNC_ENABLE
if (RPDO->synchronous && RPDO->SYNC != NULL
if (RPDO->synchronous && (RPDO->SYNC != NULL)
&& RPDO->SYNC->CANrxToggle
) {
bufNo = 1;
@ -522,7 +522,7 @@ static ODR_t OD_write_14xx(OD_stream_t *stream, const void *buf,
OD_size_t count, OD_size_t *countWritten)
{
/* "count" is also verified in *_init() function */
if (stream == NULL || buf == NULL || countWritten == NULL || count > 4) {
if ((stream == NULL) || (buf == NULL) || (countWritten == NULL) || (count > 4)) {
return ODR_DEV_INCOMPAT;
}
@ -540,16 +540,16 @@ static ODR_t OD_write_14xx(OD_stream_t *stream, const void *buf,
/* bits 11...29 must be zero, PDO must be disabled on change,
* CAN_ID == 0 is not allowed, mapping must be configured before
* enabling the PDO */
if ((COB_ID & 0x3FFFF800) != 0
|| (valid && PDO->valid && CAN_ID != PDO->configuredCanId)
if (((COB_ID & 0x3FFFF800) != 0)
|| (valid && PDO->valid && (CAN_ID != PDO->configuredCanId))
|| (valid && CO_IS_RESTRICTED_CAN_ID(CAN_ID))
|| (valid && PDO->mappedObjectsCount == 0)
|| (valid && (PDO->mappedObjectsCount == 0))
) {
return ODR_INVALID_VALUE;
}
/* parameter changed? */
if (valid != PDO->valid || CAN_ID != PDO->configuredCanId) {
if ((valid != PDO->valid) || (CAN_ID != PDO->configuredCanId)) {
/* if default CAN-ID is written, store to OD without Node-ID */
if (CAN_ID == PDO->preDefinedCanId) {
(void)CO_setUint32(bufCopy, COB_ID & 0xFFFFFF80);
@ -567,7 +567,7 @@ static ODR_t OD_write_14xx(OD_stream_t *stream, const void *buf,
(void*)RPDO, /* object passed to receive function */
CO_PDO_receive); /* this function will process rx msg */
if (valid && ret == CO_ERROR_NO) {
if (valid && (ret == CO_ERROR_NO)) {
PDO->valid = true;
PDO->configuredCanId = CAN_ID;
}
@ -588,8 +588,8 @@ 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 > CO_PDO_TRANSM_TYPE_SYNC_240)
&& (transmissionType < CO_PDO_TRANSM_TYPE_SYNC_EVENT_LO)
) {
return ODR_INVALID_VALUE;
}
@ -647,8 +647,8 @@ CO_ReturnError_t CO_RPDO_init(CO_RPDO_t *RPDO,
ODR_t odRet;
/* verify arguments */
if (RPDO == NULL || OD == NULL || em == NULL || OD_14xx_RPDOCommPar == NULL
|| OD_16xx_RPDOMapPar == NULL || CANdevRx == NULL
if ((RPDO == NULL) || (OD == NULL) || (em == NULL) || (OD_14xx_RPDOCommPar == NULL)
|| (OD_16xx_RPDOMapPar == NULL) || (CANdevRx == NULL)
) {
return CO_ERROR_ILLEGAL_ARGUMENT;
}
@ -685,7 +685,7 @@ CO_ReturnError_t CO_RPDO_init(CO_RPDO_t *RPDO,
bool_t valid = (COB_ID & 0x80000000) == 0;
uint16_t CAN_ID = (uint16_t)(COB_ID & 0x7FF);
if (valid && (PDO->mappedObjectsCount == 0 || CAN_ID == 0)) {
if (valid && ((PDO->mappedObjectsCount == 0) || (CAN_ID == 0))) {
valid = false;
if (erroneousMap == 0) { erroneousMap = 1; }
}
@ -693,14 +693,14 @@ CO_ReturnError_t CO_RPDO_init(CO_RPDO_t *RPDO,
if (erroneousMap != 0) {
CO_errorReport(PDO->em,
CO_EM_PDO_WRONG_MAPPING, CO_EMC_PROTOCOL_ERROR,
erroneousMap != 1 ? erroneousMap : COB_ID);
(erroneousMap != 1) ? erroneousMap : COB_ID);
}
if (!valid) {
CAN_ID = 0;
}
/* If default CAN-ID is stored in OD (without Node-ID), add Node-ID */
if (CAN_ID != 0 && CAN_ID == (preDefinedCanId & 0xFF80)) {
if ((CAN_ID != 0) && (CAN_ID == (preDefinedCanId & 0xFF80))) {
CAN_ID = preDefinedCanId;
}
@ -797,7 +797,7 @@ void CO_RPDO_process(CO_RPDO_t *RPDO,
/* 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
uint16_t code = (RPDO->receiveError == 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);
@ -808,7 +808,7 @@ 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
if (RPDO->synchronous && (RPDO->SYNC != NULL)
&& !RPDO->SYNC->CANrxToggle) {
bufNo = 1;
}
@ -894,8 +894,8 @@ void CO_RPDO_process(CO_RPDO_t *RPDO,
/* enable monitoring */
RPDO->timeoutTimer = 1;
}
else if (RPDO->timeoutTimer > 0
&& RPDO->timeoutTimer < RPDO->timeoutTime_us
else if ((RPDO->timeoutTimer > 0)
&& (RPDO->timeoutTimer < RPDO->timeoutTime_us)
) {
RPDO->timeoutTimer += timeDifference_us;
@ -953,7 +953,7 @@ static ODR_t OD_write_18xx(OD_stream_t *stream, const void *buf,
OD_size_t count, OD_size_t *countWritten)
{
/* "count" is also verified in *_init() function */
if (stream == NULL || buf == NULL || countWritten == NULL || count > 4) {
if ((stream == NULL) || (buf == NULL) || (countWritten == NULL) || (count > 4)) {
return ODR_DEV_INCOMPAT;
}
@ -971,16 +971,16 @@ static ODR_t OD_write_18xx(OD_stream_t *stream, const void *buf,
/* bits 11...29 must be zero, PDO must be disabled on change,
* CAN_ID == 0 is not allowed, mapping must be configured before
* enabling the PDO */
if ((COB_ID & 0x3FFFF800) != 0
|| (valid && PDO->valid && CAN_ID != PDO->configuredCanId)
if (((COB_ID & 0x3FFFF800) != 0)
|| (valid && (PDO->valid && (CAN_ID != PDO->configuredCanId)))
|| (valid && CO_IS_RESTRICTED_CAN_ID(CAN_ID))
|| (valid && PDO->mappedObjectsCount == 0)
|| (valid && (PDO->mappedObjectsCount == 0))
) {
return ODR_INVALID_VALUE;
}
/* parameter changed? */
if (valid != PDO->valid || CAN_ID != PDO->configuredCanId) {
if ((valid != PDO->valid) || (CAN_ID != PDO->configuredCanId)) {
/* if default CAN-ID is written, store to OD without Node-ID */
if (CAN_ID == PDO->preDefinedCanId) {
(void)CO_setUint32(bufCopy, COB_ID & 0xFFFFFF80);
@ -1012,8 +1012,8 @@ 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 > CO_PDO_TRANSM_TYPE_SYNC_240)
&& (transmissionType < CO_PDO_TRANSM_TYPE_SYNC_EVENT_LO)
) {
return ODR_INVALID_VALUE;
}
@ -1056,7 +1056,7 @@ static ODR_t OD_write_18xx(OD_stream_t *stream, const void *buf,
case 6: { /* SYNC start value */
uint8_t syncStartValue = CO_getUint8(buf);
if (PDO->valid || syncStartValue > 240) {
if (PDO->valid || (syncStartValue > 240)) {
return ODR_INVALID_VALUE;
}
TPDO->syncStartValue = syncStartValue;
@ -1092,8 +1092,8 @@ CO_ReturnError_t CO_TPDO_init(CO_TPDO_t *TPDO,
ODR_t odRet;
/* verify arguments */
if (TPDO == NULL || OD == NULL || em == NULL || OD_18xx_TPDOCommPar == NULL
|| OD_1Axx_TPDOMapPar == NULL || CANdevTx == NULL
if ((TPDO == NULL) || (OD == NULL) || (em == NULL) || (OD_18xx_TPDOCommPar == NULL)
|| (OD_1Axx_TPDOMapPar == NULL) || (CANdevTx == NULL)
) {
return CO_ERROR_ILLEGAL_ARGUMENT;
}
@ -1127,9 +1127,9 @@ CO_ReturnError_t CO_TPDO_init(CO_TPDO_t *TPDO,
}
return CO_ERROR_OD_PARAMETERS;
}
if (transmissionType < CO_PDO_TRANSM_TYPE_SYNC_EVENT_LO
if ((transmissionType < CO_PDO_TRANSM_TYPE_SYNC_EVENT_LO)
#if (CO_CONFIG_PDO) & CO_CONFIG_PDO_SYNC_ENABLE
&& transmissionType > CO_PDO_TRANSM_TYPE_SYNC_240
&& (transmissionType > CO_PDO_TRANSM_TYPE_SYNC_240)
#endif
) {
transmissionType = CO_PDO_TRANSM_TYPE_SYNC_EVENT_LO;
@ -1149,7 +1149,7 @@ CO_ReturnError_t CO_TPDO_init(CO_TPDO_t *TPDO,
bool_t valid = (COB_ID & 0x80000000) == 0;
uint16_t CAN_ID = (uint16_t)(COB_ID & 0x7FF);
if (valid && (PDO->mappedObjectsCount == 0 || CAN_ID == 0)) {
if (valid && ((PDO->mappedObjectsCount == 0) || (CAN_ID == 0))) {
valid = false;
if (erroneousMap == 0) { erroneousMap = 1; }
}
@ -1157,14 +1157,14 @@ CO_ReturnError_t CO_TPDO_init(CO_TPDO_t *TPDO,
if (erroneousMap != 0) {
CO_errorReport(PDO->em,
CO_EM_PDO_WRONG_MAPPING, CO_EMC_PROTOCOL_ERROR,
erroneousMap != 1 ? erroneousMap : COB_ID);
(erroneousMap != 1) ? erroneousMap : COB_ID);
}
if (!valid) {
CAN_ID = 0;
}
/* If default CAN-ID is stored in OD (without Node-ID), add Node-ID */
if (CAN_ID != 0 && CAN_ID == (preDefinedCanId & 0xFF80)) {
if ((CAN_ID != 0) && (CAN_ID == (preDefinedCanId & 0xFF80))) {
CAN_ID = preDefinedCanId;
}
@ -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 == CO_PDO_TRANSM_TYPE_SYNC_ACYCLIC)
|| (TPDO->transmissionType >= CO_PDO_TRANSM_TYPE_SYNC_EVENT_LO));
#endif
#if (CO_CONFIG_PDO) & CO_CONFIG_PDO_OD_IO_ACCESS
@ -1295,7 +1295,7 @@ static CO_ReturnError_t CO_TPDOsend(CO_TPDO_t *TPDO) {
/* In event driven TPDO indicate transmission of OD variable */
#if OD_FLAGS_PDO_SIZE > 0
uint8_t *flagPDObyte = PDO->flagPDObyte[i];
if (flagPDObyte != NULL && eventDriven) {
if ((flagPDObyte != NULL) && eventDriven) {
*flagPDObyte |= PDO->flagPDObitmask[i];
}
#endif
@ -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 == CO_PDO_TRANSM_TYPE_SYNC_ACYCLIC)
|| (TPDO->transmissionType >= CO_PDO_TRANSM_TYPE_SYNC_EVENT_LO)
) {
/* event timer */
#if (CO_CONFIG_PDO) & CO_CONFIG_TPDO_TIMERS_ENABLE
@ -1388,7 +1388,7 @@ void CO_TPDO_process(CO_TPDO_t *TPDO,
? (TPDO->inhibitTimer - timeDifference_us) : 0;
/* send TPDO */
if (TPDO->sendRequest && TPDO->inhibitTimer == 0) {
if (TPDO->sendRequest && (TPDO->inhibitTimer == 0)) {
CO_TPDOsend(TPDO);
}
@ -1409,7 +1409,7 @@ void CO_TPDO_process(CO_TPDO_t *TPDO,
/* Synchronous PDOs */
#if (CO_CONFIG_PDO) & CO_CONFIG_PDO_SYNC_ENABLE
else if (TPDO->SYNC != NULL && syncWas) {
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); }
@ -1418,15 +1418,15 @@ void CO_TPDO_process(CO_TPDO_t *TPDO,
else {
/* is the start of synchronous TPDO transmission */
if (TPDO->syncCounter == 255) {
if (TPDO->SYNC->counterOverflowValue != 0
&& TPDO->syncStartValue != 0
if ((TPDO->SYNC->counterOverflowValue != 0)
&& (TPDO->syncStartValue != 0)
) {
/* syncStartValue is in use */
TPDO->syncCounter = 254;
}
else {
/* Send first TPDO somewhere in the middle */
TPDO->syncCounter = TPDO->transmissionType / 2 + 1;
TPDO->syncCounter = (TPDO->transmissionType / 2) + 1;
}
}
/* If the syncStartValue is in use, start first TPDO after SYNC

162
301/CO_SDOclient.c
View file

@ -67,13 +67,13 @@ static void CO_SDOclient_receive(void *object, void *msg) {
/* Ignore messages in idle state and messages with wrong length. Ignore
* message also if previous message was not processed yet and not abort */
if (SDO_C->state != CO_SDO_ST_IDLE && DLC == 8U
&& (!CO_FLAG_READ(SDO_C->CANrxNew) || data[0] == 0x80)
if ((SDO_C->state != CO_SDO_ST_IDLE) && (DLC == 8U)
&& (!CO_FLAG_READ(SDO_C->CANrxNew) || (data[0] == 0x80))
) {
#if (CO_CONFIG_SDO_CLI) & CO_CONFIG_SDO_CLI_BLOCK
if (data[0] == 0x80 /* abort from server */
|| (SDO_C->state != CO_SDO_ST_UPLOAD_BLK_SUBBLOCK_SREQ
&& SDO_C->state != CO_SDO_ST_UPLOAD_BLK_SUBBLOCK_CRSP)
if ((data[0] == 0x80) /* abort from server */
|| ((SDO_C->state != CO_SDO_ST_UPLOAD_BLK_SUBBLOCK_SREQ)
&& (SDO_C->state != CO_SDO_ST_UPLOAD_BLK_SUBBLOCK_CRSP))
) {
#endif
/* copy data and set 'new message' flag */
@ -97,8 +97,8 @@ static void CO_SDOclient_receive(void *object, void *msg) {
SDO_C->block_timeoutTimer = 0;
/* verify if sequence number is correct */
if (seqno <= SDO_C->block_blksize
&& seqno == (SDO_C->block_seqno + 1)
if ((seqno <= SDO_C->block_blksize)
&& (seqno == (SDO_C->block_seqno + 1))
) {
SDO_C->block_seqno = seqno;
@ -127,7 +127,7 @@ static void CO_SDOclient_receive(void *object, void *msg) {
/* If message is duplicate or sequence didn't start yet, ignore
* it. Otherwise seqno is wrong, so break sub-block. Data after
* last good seqno will be re-transmitted. */
else if (seqno != SDO_C->block_seqno && SDO_C->block_seqno != 0U) {
else if ((seqno != SDO_C->block_seqno) && (SDO_C->block_seqno != 0U)) {
state = CO_SDO_ST_UPLOAD_BLK_SUBBLOCK_CRSP;
#ifdef CO_DEBUG_SDO_CLIENT
char msg[80];
@ -177,7 +177,7 @@ static ODR_t OD_write_1280(OD_stream_t *stream, const void *buf,
OD_size_t count, OD_size_t *countWritten)
{
/* "count" is already verified in *_init() function */
if (stream == NULL || buf == NULL || countWritten == NULL) {
if ((stream == NULL) || (buf == NULL) || (countWritten == NULL)) {
return ODR_DEV_INCOMPAT;
}
@ -194,8 +194,8 @@ static ODR_t OD_write_1280(OD_stream_t *stream, const void *buf,
bool_t valid = (COB_ID & 0x80000000) == 0;
/* SDO client must not be valid when changing COB_ID */
if ((COB_ID & 0x3FFFF800) != 0
|| (valid && SDO_C->valid && CAN_ID != CAN_ID_cur)
if (((COB_ID & 0x3FFFF800) != 0)
|| (valid && SDO_C->valid && (CAN_ID != CAN_ID_cur))
|| (valid && CO_IS_RESTRICTED_CAN_ID(CAN_ID))
) {
return ODR_INVALID_VALUE;
@ -214,8 +214,8 @@ static ODR_t OD_write_1280(OD_stream_t *stream, const void *buf,
bool_t valid = (COB_ID & 0x80000000) == 0;
/* SDO client must not be valid when changing COB_ID */
if ((COB_ID & 0x3FFFF800) != 0
|| (valid && SDO_C->valid && CAN_ID != CAN_ID_cur)
if (((COB_ID & 0x3FFFF800) != 0)
|| (valid && SDO_C->valid && (CAN_ID != CAN_ID_cur))
|| (valid && CO_IS_RESTRICTED_CAN_ID(CAN_ID))
) {
return ODR_INVALID_VALUE;
@ -258,10 +258,10 @@ CO_ReturnError_t CO_SDOclient_init(CO_SDOclient_t *SDO_C,
uint32_t *errInfo)
{
/* verify arguments */
if (SDO_C == NULL || OD_1280_SDOcliPar == NULL
|| OD_getIndex(OD_1280_SDOcliPar) < OD_H1280_SDO_CLIENT_1_PARAM
|| OD_getIndex(OD_1280_SDOcliPar) > (OD_H1280_SDO_CLIENT_1_PARAM + 0x7F)
|| CANdevRx==NULL || CANdevTx==NULL
if ((SDO_C == NULL) || (OD_1280_SDOcliPar == NULL)
|| (OD_getIndex(OD_1280_SDOcliPar) < OD_H1280_SDO_CLIENT_1_PARAM)
|| (OD_getIndex(OD_1280_SDOcliPar) > (OD_H1280_SDO_CLIENT_1_PARAM + 0x7F))
|| (CANdevRx==NULL) || (CANdevTx==NULL)
) {
return CO_ERROR_ILLEGAL_ARGUMENT;
}
@ -292,8 +292,8 @@ CO_ReturnError_t CO_SDOclient_init(CO_SDOclient_t *SDO_C,
ODR_t odRet2 = OD_get_u32(OD_1280_SDOcliPar, 2, &COB_IDServerToClient, true);
ODR_t odRet3 = OD_get_u8(OD_1280_SDOcliPar, 3, &nodeIDOfTheSDOServer, true);
if (odRet0 != ODR_OK || maxSubIndex != 3
|| odRet1 != ODR_OK || odRet2 != ODR_OK || odRet3 != ODR_OK
if ((odRet0 != ODR_OK) || (maxSubIndex != 3)
|| (odRet1 != ODR_OK) || (odRet2 != ODR_OK) || (odRet3 != ODR_OK)
) {
if (errInfo != NULL) *errInfo = OD_getIndex(OD_1280_SDOcliPar);
return CO_ERROR_OD_PARAMETERS;
@ -373,8 +373,8 @@ CO_SDO_return_t CO_SDOclient_setup(CO_SDOclient_t *SDO_C,
#if (CO_CONFIG_SDO_CLI) & CO_CONFIG_FLAG_OD_DYNAMIC
/* proceed only, if parameters change */
if (COB_IDClientToServer == SDO_C->COB_IDClientToServer
&& COB_IDServerToClient == SDO_C->COB_IDServerToClient
if ((COB_IDClientToServer == SDO_C->COB_IDClientToServer)
&& (COB_IDServerToClient == SDO_C->COB_IDServerToClient)
) {
return CO_SDO_RT_ok_communicationEnd;
}
@ -388,7 +388,7 @@ CO_SDO_return_t CO_SDOclient_setup(CO_SDOclient_t *SDO_C,
(uint16_t)(COB_IDClientToServer & 0x7FF) : 0;
uint16_t CanIdS2C = ((COB_IDServerToClient & 0x80000000L) == 0) ?
(uint16_t)(COB_IDServerToClient & 0x7FF) : 0;
if (CanIdC2S != 0 && CanIdS2C != 0) {
if ((CanIdC2S != 0) && (CanIdS2C != 0)) {
SDO_C->valid = true;
}
else {
@ -417,7 +417,7 @@ CO_SDO_return_t CO_SDOclient_setup(CO_SDOclient_t *SDO_C,
0); /* synchronous message flag bit */
if (ret != CO_ERROR_NO || SDO_C->CANtxBuff == NULL) {
if ((ret != CO_ERROR_NO) || (SDO_C->CANtxBuff == NULL)) {
SDO_C->valid = false;
return CO_SDO_RT_wrongArguments;
}
@ -437,7 +437,7 @@ CO_SDO_return_t CO_SDOclientDownloadInitiate(CO_SDOclient_t *SDO_C,
bool_t blockEnable)
{
/* verify parameters */
if (SDO_C == NULL || !SDO_C->valid) {
if ((SDO_C == NULL) || !SDO_C->valid) {
return CO_SDO_RT_wrongArguments;
}
@ -454,8 +454,8 @@ CO_SDO_return_t CO_SDOclientDownloadInitiate(CO_SDOclient_t *SDO_C,
#if (CO_CONFIG_SDO_CLI) & CO_CONFIG_SDO_CLI_LOCAL
/* if node-ID of the SDO server is the same as node-ID of this node, then
* transfer data within this node */
if (SDO_C->OD != NULL && SDO_C->nodeId != 0
&& SDO_C->nodeIDOfTheSDOServer == SDO_C->nodeId
if ((SDO_C->OD != NULL) && (SDO_C->nodeId != 0)
&& (SDO_C->nodeIDOfTheSDOServer == SDO_C->nodeId)
) {
SDO_C->OD_IO.write = NULL;
SDO_C->state = CO_SDO_ST_DOWNLOAD_LOCAL_TRANSFER;
@ -463,8 +463,8 @@ CO_SDO_return_t CO_SDOclientDownloadInitiate(CO_SDOclient_t *SDO_C,
else
#endif
#if (CO_CONFIG_SDO_CLI) & CO_CONFIG_SDO_CLI_BLOCK
if (blockEnable && (sizeIndicated == 0 ||
sizeIndicated > CO_CONFIG_SDO_CLI_PST)
if (blockEnable && ((sizeIndicated == 0) ||
(sizeIndicated > CO_CONFIG_SDO_CLI_PST))
) {
SDO_C->state = CO_SDO_ST_DOWNLOAD_BLK_INITIATE_REQ;
}
@ -486,8 +486,8 @@ void CO_SDOclientDownloadInitiateSize(CO_SDOclient_t *SDO_C,
if (SDO_C != NULL) {
SDO_C->sizeInd = sizeIndicated;
#if (CO_CONFIG_SDO_CLI) & CO_CONFIG_SDO_CLI_BLOCK
if (SDO_C->state == CO_SDO_ST_DOWNLOAD_BLK_INITIATE_REQ
&& sizeIndicated > 0 && sizeIndicated <= CO_CONFIG_SDO_CLI_PST
if ((SDO_C->state == CO_SDO_ST_DOWNLOAD_BLK_INITIATE_REQ)
&& (sizeIndicated > 0) && (sizeIndicated <= CO_CONFIG_SDO_CLI_PST)
) {
SDO_C->state = CO_SDO_ST_DOWNLOAD_INITIATE_REQ;
}
@ -502,7 +502,7 @@ size_t CO_SDOclientDownloadBufWrite(CO_SDOclient_t *SDO_C,
size_t count)
{
size_t ret = 0;
if (SDO_C != NULL && buf != NULL) {
if ((SDO_C != NULL) && (buf != NULL)) {
ret = CO_fifo_write(&SDO_C->bufFifo, buf, count, NULL);
}
return ret;
@ -523,7 +523,7 @@ CO_SDO_return_t CO_SDOclientDownload(CO_SDOclient_t *SDO_C,
CO_SDO_return_t ret = CO_SDO_RT_waitingResponse;
CO_SDO_abortCode_t abortCode = CO_SDO_AB_NONE;
if (SDO_C == NULL || !SDO_C->valid) {
if ((SDO_C == NULL) || !SDO_C->valid) {
abortCode = CO_SDO_AB_DEVICE_INCOMPAT;
ret = CO_SDO_RT_wrongArguments;
}
@ -532,7 +532,7 @@ CO_SDO_return_t CO_SDOclientDownload(CO_SDOclient_t *SDO_C,
}
#if (CO_CONFIG_SDO_CLI) & CO_CONFIG_SDO_CLI_LOCAL
/* Transfer data locally **************************************************/
else if (SDO_C->state == CO_SDO_ST_DOWNLOAD_LOCAL_TRANSFER && !abort) {
else if ((SDO_C->state == CO_SDO_ST_DOWNLOAD_LOCAL_TRANSFER) && !abort) {
/* search object dictionary in first pass */
if (SDO_C->OD_IO.write == NULL) {
ODR_t odRet;
@ -571,14 +571,14 @@ CO_SDO_return_t CO_SDOclientDownload(CO_SDOclient_t *SDO_C,
ret = CO_SDO_RT_endedWithClientAbort;
}
/* verify if sizeTran is too large */
else if (SDO_C->sizeInd > 0 && SDO_C->sizeTran > SDO_C->sizeInd) {
else if ((SDO_C->sizeInd > 0) && (SDO_C->sizeTran > SDO_C->sizeInd)) {
SDO_C->sizeTran -= count;
abortCode = CO_SDO_AB_DATA_LONG;
ret = CO_SDO_RT_endedWithClientAbort;
}
/* Verify sizeTran is too small in last segment of data */
else if (!bufferPartial
&& SDO_C->sizeInd > 0 && SDO_C->sizeTran < SDO_C->sizeInd
&& (SDO_C->sizeInd > 0) && (SDO_C->sizeTran < SDO_C->sizeInd)
) {
abortCode = CO_SDO_AB_DATA_SHORT;
ret = CO_SDO_RT_endedWithClientAbort;
@ -597,12 +597,12 @@ CO_SDO_return_t CO_SDOclientDownload(CO_SDOclient_t *SDO_C,
* shorter than size of OD data buffer. If so, add two zero
* bytes to terminate (unicode) string. Shorten also OD data
* size, (temporary, send info about EOF into OD_IO.write) */
if ((SDO_C->OD_IO.stream.attribute & ODA_STR) != 0
&& (sizeInOd == 0 || SDO_C->sizeTran < sizeInOd)
if (((SDO_C->OD_IO.stream.attribute & ODA_STR) != 0)
&& ((sizeInOd == 0) || (SDO_C->sizeTran < sizeInOd))
) {
buf[count++] = 0;
SDO_C->sizeTran++;
if (sizeInOd == 0 || sizeInOd > SDO_C->sizeTran) {
if ((sizeInOd == 0) || (sizeInOd > SDO_C->sizeTran)) {
buf[count++] = 0;
SDO_C->sizeTran++;
}
@ -629,13 +629,13 @@ CO_SDO_return_t CO_SDOclientDownload(CO_SDOclient_t *SDO_C,
CO_UNLOCK_OD(SDO_C->CANdevTx);
/* verify for errors in write */
if (odRet != ODR_OK && odRet != ODR_PARTIAL) {
if ((odRet != ODR_OK) && (odRet != ODR_PARTIAL)) {
abortCode = (CO_SDO_abortCode_t)OD_getSDOabCode(odRet);
ret = CO_SDO_RT_endedWithServerAbort;
}
/* error if OD variable was written completely,
* but SDO download still has data */
else if (bufferPartial && odRet == ODR_OK) {
else if (bufferPartial && (odRet == ODR_OK)) {
abortCode = CO_SDO_AB_DATA_LONG;
ret = CO_SDO_RT_endedWithClientAbort;
}
@ -693,7 +693,7 @@ CO_SDO_return_t CO_SDOclientDownload(CO_SDOclient_t *SDO_C,
index = ((uint16_t) SDO_C->CANrxData[2]) << 8;
index |= SDO_C->CANrxData[1];
subindex = SDO_C->CANrxData[3];
if (index != SDO_C->index || subindex != SDO_C->subIndex) {
if ((index != SDO_C->index) || (subindex != SDO_C->subIndex)) {
abortCode = CO_SDO_AB_PRAM_INCOMPAT;
SDO_C->state = CO_SDO_ST_ABORT;
break;
@ -761,7 +761,7 @@ CO_SDO_return_t CO_SDOclientDownload(CO_SDOclient_t *SDO_C,
index = ((uint16_t) SDO_C->CANrxData[2]) << 8;
index |= SDO_C->CANrxData[1];
subindex = SDO_C->CANrxData[3];
if (index != SDO_C->index || subindex != SDO_C->subIndex) {
if ((index != SDO_C->index) || (subindex != SDO_C->subIndex)) {
abortCode = CO_SDO_AB_PRAM_INCOMPAT;
SDO_C->state = CO_SDO_ST_ABORT;
break;
@ -769,7 +769,7 @@ CO_SDO_return_t CO_SDOclientDownload(CO_SDOclient_t *SDO_C,
SDO_C->block_crc = 0;
SDO_C->block_blksize = SDO_C->CANrxData[4];
if (SDO_C->block_blksize < 1 || SDO_C->block_blksize > 127)
if ((SDO_C->block_blksize < 1) || (SDO_C->block_blksize > 127))
SDO_C->block_blksize = 127;
SDO_C->block_seqno = 0;
CO_fifo_altBegin(&SDO_C->bufFifo, 0);
@ -791,7 +791,7 @@ CO_SDO_return_t CO_SDOclientDownload(CO_SDOclient_t *SDO_C,
* Re-transmit data after erroneous segment. */
size_t cntFailed = SDO_C->block_seqno
- SDO_C->CANrxData[1];
cntFailed = cntFailed * 7 - SDO_C->block_noData;
cntFailed = (cntFailed * 7) - SDO_C->block_noData;
SDO_C->sizeTran -= cntFailed;
CO_fifo_altBegin(&SDO_C->bufFifo,
(size_t)SDO_C->CANrxData[1] * 7);
@ -892,14 +892,14 @@ CO_SDO_return_t CO_SDOclientDownload(CO_SDOclient_t *SDO_C,
count = CO_fifo_getOccupied(&SDO_C->bufFifo);
/* is expedited transfer, <= 4bytes of data */
if ((SDO_C->sizeInd == 0 && count <= 4)
|| (SDO_C->sizeInd > 0 && SDO_C->sizeInd <= 4)
if (((SDO_C->sizeInd == 0) && (count <= 4))
|| ((SDO_C->sizeInd > 0) && (SDO_C->sizeInd <= 4))
) {
SDO_C->CANtxBuff->data[0] |= 0x02;
/* verify length, indicate data size */
if (count == 0 || (SDO_C->sizeInd > 0 &&
SDO_C->sizeInd != count)
if ((count == 0) || ((SDO_C->sizeInd > 0) &&
(SDO_C->sizeInd != count))
) {
SDO_C->state = CO_SDO_ST_IDLE;
abortCode = CO_SDO_AB_TYPE_MISMATCH;
@ -948,7 +948,7 @@ CO_SDO_return_t CO_SDOclientDownload(CO_SDOclient_t *SDO_C,
/* verify if sizeTran is too large */
SDO_C->sizeTran += count;
if (SDO_C->sizeInd > 0 && SDO_C->sizeTran > SDO_C->sizeInd) {
if ((SDO_C->sizeInd > 0) && (SDO_C->sizeTran > SDO_C->sizeInd)) {
SDO_C->sizeTran -= count;
abortCode = CO_SDO_AB_DATA_LONG;
SDO_C->state = CO_SDO_ST_ABORT;
@ -959,8 +959,8 @@ CO_SDO_return_t CO_SDOclientDownload(CO_SDOclient_t *SDO_C,
SDO_C->CANtxBuff->data[0] = (uint8_t)(SDO_C->toggle | ((7 - count) << 1));
/* is end of transfer? Verify also sizeTran */
if (CO_fifo_getOccupied(&SDO_C->bufFifo) == 0 && !bufferPartial) {
if (SDO_C->sizeInd > 0 && SDO_C->sizeTran < SDO_C->sizeInd) {
if ((CO_fifo_getOccupied(&SDO_C->bufFifo) == 0) && !bufferPartial) {
if ((SDO_C->sizeInd > 0) && (SDO_C->sizeTran < SDO_C->sizeInd)) {
abortCode = CO_SDO_AB_DATA_SHORT;
SDO_C->state = CO_SDO_ST_ABORT;
break;
@ -999,7 +999,7 @@ CO_SDO_return_t CO_SDOclientDownload(CO_SDOclient_t *SDO_C,
}
case CO_SDO_ST_DOWNLOAD_BLK_SUBBLOCK_REQ: {
if (CO_fifo_altGetOccupied(&SDO_C->bufFifo) < 7 && bufferPartial) {
if ((CO_fifo_altGetOccupied(&SDO_C->bufFifo) < 7) && bufferPartial) {
/* wait until data are refilled */
break;
}
@ -1012,7 +1012,7 @@ CO_SDO_return_t CO_SDOclientDownload(CO_SDOclient_t *SDO_C,
/* verify if sizeTran is too large */
SDO_C->sizeTran += count;
if (SDO_C->sizeInd > 0 && SDO_C->sizeTran > SDO_C->sizeInd) {
if ((SDO_C->sizeInd > 0) && (SDO_C->sizeTran > SDO_C->sizeInd)) {
SDO_C->sizeTran -= count;
abortCode = CO_SDO_AB_DATA_LONG;
SDO_C->state = CO_SDO_ST_ABORT;
@ -1020,8 +1020,8 @@ CO_SDO_return_t CO_SDOclientDownload(CO_SDOclient_t *SDO_C,
}
/* is end of transfer? Verify also sizeTran */
if (CO_fifo_altGetOccupied(&SDO_C->bufFifo) == 0 && !bufferPartial){
if (SDO_C->sizeInd > 0 && SDO_C->sizeTran < SDO_C->sizeInd) {
if ((CO_fifo_altGetOccupied(&SDO_C->bufFifo) == 0) && !bufferPartial){
if ((SDO_C->sizeInd > 0) && (SDO_C->sizeTran < SDO_C->sizeInd)) {
abortCode = CO_SDO_AB_DATA_SHORT;
SDO_C->state = CO_SDO_ST_ABORT;
break;
@ -1109,7 +1109,7 @@ CO_SDO_return_t CO_SDOclientUploadInitiate(CO_SDOclient_t *SDO_C,
bool_t blockEnable)
{
/* verify parameters */
if (SDO_C == NULL || !SDO_C->valid) {
if ((SDO_C == NULL) || !SDO_C->valid) {
return CO_SDO_RT_wrongArguments;
}
@ -1129,8 +1129,8 @@ CO_SDO_return_t CO_SDOclientUploadInitiate(CO_SDOclient_t *SDO_C,
#if (CO_CONFIG_SDO_CLI) & CO_CONFIG_SDO_CLI_LOCAL
/* if node-ID of the SDO server is the same as node-ID of this node, then
* transfer data within this node */
if (SDO_C->OD != NULL && SDO_C->nodeId != 0
&& SDO_C->nodeIDOfTheSDOServer == SDO_C->nodeId
if (((SDO_C->OD != NULL) && (SDO_C->nodeId != 0))
&& (SDO_C->nodeIDOfTheSDOServer == SDO_C->nodeId)
) {
SDO_C->OD_IO.read = NULL;
SDO_C->state = CO_SDO_ST_UPLOAD_LOCAL_TRANSFER;
@ -1167,7 +1167,7 @@ CO_SDO_return_t CO_SDOclientUpload(CO_SDOclient_t *SDO_C,
CO_SDO_return_t ret = CO_SDO_RT_waitingResponse;
CO_SDO_abortCode_t abortCode = CO_SDO_AB_NONE;
if (SDO_C == NULL || !SDO_C->valid) {
if ((SDO_C == NULL) || !SDO_C->valid) {
abortCode = CO_SDO_AB_DEVICE_INCOMPAT;
ret = CO_SDO_RT_wrongArguments;
}
@ -1176,7 +1176,7 @@ CO_SDO_return_t CO_SDOclientUpload(CO_SDOclient_t *SDO_C,
}
#if (CO_CONFIG_SDO_CLI) & CO_CONFIG_SDO_CLI_LOCAL
/* Transfer data locally **************************************************/
else if (SDO_C->state == CO_SDO_ST_UPLOAD_LOCAL_TRANSFER && !abort) {
else if ((SDO_C->state == CO_SDO_ST_UPLOAD_LOCAL_TRANSFER) && !abort) {
/* search object dictionary in first pass */
if (SDO_C->OD_IO.read == NULL) {
ODR_t odRet;
@ -1213,7 +1213,7 @@ CO_SDO_return_t CO_SDOclientUpload(CO_SDOclient_t *SDO_C,
/* Get size of data in Object Dictionary. If size is not indicated
* use maximum SDO client buffer size. Prepare temp buffer. */
OD_size_t countData = SDO_C->OD_IO.stream.dataLength;
OD_size_t countBuf = (countData > 0 && countData <= countFifo)
OD_size_t countBuf = ((countData > 0) && (countData <= countFifo))
? countData : (OD_size_t)countFifo;
OD_size_t countRd = 0;
uint8_t buf[CO_CONFIG_SDO_CLI_BUFFER_SIZE + 1];
@ -1224,14 +1224,14 @@ CO_SDO_return_t CO_SDOclientUpload(CO_SDOclient_t *SDO_C,
buf, countBuf, &countRd);
CO_UNLOCK_OD(SDO_C->CANdevTx);
if (odRet != ODR_OK && odRet != ODR_PARTIAL) {
if ((odRet != ODR_OK) && (odRet != ODR_PARTIAL)) {
abortCode = (CO_SDO_abortCode_t)OD_getSDOabCode(odRet);
ret = CO_SDO_RT_endedWithServerAbort;
}
else {
/* if data is string, send only data up to null termination */
if (countRd > 0
&& (SDO_C->OD_IO.stream.attribute & ODA_STR) != 0
if ((countRd > 0)
&& ((SDO_C->OD_IO.stream.attribute & ODA_STR) != 0)
) {
buf[countRd] = 0; /* (buf is one byte larger) */
OD_size_t countStr = (OD_size_t)strlen((char *)buf);
@ -1250,14 +1250,14 @@ CO_SDO_return_t CO_SDOclientUpload(CO_SDOclient_t *SDO_C,
/* verify if size of data uploaded is too large */
SDO_C->sizeInd = SDO_C->OD_IO.stream.dataLength;
if (SDO_C->sizeInd > 0 && SDO_C->sizeTran > SDO_C->sizeInd) {
if ((SDO_C->sizeInd > 0) && (SDO_C->sizeTran > SDO_C->sizeInd)) {
abortCode = CO_SDO_AB_DATA_LONG;
ret = CO_SDO_RT_endedWithClientAbort;
}
/* If no more segments to be upload, finish */
else if (odRet == ODR_OK) {
/* verify size of data uploaded */
if (SDO_C->sizeInd > 0 && SDO_C->sizeTran < SDO_C->sizeInd){
if ((SDO_C->sizeInd > 0) && (SDO_C->sizeTran < SDO_C->sizeInd)){
abortCode = CO_SDO_AB_DATA_SHORT;
ret = CO_SDO_RT_endedWithClientAbort;
}
@ -1271,8 +1271,8 @@ CO_SDO_return_t CO_SDOclientUpload(CO_SDOclient_t *SDO_C,
}
}
if (ret != CO_SDO_RT_uploadDataBufferFull
&& ret != CO_SDO_RT_waitingLocalTransfer
if ((ret != CO_SDO_RT_uploadDataBufferFull)
&& (ret != CO_SDO_RT_waitingLocalTransfer)
) {
SDO_C->state = CO_SDO_ST_IDLE;
}
@ -1308,7 +1308,7 @@ CO_SDO_return_t CO_SDOclientUpload(CO_SDOclient_t *SDO_C,
index = ((uint16_t) SDO_C->CANrxData[2]) << 8;
index |= SDO_C->CANrxData[1];
subindex = SDO_C->CANrxData[3];
if (index != SDO_C->index || subindex != SDO_C->subIndex) {
if ((index != SDO_C->index) || (subindex != SDO_C->subIndex)) {
abortCode = CO_SDO_AB_PRAM_INCOMPAT;
SDO_C->state = CO_SDO_ST_ABORT;
break;
@ -1381,8 +1381,8 @@ CO_SDO_return_t CO_SDOclientUpload(CO_SDOclient_t *SDO_C,
}
/* verify if size of data uploaded is too large */
if (SDO_C->sizeInd > 0
&& SDO_C->sizeTran > SDO_C->sizeInd
if ((SDO_C->sizeInd > 0)
&& (SDO_C->sizeTran > SDO_C->sizeInd)
) {
abortCode = CO_SDO_AB_DATA_LONG;
SDO_C->state = CO_SDO_ST_ABORT;
@ -1392,8 +1392,8 @@ CO_SDO_return_t CO_SDOclientUpload(CO_SDOclient_t *SDO_C,
/* If no more segments to be upload, finish */
if (SDO_C->CANrxData[0] & 0x01) {
/* verify size of data uploaded */
if (SDO_C->sizeInd > 0
&& SDO_C->sizeTran < SDO_C->sizeInd
if ((SDO_C->sizeInd > 0)
&& (SDO_C->sizeTran < SDO_C->sizeInd)
) {
abortCode = CO_SDO_AB_DATA_SHORT;
SDO_C->state = CO_SDO_ST_ABORT;
@ -1436,7 +1436,7 @@ CO_SDO_return_t CO_SDOclientUpload(CO_SDOclient_t *SDO_C,
index = ((uint16_t) SDO_C->CANrxData[2]) << 8;
index |= SDO_C->CANrxData[1];
subindex = SDO_C->CANrxData[3];
if (index != SDO_C->index || subindex != SDO_C->subIndex) {
if ((index != SDO_C->index) || (subindex != SDO_C->subIndex)) {
abortCode = CO_SDO_AB_PRAM_INCOMPAT;
SDO_C->state = CO_SDO_ST_ABORT;
}
@ -1452,7 +1452,7 @@ CO_SDO_return_t CO_SDOclientUpload(CO_SDOclient_t *SDO_C,
index = ((uint16_t) SDO_C->CANrxData[2]) << 8;
index |= SDO_C->CANrxData[1];
subindex = SDO_C->CANrxData[3];
if (index != SDO_C->index || subindex != SDO_C->subIndex) {
if ((index != SDO_C->index) || (subindex != SDO_C->subIndex)) {
abortCode = CO_SDO_AB_PRAM_INCOMPAT;
SDO_C->state = CO_SDO_ST_ABORT;
break;
@ -1508,8 +1508,8 @@ CO_SDO_return_t CO_SDOclientUpload(CO_SDOclient_t *SDO_C,
SDO_C->sizeTran += 7 - noData;
/* verify length */
if (SDO_C->sizeInd > 0
&& SDO_C->sizeTran != SDO_C->sizeInd
if ((SDO_C->sizeInd > 0)
&& (SDO_C->sizeTran != SDO_C->sizeInd)
) {
abortCode = (SDO_C->sizeTran > SDO_C->sizeInd) ?
CO_SDO_AB_DATA_LONG : CO_SDO_AB_DATA_SHORT;
@ -1560,8 +1560,8 @@ CO_SDO_return_t CO_SDOclientUpload(CO_SDOclient_t *SDO_C,
SDO_C->timeoutTimer += timeDifference_us;
}
if (SDO_C->timeoutTimer >= SDO_C->SDOtimeoutTime_us) {
if (SDO_C->state == CO_SDO_ST_UPLOAD_SEGMENT_REQ ||
SDO_C->state == CO_SDO_ST_UPLOAD_BLK_SUBBLOCK_CRSP
if ((SDO_C->state == CO_SDO_ST_UPLOAD_SEGMENT_REQ) ||
(SDO_C->state == CO_SDO_ST_UPLOAD_BLK_SUBBLOCK_CRSP)
) {
/* application didn't empty buffer */
abortCode = CO_SDO_AB_GENERAL;
@ -1706,7 +1706,7 @@ CO_SDO_return_t CO_SDOclientUpload(CO_SDOclient_t *SDO_C,
}
else {
/* verify if size of data uploaded is too large */
if (SDO_C->sizeInd > 0 && SDO_C->sizeTran > SDO_C->sizeInd) {
if ((SDO_C->sizeInd > 0) && (SDO_C->sizeTran > SDO_C->sizeInd)) {
abortCode = CO_SDO_AB_DATA_LONG;
SDO_C->state = CO_SDO_ST_ABORT;
break;
@ -1819,7 +1819,7 @@ size_t CO_SDOclientUploadBufRead(CO_SDOclient_t *SDO_C,
size_t count)
{
size_t ret = 0;
if (SDO_C != NULL && buf != NULL) {
if ((SDO_C != NULL) && (buf != NULL)) {
ret = CO_fifo_read(&SDO_C->bufFifo, buf, count, NULL);
}
return ret;

98
301/CO_SDOserver.c
View file

@ -173,8 +173,8 @@ static CO_ReturnError_t CO_SDOserver_init_canRxTx(CO_SDOserver_t *SDO,
{
#if (CO_CONFIG_SDO_SRV) & CO_CONFIG_FLAG_OD_DYNAMIC
/* proceed only, if parameters change */
if (COB_IDClientToServer == SDO->COB_IDClientToServer
&& COB_IDServerToClient == SDO->COB_IDServerToClient
if ((COB_IDClientToServer == SDO->COB_IDClientToServer)
&& (COB_IDServerToClient == SDO->COB_IDServerToClient)
) {
return CO_ERROR_NO;
}
@ -188,7 +188,7 @@ static CO_ReturnError_t CO_SDOserver_init_canRxTx(CO_SDOserver_t *SDO,
(uint16_t)COB_IDClientToServer : 0;
uint16_t idS2C = ((COB_IDServerToClient & 0x80000000L) == 0) ?
(uint16_t)COB_IDServerToClient : 0;
if (idC2S != 0 && idS2C != 0) {
if ((idC2S != 0) && (idS2C != 0)) {
SDO->valid = true;
}
else {
@ -236,7 +236,7 @@ static ODR_t OD_write_1201_additional(OD_stream_t *stream, const void *buf,
OD_size_t count, OD_size_t *countWritten)
{
/* "count" is already verified in *_init() function */
if (stream == NULL || buf == NULL || countWritten == NULL) {
if ((stream == NULL) || (buf == NULL) || (countWritten == NULL)) {
return ODR_DEV_INCOMPAT;
}
@ -254,8 +254,8 @@ static ODR_t OD_write_1201_additional(OD_stream_t *stream, const void *buf,
bool_t valid = (COB_ID & 0x80000000) == 0;
/* SDO client must not be valid when changing COB_ID */
if ((COB_ID & 0x3FFFF800) != 0
|| (valid && SDO->valid && CAN_ID != CAN_ID_cur)
if (((COB_ID & 0x3FFFF800) != 0)
|| ((valid && SDO->valid) && (CAN_ID != CAN_ID_cur))
|| (valid && CO_IS_RESTRICTED_CAN_ID(CAN_ID))
) {
return ODR_INVALID_VALUE;
@ -276,8 +276,8 @@ static ODR_t OD_write_1201_additional(OD_stream_t *stream, const void *buf,
bool_t valid = (COB_ID & 0x80000000) == 0;
/* SDO client must not be valid when changing COB_ID */
if ((COB_ID & 0x3FFFF800) != 0
|| (valid && SDO->valid && CAN_ID != CAN_ID_cur)
if (((COB_ID & 0x3FFFF800) != 0)
|| (valid && (SDO->valid && (CAN_ID != CAN_ID_cur)))
|| (valid && CO_IS_RESTRICTED_CAN_ID(CAN_ID))
) {
return ODR_INVALID_VALUE;
@ -296,7 +296,7 @@ static ODR_t OD_write_1201_additional(OD_stream_t *stream, const void *buf,
return ODR_TYPE_MISMATCH;
}
uint8_t nodeId = CO_getUint8(buf);
if (nodeId < 1 || nodeId > 127) {
if ((nodeId < 1) || (nodeId > 127)) {
return ODR_INVALID_VALUE;
}
break;
@ -325,7 +325,7 @@ CO_ReturnError_t CO_SDOserver_init(CO_SDOserver_t *SDO,
uint32_t *errInfo)
{
/* verify arguments */
if (SDO == NULL || OD == NULL || CANdevRx == NULL || CANdevTx == NULL) {
if ((SDO == NULL) || (OD == NULL) || (CANdevRx == NULL) || (CANdevTx == NULL)) {
return CO_ERROR_ILLEGAL_ARGUMENT;
}
@ -350,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;
@ -361,7 +361,7 @@ 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) {
if ((nodeId < 1) || (nodeId > 127)) {
return CO_ERROR_ILLEGAL_ARGUMENT;
}
@ -372,8 +372,8 @@ CO_ReturnError_t CO_SDOserver_init(CO_SDOserver_t *SDO,
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 > OD_H1200_SDO_SERVER_1_PARAM)
&& (OD_SDOsrvParIdx <= (OD_H1200_SDO_SERVER_1_PARAM + 0x7F))
) {
/* configure additional SDO channel and SDO server parameters for it */
uint8_t maxSubIndex;
@ -386,8 +386,8 @@ CO_ReturnError_t CO_SDOserver_init(CO_SDOserver_t *SDO,
ODR_t odRet2 = OD_get_u32(OD_1200_SDOsrvPar, 2,
&COB_IDServerToClient32, true);
if (odRet0 != ODR_OK || (maxSubIndex != 2 && maxSubIndex != 3)
|| odRet1 != ODR_OK || odRet2 != ODR_OK
if ((odRet0 != ODR_OK) || ((maxSubIndex != 2) && (maxSubIndex != 3))
|| (odRet1 != ODR_OK) || (odRet2 != ODR_OK)
) {
if (errInfo != NULL) { *errInfo = OD_SDOsrvParIdx; }
return CO_ERROR_OD_PARAMETERS;
@ -485,7 +485,7 @@ static bool_t validateAndWriteToOD(CO_SDOserver_t *SDO,
if (SDO->finished) {
/* Verify if size of data downloaded matches size indicated. */
if (SDO->sizeInd > 0 && SDO->sizeTran != SDO->sizeInd) {
if ((SDO->sizeInd > 0) && (SDO->sizeTran != SDO->sizeInd)) {
*abortCode = (SDO->sizeTran > SDO->sizeInd) ?
CO_SDO_AB_DATA_LONG : CO_SDO_AB_DATA_SHORT;
SDO->state = CO_SDO_ST_ABORT;
@ -505,13 +505,13 @@ static bool_t validateAndWriteToOD(CO_SDOserver_t *SDO,
* shorter than size of OD data buffer. If so, add two zero bytes
* to terminate (unicode) string. Shorten also OD data size,
* (temporary, send information about EOF into OD_IO.write) */
if ((SDO->OD_IO.stream.attribute & ODA_STR) != 0
&& (sizeInOd == 0 || SDO->sizeTran < sizeInOd)
&& (SDO->bufOffsetWr + 2) <= CO_CONFIG_SDO_SRV_BUFFER_SIZE
if (((SDO->OD_IO.stream.attribute & ODA_STR) != 0)
&& ((sizeInOd == 0) || (SDO->sizeTran < sizeInOd))
&& ((SDO->bufOffsetWr + 2) <= CO_CONFIG_SDO_SRV_BUFFER_SIZE)
) {
SDO->buf[SDO->bufOffsetWr++] = 0;
SDO->sizeTran++;
if (sizeInOd == 0 || SDO->sizeTran < sizeInOd) {
if ((sizeInOd == 0) || (SDO->sizeTran < sizeInOd)) {
SDO->buf[SDO->bufOffsetWr++] = 0;
SDO->sizeTran++;
}
@ -532,7 +532,7 @@ static bool_t validateAndWriteToOD(CO_SDOserver_t *SDO,
}
else {
/* Verify if size of data downloaded is not too large. */
if (SDO->sizeInd > 0 && SDO->sizeTran > SDO->sizeInd) {
if ((SDO->sizeInd > 0) && (SDO->sizeTran > SDO->sizeInd)) {
*abortCode = CO_SDO_AB_DATA_LONG;
SDO->state = CO_SDO_ST_ABORT;
return false;
@ -564,18 +564,18 @@ static bool_t validateAndWriteToOD(CO_SDOserver_t *SDO,
SDO->bufOffsetWr = 0;
/* verify write error value */
if (odRet != ODR_OK && odRet != ODR_PARTIAL) {
if ((odRet != ODR_OK) && (odRet != ODR_PARTIAL)) {
*abortCode = (CO_SDO_abortCode_t)OD_getSDOabCode(odRet);
SDO->state = CO_SDO_ST_ABORT;
return false;
}
else if (SDO->finished && odRet == ODR_PARTIAL) {
else if (SDO->finished && (odRet == ODR_PARTIAL)) {
/* OD variable was not written completely, but SDO download finished */
*abortCode = CO_SDO_AB_DATA_SHORT;
SDO->state = CO_SDO_ST_ABORT;
return false;
}
else if (!SDO->finished && odRet == ODR_OK) {
else if (!SDO->finished && (odRet == ODR_OK)) {
/* OD variable was written completely, but SDO download still has data*/
*abortCode = CO_SDO_AB_DATA_LONG;
SDO->state = CO_SDO_ST_ABORT;
@ -605,7 +605,7 @@ static bool_t readFromOd(CO_SDOserver_t *SDO,
{
OD_size_t countRemain = SDO->bufOffsetWr - SDO->bufOffsetRd;
if (!SDO->finished && countRemain < countMinimum) {
if (!SDO->finished && (countRemain < countMinimum)) {
/* first move remaining data to the start of the buffer */
(void)memmove(SDO->buf, SDO->buf + SDO->bufOffsetRd, countRemain);
SDO->bufOffsetRd = 0;
@ -623,14 +623,14 @@ static bool_t readFromOd(CO_SDOserver_t *SDO,
countRdRequest, &countRd);
CO_UNLOCK_OD(SDO->CANdevTx);
if (odRet != ODR_OK && odRet != ODR_PARTIAL) {
if ((odRet != ODR_OK) && (odRet != ODR_PARTIAL)) {
*abortCode = (CO_SDO_abortCode_t)OD_getSDOabCode(odRet);
SDO->state = CO_SDO_ST_ABORT;
return false;
}
/* if data is string, send only data up to null termination */
if (countRd > 0 && (SDO->OD_IO.stream.attribute & ODA_STR) != 0) {
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 */
@ -644,7 +644,7 @@ static bool_t readFromOd(CO_SDOserver_t *SDO,
/* partial or finished read */
SDO->bufOffsetWr = countRemain + countRd;
if (SDO->bufOffsetWr == 0 || odRet == ODR_PARTIAL) {
if ((SDO->bufOffsetWr == 0) || (odRet == ODR_PARTIAL)) {
SDO->finished = false;
if (SDO->bufOffsetWr < countMinimum) {
*abortCode = CO_SDO_AB_DEVICE_INCOMPAT;
@ -701,7 +701,7 @@ CO_SDO_return_t CO_SDOserver_process(CO_SDOserver_t *SDO,
bool_t isNew = CO_FLAG_READ(SDO->CANrxNew);
if (SDO->valid && SDO->state == CO_SDO_ST_IDLE && !isNew) {
if (SDO->valid && (SDO->state == CO_SDO_ST_IDLE) && !isNew) {
/* Idle and nothing new */
ret = CO_SDO_RT_ok_communicationEnd;
}
@ -741,7 +741,7 @@ CO_SDO_return_t CO_SDOserver_process(CO_SDOserver_t *SDO,
/* if no error search object dictionary for new SDO request */
if (abortCode == CO_SDO_AB_NONE) {
ODR_t odRet;
SDO->index = ((uint16_t)SDO->CANrxData[2]) << 8
SDO->index = (((uint16_t)SDO->CANrxData[2]) << 8)
| SDO->CANrxData[1];
SDO->subIndex = SDO->CANrxData[3];
odRet = OD_getSub(OD_find(SDO->OD, SDO->index), SDO->subIndex,
@ -757,13 +757,13 @@ CO_SDO_return_t CO_SDOserver_process(CO_SDOserver_t *SDO,
SDO->state = CO_SDO_ST_ABORT;
}
else if (upload
&& (SDO->OD_IO.stream.attribute & ODA_SDO_R) == 0
&& ((SDO->OD_IO.stream.attribute & ODA_SDO_R) == 0)
) {
abortCode = CO_SDO_AB_WRITEONLY;
SDO->state = CO_SDO_ST_ABORT;
}
else if (!upload
&& (SDO->OD_IO.stream.attribute & ODA_SDO_W) == 0
&& ((SDO->OD_IO.stream.attribute & ODA_SDO_W) == 0)
) {
abortCode = CO_SDO_AB_READONLY;
SDO->state = CO_SDO_ST_ABORT;
@ -774,7 +774,7 @@ CO_SDO_return_t CO_SDOserver_process(CO_SDOserver_t *SDO,
#if (CO_CONFIG_SDO_SRV) & CO_CONFIG_SDO_SRV_SEGMENTED
/* load data from object dictionary, if upload and no error */
if (upload && abortCode == CO_SDO_AB_NONE) {
if (upload && (abortCode == CO_SDO_AB_NONE)) {
SDO->bufOffsetRd = SDO->bufOffsetWr = 0;
SDO->sizeTran = 0;
SDO->finished = false;
@ -797,7 +797,7 @@ CO_SDO_return_t CO_SDOserver_process(CO_SDOserver_t *SDO,
}
else {
/* If data type is string, size is not known */
SDO->sizeInd = (SDO->OD_IO.stream.attribute&ODA_STR)==0
SDO->sizeInd = ((SDO->OD_IO.stream.attribute&ODA_STR)==0)
? SDO->OD_IO.stream.dataLength
: 0;
}
@ -806,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) {
@ -820,7 +820,7 @@ CO_SDO_return_t CO_SDOserver_process(CO_SDOserver_t *SDO,
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 */ }
@ -838,11 +838,11 @@ CO_SDO_return_t CO_SDOserver_process(CO_SDOserver_t *SDO,
* shorter as size of OD data buffer. If so, add two zero bytes
* to terminate (unicode) string. Shorten also OD data size,
* (temporary, send information about EOF into OD_IO.write) */
if ((SDO->OD_IO.stream.attribute & ODA_STR) != 0
&& (sizeInOd == 0 || dataSizeToWrite < sizeInOd)
if (((SDO->OD_IO.stream.attribute & ODA_STR) != 0)
&& ((sizeInOd == 0) || (dataSizeToWrite < sizeInOd))
) {
OD_size_t delta = sizeInOd - dataSizeToWrite;
dataSizeToWrite += delta == 1 ? 1 : 2;
dataSizeToWrite += (delta == 1) ? 1 : 2;
SDO->OD_IO.stream.dataLength = dataSizeToWrite;
}
else if (sizeInOd == 0) {
@ -895,8 +895,8 @@ CO_SDO_return_t CO_SDOserver_process(CO_SDOserver_t *SDO,
break;
}
/* strings are allowed to be shorter */
else if (SDO->sizeInd < sizeInOd
&& (SDO->OD_IO.stream.attribute & ODA_STR) == 0
else if ((SDO->sizeInd < sizeInOd)
&& ((SDO->OD_IO.stream.attribute & ODA_STR) == 0)
) {
abortCode = CO_SDO_AB_DATA_SHORT;
SDO->state = CO_SDO_ST_ABORT;
@ -938,8 +938,8 @@ CO_SDO_return_t CO_SDOserver_process(CO_SDOserver_t *SDO,
SDO->sizeTran += count;
/* if data size exceeds variable size, abort */
if (SDO->OD_IO.stream.dataLength > 0
&& SDO->sizeTran > SDO->OD_IO.stream.dataLength
if ((SDO->OD_IO.stream.dataLength > 0)
&& (SDO->sizeTran > SDO->OD_IO.stream.dataLength)
) {
abortCode = CO_SDO_AB_DATA_LONG;
SDO->state = CO_SDO_ST_ABORT;
@ -948,7 +948,7 @@ CO_SDO_return_t CO_SDOserver_process(CO_SDOserver_t *SDO,
/* if necessary, empty the buffer */
if (SDO->finished
|| (CO_CONFIG_SDO_SRV_BUFFER_SIZE - SDO->bufOffsetWr)<(7+2)
|| ((CO_CONFIG_SDO_SRV_BUFFER_SIZE - SDO->bufOffsetWr)<(7+2))
) {
if (!validateAndWriteToOD(SDO, &abortCode, 0, 0)) {
break;
@ -1285,7 +1285,7 @@ CO_SDO_return_t CO_SDOserver_process(CO_SDOserver_t *SDO,
case CO_SDO_ST_UPLOAD_INITIATE_RSP: {
#if (CO_CONFIG_SDO_SRV) & CO_CONFIG_SDO_SRV_SEGMENTED
/* data were already loaded from OD variable */
if (SDO->sizeInd > 0 && SDO->sizeInd <= 4) {
if ((SDO->sizeInd > 0) && (SDO->sizeInd <= 4)) {
/* expedited transfer */
SDO->CANtxBuff->data[0] = (uint8_t)(0x43|((4-SDO->sizeInd)<<2));
(void)memcpy(&SDO->CANtxBuff->data[4], &SDO->buf, SDO->sizeInd);
@ -1364,7 +1364,7 @@ CO_SDO_return_t CO_SDOserver_process(CO_SDOserver_t *SDO,
OD_size_t count = SDO->bufOffsetWr - SDO->bufOffsetRd;
/* verify, if this is the last segment */
if (count < 7 || (SDO->finished && count == 7)) {
if ((count < 7) || (SDO->finished && (count == 7))) {
/* indicate last segment and nnn */
SDO->CANtxBuff->data[0] |= ((7 - count) << 1) | 0x01;
SDO->state = CO_SDO_ST_IDLE;
@ -1389,8 +1389,8 @@ CO_SDO_return_t CO_SDOserver_process(CO_SDOserver_t *SDO,
SDO->state = CO_SDO_ST_ABORT;
break;
}
else if (ret == CO_SDO_RT_ok_communicationEnd
&& SDO->sizeTran < SDO->sizeInd
else if ((ret == CO_SDO_RT_ok_communicationEnd)
&& (SDO->sizeTran < SDO->sizeInd)
) {
abortCode = CO_SDO_AB_DATA_SHORT;
ret = CO_SDO_RT_waitingResponse;

22
301/CO_SYNC.c
View file

@ -83,8 +83,8 @@ static void CO_SYNC_receive(void *object, void *msg) {
static ODR_t OD_write_1005(OD_stream_t *stream, const void *buf,
OD_size_t count, OD_size_t *countWritten)
{
if (stream == NULL || stream->subIndex != 0 || buf == NULL
|| count != sizeof(uint32_t) || countWritten == NULL
if ((stream == NULL) || (stream->subIndex != 0) || (buf == NULL)
|| (count != sizeof(uint32_t)) || (countWritten == NULL)
) {
return ODR_DEV_INCOMPAT;
}
@ -102,7 +102,7 @@ static ODR_t OD_write_1005(OD_stream_t *stream, const void *buf,
return ODR_INVALID_VALUE;
}
#else
if ((cobIdSync & 0xFFFFF800) != 0 || CO_IS_RESTRICTED_CAN_ID(CAN_ID)) {
if (((cobIdSync & 0xFFFFF800) != 0) || CO_IS_RESTRICTED_CAN_ID(CAN_ID)) {
return ODR_INVALID_VALUE;
}
#endif
@ -219,11 +219,11 @@ CO_ReturnError_t CO_SYNC_init(CO_SYNC_t *SYNC,
ODR_t odRet;
/* verify arguments */
if (SYNC == NULL || em == NULL || OD_1005_cobIdSync == NULL
if ((SYNC == NULL) || (em == NULL) || (OD_1005_cobIdSync == NULL)
#if (CO_CONFIG_SYNC) & CO_CONFIG_SYNC_PRODUCER
|| OD_1006_commCyclePeriod == NULL || CANdevTx == NULL
|| (OD_1006_commCyclePeriod == NULL) || (CANdevTx == NULL)
#endif
|| CANdevRx == NULL
|| (CANdevRx == NULL)
) {
return CO_ERROR_ILLEGAL_ARGUMENT;
}
@ -257,7 +257,7 @@ CO_ReturnError_t CO_SYNC_init(CO_SYNC_t *SYNC,
return CO_ERROR_OD_PARAMETERS;
}
#else
if (OD_1006_commCyclePeriod != NULL && SYNC->OD_1006_period == NULL) {
if ((OD_1006_commCyclePeriod != NULL) && (SYNC->OD_1006_period == NULL)) {
if (errInfo != NULL) {
*errInfo = OD_getIndex(OD_1006_commCyclePeriod);
}
@ -268,7 +268,7 @@ CO_ReturnError_t CO_SYNC_init(CO_SYNC_t *SYNC,
/* get "Synchronous window length" from OD (optional parameter) */
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 ((OD_1007_syncWindowLen != NULL) && (SYNC->OD_1007_window == NULL)) {
if (errInfo != NULL) {
*errInfo = OD_getIndex(OD_1007_syncWindowLen);
}
@ -385,7 +385,7 @@ CO_SYNC_status_t CO_SYNC_process(CO_SYNC_t *SYNC,
CO_FLAG_CLEAR(SYNC->CANrxNew);
}
uint32_t OD_1006_period = SYNC->OD_1006_period != NULL
uint32_t OD_1006_period = (SYNC->OD_1006_period != NULL)
? *SYNC->OD_1006_period : 0;
if (OD_1006_period > 0) {
@ -434,8 +434,8 @@ CO_SYNC_status_t CO_SYNC_process(CO_SYNC_t *SYNC,
} /* if (OD_1006_period > 0) */
/* Synchronous PDOs are allowed only inside time window */
if (SYNC->OD_1007_window != NULL && *SYNC->OD_1007_window > 0
&& SYNC->timer > *SYNC->OD_1007_window
if ((SYNC->OD_1007_window != NULL) && (*SYNC->OD_1007_window > 0)
&& (SYNC->timer > *SYNC->OD_1007_window)
) {
if (!SYNC->syncIsOutsideWindow) {
syncStatus = CO_SYNC_PASSED_WINDOW;

10
301/CO_TIME.c
View file

@ -64,8 +64,8 @@ static void CO_TIME_receive(void *object, void *msg) {
static ODR_t OD_write_1012(OD_stream_t *stream, const void *buf,
OD_size_t count, OD_size_t *countWritten)
{
if (stream == NULL || stream->subIndex != 0 || buf == NULL
|| count != sizeof(uint32_t) || countWritten == NULL
if ((stream == NULL) || (stream->subIndex != 0) || (buf == NULL)
|| (count != sizeof(uint32_t)) || (countWritten == NULL)
) {
return ODR_DEV_INCOMPAT;
}
@ -75,7 +75,7 @@ static ODR_t OD_write_1012(OD_stream_t *stream, const void *buf,
/* verify written value */
uint32_t cobIdTimeStamp = CO_getUint32(buf);
uint16_t CAN_ID = cobIdTimeStamp & 0x7FF;
if ((cobIdTimeStamp & 0x3FFFF800) != 0 || CO_IS_RESTRICTED_CAN_ID(CAN_ID)) {
if (((cobIdTimeStamp & 0x3FFFF800) != 0) || CO_IS_RESTRICTED_CAN_ID(CAN_ID)) {
return ODR_INVALID_VALUE;
}
@ -100,7 +100,7 @@ CO_ReturnError_t CO_TIME_init(CO_TIME_t *TIME,
uint32_t *errInfo)
{
/* verify arguments */
if (TIME == NULL || OD_1012_cobIdTimeStamp == NULL || CANdevRx == NULL
if ((TIME == NULL) || (OD_1012_cobIdTimeStamp == NULL) || (CANdevRx == NULL)
#if (CO_CONFIG_TIME) & CO_CONFIG_TIME_PRODUCER
|| CANdevTx == NULL
#endif
@ -203,7 +203,7 @@ bool_t CO_TIME_process(CO_TIME_t *TIME,
/* Update time */
uint32_t ms = 0;
if (!timestampReceived && timeDifference_us > 0) {
if (!timestampReceived && (timeDifference_us > 0)) {
uint32_t us = timeDifference_us + TIME->residual_us;
ms = us / 1000;
TIME->residual_us = us % 1000;

12
301/CO_driver.h
View file

@ -506,12 +506,12 @@ typedef enum {
* They shall not be used for SYNC, TIME, EMCY, PDO and SDO.
*/
#ifndef CO_IS_RESTRICTED_CAN_ID
#define CO_IS_RESTRICTED_CAN_ID(CAN_ID) ((CAN_ID) <= 0x7F \
|| ((CAN_ID) >= 0x101 && (CAN_ID) <= 0x180) \
|| ((CAN_ID) >= 0x581 && (CAN_ID) <= 0x5FF) \
|| ((CAN_ID) >= 0x601 && (CAN_ID) <= 0x67F) \
|| ((CAN_ID) >= 0x6E0 && (CAN_ID) <= 0x6FF) \
|| (CAN_ID) >= 0x701)
#define CO_IS_RESTRICTED_CAN_ID(CAN_ID) (((CAN_ID) <= 0x7F) \
|| (((CAN_ID) >= 0x101) && ((CAN_ID) <= 0x180)) \
|| (((CAN_ID) >= 0x581) && ((CAN_ID) <= 0x5FF)) \
|| (((CAN_ID) >= 0x601) && ((CAN_ID) <= 0x67F)) \
|| (((CAN_ID) >= 0x6E0) && ((CAN_ID) <= 0x6FF)) \
|| ((CAN_ID) >= 0x701))
#endif

140
301/CO_fifo.c
View file

@ -54,7 +54,7 @@
/******************************************************************************/
void CO_fifo_init(CO_fifo_t *fifo, uint8_t *buf, size_t bufSize) {
if (fifo == NULL || buf == NULL || bufSize < 2) {
if ((fifo == NULL) || (buf == NULL) || (bufSize < 2)) {
return;
}
@ -88,7 +88,7 @@ size_t CO_fifo_write(CO_fifo_t *fifo,
size_t i;
uint8_t *bufDest;
if (fifo == NULL || fifo->buf == NULL || buf == NULL) {
if ((fifo == NULL) || (fifo->buf == NULL) || (buf == NULL)) {
return 0;
}
@ -97,8 +97,8 @@ size_t CO_fifo_write(CO_fifo_t *fifo,
size_t writePtrNext = fifo->writePtr + 1;
/* is circular buffer full */
if (writePtrNext == fifo->readPtr ||
(writePtrNext == fifo->bufSize && fifo->readPtr == 0)) {
if ((writePtrNext == fifo->readPtr) ||
((writePtrNext == fifo->bufSize) && (fifo->readPtr == 0))) {
break;
}
@ -134,7 +134,7 @@ size_t CO_fifo_read(CO_fifo_t *fifo, uint8_t *buf, size_t count, bool_t *eof) {
if (eof != NULL) {
*eof = false;
}
if (fifo == NULL || buf == NULL || fifo->readPtr == fifo->writePtr) {
if ((fifo == NULL) || (buf == NULL) || (fifo->readPtr == fifo->writePtr)) {
return 0;
}
@ -161,7 +161,7 @@ size_t CO_fifo_read(CO_fifo_t *fifo, uint8_t *buf, size_t count, bool_t *eof) {
#if (CO_CONFIG_FIFO) & CO_CONFIG_FIFO_ASCII_COMMANDS
/* is delimiter? */
if (eof != NULL && c == DELIM_COMMAND) {
if ((eof != NULL) && (c == DELIM_COMMAND)) {
*eof = true;
break;
}
@ -261,7 +261,7 @@ bool_t CO_fifo_CommSearch(CO_fifo_t *fifo, bool_t clear) {
size_t count;
uint8_t *commandEnd;
if (fifo == NULL || fifo->readPtr == fifo->writePtr) {
if ((fifo == NULL) || (fifo->readPtr == fifo->writePtr)) {
return 0;
}
@ -282,12 +282,12 @@ bool_t CO_fifo_CommSearch(CO_fifo_t *fifo, bool_t clear) {
commandEnd = (uint8_t *)memchr((const void *)&fifo->buf[0],
(int)DELIM_COMMAND,
fifo->writePtr);
if (commandEnd != NULL || fifo->readPtr == (fifo->writePtr + 1)) {
if ((commandEnd != NULL) || (fifo->readPtr == (fifo->writePtr + 1))) {
/* command delimiter found or buffer full */
newCommand = true;
}
}
else if (fifo->readPtr == 0 && fifo->writePtr == (fifo->bufSize - 1)) {
else if ((fifo->readPtr == 0) && (fifo->writePtr == (fifo->bufSize - 1))) {
/* buffer full */
newCommand = true;
}
@ -313,14 +313,14 @@ bool_t CO_fifo_CommSearch(CO_fifo_t *fifo, bool_t clear) {
bool_t CO_fifo_trimSpaces(CO_fifo_t *fifo, bool_t *insideComment) {
bool_t delimCommandFound = false;
if (fifo != NULL && insideComment != NULL) {
if ((fifo != NULL) && (insideComment != NULL)) {
while (fifo->readPtr != fifo->writePtr) {
uint8_t c = fifo->buf[fifo->readPtr];
if (c == DELIM_COMMENT) {
*insideComment = true;
}
else if (isgraph((int)c) != 0 && !(*insideComment)) {
else if ((isgraph((int)c) != 0) && !(*insideComment)) {
break;
}
if (++fifo->readPtr == fifo->bufSize) {
@ -348,8 +348,8 @@ size_t CO_fifo_readToken(CO_fifo_t *fifo,
bool_t delimCommentFound = false;
size_t tokenSize = 0;
if (fifo != NULL && buf != NULL && count > 1 && (err == NULL || *err == 0)
&& fifo->readPtr != fifo->writePtr
if ((fifo != NULL) && (buf != NULL) && (count > 1) && ((err == NULL) || (*err == 0))
&& (fifo->readPtr != fifo->writePtr)
) {
bool_t finished = false;
uint8_t step = 0;
@ -438,10 +438,10 @@ size_t CO_fifo_readToken(CO_fifo_t *fifo,
}
/* set 'err' return value */
if (err != NULL && *err == false) {
if (tokenSize == count || (closed != NULL &&
((*closed == 1 && (!delimCommandFound || tokenSize == 0)) ||
(*closed == 0 && (delimCommandFound || tokenSize == 0)))
if ((err != NULL) && (*err == false)) {
if ((tokenSize == count) || ((closed != NULL) &&
(((*closed == 1) && (!delimCommandFound || (tokenSize == 0))) ||
((*closed == 0) && (delimCommandFound || (tokenSize == 0))))
)) {
*err = true;
}
@ -456,7 +456,7 @@ size_t CO_fifo_readToken(CO_fifo_t *fifo,
tokenSize = 0;
}
/* write string terminator character */
if (buf != NULL && count > tokenSize) {
if ((buf != NULL) && (count > tokenSize)) {
buf[tokenSize] = '\0';
}
@ -488,7 +488,7 @@ static const uint8_t base64DecTable[] = {
size_t CO_fifo_readU82a(CO_fifo_t *fifo, char *buf, size_t count, bool_t end) {
uint8_t n=0;
if (fifo != NULL && count >= 6 && CO_fifo_getOccupied(fifo) == sizeof(n)) {
if ((fifo != NULL) && (count >= 6) && (CO_fifo_getOccupied(fifo) == sizeof(n))) {
CO_fifo_read(fifo, &n, sizeof(n), NULL);
return sprintf(buf, "%"PRIu8, n);
}
@ -500,7 +500,7 @@ size_t CO_fifo_readU82a(CO_fifo_t *fifo, char *buf, size_t count, bool_t end) {
size_t CO_fifo_readU162a(CO_fifo_t *fifo, char *buf, size_t count, bool_t end) {
uint16_t n=0;
if (fifo != NULL && count >= 8 && CO_fifo_getOccupied(fifo) == sizeof(n)) {
if ((fifo != NULL) && (count >= 8) && (CO_fifo_getOccupied(fifo) == sizeof(n))) {
CO_fifo_read(fifo, (uint8_t *)&n, sizeof(n), NULL);
return sprintf(buf, "%"PRIu16, CO_SWAP_16(n));
}
@ -512,7 +512,7 @@ size_t CO_fifo_readU162a(CO_fifo_t *fifo, char *buf, size_t count, bool_t end) {
size_t CO_fifo_readU322a(CO_fifo_t *fifo, char *buf, size_t count, bool_t end) {
uint32_t n=0;
if (fifo != NULL && count >= 12 && CO_fifo_getOccupied(fifo) == sizeof(n)) {
if ((fifo != NULL) && (count >= 12) && (CO_fifo_getOccupied(fifo) == sizeof(n))) {
CO_fifo_read(fifo, (uint8_t *)&n, sizeof(n), NULL);
return sprintf(buf, "%"PRIu32, CO_SWAP_32(n));
}
@ -524,7 +524,7 @@ size_t CO_fifo_readU322a(CO_fifo_t *fifo, char *buf, size_t count, bool_t end) {
size_t CO_fifo_readU642a(CO_fifo_t *fifo, char *buf, size_t count, bool_t end) {
uint64_t n=0;
if (fifo != NULL && count >= 20 && CO_fifo_getOccupied(fifo) == sizeof(n)) {
if ((fifo != NULL) && (count >= 20) && (CO_fifo_getOccupied(fifo) == sizeof(n))) {
CO_fifo_read(fifo, (uint8_t *)&n, sizeof(n), NULL);
return sprintf(buf, "%"PRIu64, CO_SWAP_64(n));
}
@ -536,7 +536,7 @@ size_t CO_fifo_readU642a(CO_fifo_t *fifo, char *buf, size_t count, bool_t end) {
size_t CO_fifo_readX82a(CO_fifo_t *fifo, char *buf, size_t count, bool_t end) {
uint8_t n=0;
if (fifo != NULL && count >= 6 && CO_fifo_getOccupied(fifo) == sizeof(n)) {
if ((fifo != NULL) && (count >= 6) && (CO_fifo_getOccupied(fifo) == sizeof(n))) {
CO_fifo_read(fifo, (uint8_t *)&n, sizeof(n), NULL);
return sprintf(buf, "0x%02"PRIX8, n);
}
@ -548,7 +548,7 @@ size_t CO_fifo_readX82a(CO_fifo_t *fifo, char *buf, size_t count, bool_t end) {
size_t CO_fifo_readX162a(CO_fifo_t *fifo, char *buf, size_t count, bool_t end) {
uint16_t n=0;
if (fifo != NULL && count >= 8 && CO_fifo_getOccupied(fifo) == sizeof(n)) {
if ((fifo != NULL) && (count >= 8) && (CO_fifo_getOccupied(fifo) == sizeof(n))) {
CO_fifo_read(fifo, (uint8_t *)&n, sizeof(n), NULL);
return sprintf(buf, "0x%04"PRIX16, CO_SWAP_16(n));
}
@ -560,7 +560,7 @@ size_t CO_fifo_readX162a(CO_fifo_t *fifo, char *buf, size_t count, bool_t end) {
size_t CO_fifo_readX322a(CO_fifo_t *fifo, char *buf, size_t count, bool_t end) {
uint32_t n=0;
if (fifo != NULL && count >= 12 && CO_fifo_getOccupied(fifo) == sizeof(n)) {
if ((fifo != NULL) && (count >= 12) && (CO_fifo_getOccupied(fifo) == sizeof(n))) {
CO_fifo_read(fifo, (uint8_t *)&n, sizeof(n), NULL);
return sprintf(buf, "0x%08"PRIX32, CO_SWAP_32(n));
}
@ -572,7 +572,7 @@ size_t CO_fifo_readX322a(CO_fifo_t *fifo, char *buf, size_t count, bool_t end) {
size_t CO_fifo_readX642a(CO_fifo_t *fifo, char *buf, size_t count, bool_t end) {
uint64_t n=0;
if (fifo != NULL && count >= 20 && CO_fifo_getOccupied(fifo) == sizeof(n)) {
if ((fifo != NULL) && (count >= 20) && (CO_fifo_getOccupied(fifo) == sizeof(n))) {
CO_fifo_read(fifo, (uint8_t *)&n, sizeof(n), NULL);
return sprintf(buf, "0x%016"PRIX64, CO_SWAP_64(n));
}
@ -584,7 +584,7 @@ size_t CO_fifo_readX642a(CO_fifo_t *fifo, char *buf, size_t count, bool_t end) {
size_t CO_fifo_readI82a(CO_fifo_t *fifo, char *buf, size_t count, bool_t end) {
int8_t n=0;
if (fifo != NULL && count >= 6 && CO_fifo_getOccupied(fifo) == sizeof(n)) {
if ((fifo != NULL) && (count >= 6) && (CO_fifo_getOccupied(fifo) == sizeof(n))) {
CO_fifo_read(fifo, (uint8_t *)&n, sizeof(n), NULL);
return sprintf(buf, "%"PRId8, n);
}
@ -596,7 +596,7 @@ size_t CO_fifo_readI82a(CO_fifo_t *fifo, char *buf, size_t count, bool_t end) {
size_t CO_fifo_readI162a(CO_fifo_t *fifo, char *buf, size_t count, bool_t end) {
int16_t n=0;
if (fifo != NULL && count >= 8 && CO_fifo_getOccupied(fifo) == sizeof(n)) {
if ((fifo != NULL) && (count >= 8) && (CO_fifo_getOccupied(fifo) == sizeof(n))) {
CO_fifo_read(fifo, (uint8_t *)&n, sizeof(n), NULL);
return sprintf(buf, "%"PRId16, CO_SWAP_16(n));
}
@ -608,7 +608,7 @@ size_t CO_fifo_readI162a(CO_fifo_t *fifo, char *buf, size_t count, bool_t end) {
size_t CO_fifo_readI322a(CO_fifo_t *fifo, char *buf, size_t count, bool_t end) {
int32_t n=0;
if (fifo != NULL && count >= 13 && CO_fifo_getOccupied(fifo) == sizeof(n)) {
if ((fifo != NULL) && (count >= 13) && (CO_fifo_getOccupied(fifo) == sizeof(n))) {
CO_fifo_read(fifo, (uint8_t *)&n, sizeof(n), NULL);
return sprintf(buf, "%"PRId32, CO_SWAP_32(n));
}
@ -620,7 +620,7 @@ size_t CO_fifo_readI322a(CO_fifo_t *fifo, char *buf, size_t count, bool_t end) {
size_t CO_fifo_readI642a(CO_fifo_t *fifo, char *buf, size_t count, bool_t end) {
int64_t n=0;
if (fifo != NULL && count >= 23 && CO_fifo_getOccupied(fifo) == sizeof(n)) {
if ((fifo != NULL) && (count >= 23) && (CO_fifo_getOccupied(fifo) == sizeof(n))) {
CO_fifo_read(fifo, (uint8_t *)&n, sizeof(n), NULL);
return sprintf(buf, "%"PRId64, CO_SWAP_64(n));
}
@ -632,7 +632,7 @@ size_t CO_fifo_readI642a(CO_fifo_t *fifo, char *buf, size_t count, bool_t end) {
size_t CO_fifo_readR322a(CO_fifo_t *fifo, char *buf, size_t count, bool_t end) {
float32_t n=0;
if (fifo != NULL && count >= 20 && CO_fifo_getOccupied(fifo) == sizeof(n)) {
if ((fifo != NULL) && (count >= 20) && (CO_fifo_getOccupied(fifo) == sizeof(n))) {
CO_fifo_read(fifo, (uint8_t *)&n, sizeof(n), NULL);
return sprintf(buf, "%g", (double)CO_SWAP_32(n));
}
@ -644,7 +644,7 @@ size_t CO_fifo_readR322a(CO_fifo_t *fifo, char *buf, size_t count, bool_t end) {
size_t CO_fifo_readR642a(CO_fifo_t *fifo, char *buf, size_t count, bool_t end) {
float64_t n=0;
if (fifo != NULL && count >= 30 && CO_fifo_getOccupied(fifo) == sizeof(n)) {
if ((fifo != NULL) && (count >= 30) && (CO_fifo_getOccupied(fifo) == sizeof(n))) {
CO_fifo_read(fifo, (uint8_t *)&n, sizeof(n), NULL);
return sprintf(buf, "%g", (double)CO_SWAP_64(n));
}
@ -658,7 +658,7 @@ size_t CO_fifo_readHex2a(CO_fifo_t *fifo, char *buf, size_t count, bool_t end) {
size_t len = 0;
if (fifo != NULL && count > 3) {
if ((fifo != NULL) && (count > 3)) {
/* Very first write is without leading space */
if (!fifo->started) {
uint8_t c;
@ -683,7 +683,7 @@ size_t CO_fifo_readHex2a(CO_fifo_t *fifo, char *buf, size_t count, bool_t end) {
size_t CO_fifo_readVs2a(CO_fifo_t *fifo, char *buf, size_t count, bool_t end) {
size_t len = 0;
if (fifo != NULL && count > 3) {
if ((fifo != NULL) && (count > 3)) {
/* Start with '"' */
if (!fifo->started) {
buf[len++] = '"';
@ -698,7 +698,7 @@ size_t CO_fifo_readVs2a(CO_fifo_t *fifo, char *buf, size_t count, bool_t end) {
}
break;
}
else if (c != 0 && c != (uint8_t)'\r') {
else if ((c != 0) && (c != (uint8_t)'\r')) {
/* skip null and CR inside string */
buf[len++] = (char)c;
if (c == DELIM_DQUOTE) {
@ -716,7 +716,7 @@ size_t CO_fifo_readB642a(CO_fifo_t *fifo, char *buf, size_t count, bool_t end) {
size_t len = 0;
if (fifo != NULL && count >= 4) {
if ((fifo != NULL) && (count >= 4)) {
uint8_t step;
uint16_t word;
@ -775,7 +775,7 @@ size_t CO_fifo_readB642a(CO_fifo_t *fifo, char *buf, size_t count, bool_t end) {
}
/* memorize variables for next iteration */
fifo->aux = (uint32_t)step << 16 | word;
fifo->aux = ((uint32_t)step << 16) | word;
}
return len;
@ -790,11 +790,11 @@ size_t CO_fifo_cpyTok2U8(CO_fifo_t *dest, CO_fifo_t *src, CO_fifo_st *status) {
size_t nWr = 0;
size_t nRd = CO_fifo_readToken(src, buf, sizeof(buf), &closed, &err);
CO_fifo_st st = (uint8_t)closed;
if (nRd == 0 || err) st |= CO_fifo_st_errTok;
if ((nRd == 0) || err) st |= CO_fifo_st_errTok;
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 > UINT8_MAX)) st |= CO_fifo_st_errVal;
else {
uint8_t num = (uint8_t) u32;
nWr = CO_fifo_write(dest, &num, sizeof(num), NULL);
@ -812,11 +812,11 @@ size_t CO_fifo_cpyTok2U16(CO_fifo_t *dest, CO_fifo_t *src, CO_fifo_st *status) {
size_t nWr = 0;
size_t nRd = CO_fifo_readToken(src, buf, sizeof(buf), &closed, &err);
CO_fifo_st st = (uint8_t)closed;
if (nRd == 0 || err) st |= CO_fifo_st_errTok;
if ((nRd == 0) || err) st |= CO_fifo_st_errTok;
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 > 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);
@ -834,7 +834,7 @@ size_t CO_fifo_cpyTok2U32(CO_fifo_t *dest, CO_fifo_t *src, CO_fifo_st *status) {
size_t nWr = 0;
size_t nRd = CO_fifo_readToken(src, buf, sizeof(buf), &closed, &err);
CO_fifo_st st = (uint8_t)closed;
if (nRd == 0 || err) st |= CO_fifo_st_errTok;
if ((nRd == 0) || err) st |= CO_fifo_st_errTok;
else {
char *sRet;
uint32_t u32 = strtoul(buf, &sRet, 0);
@ -856,7 +856,7 @@ size_t CO_fifo_cpyTok2U64(CO_fifo_t *dest, CO_fifo_t *src, CO_fifo_st *status) {
size_t nWr = 0;
size_t nRd = CO_fifo_readToken(src, buf, sizeof(buf), &closed, &err);
CO_fifo_st st = (uint8_t)closed;
if (nRd == 0 || err) st |= CO_fifo_st_errTok;
if ((nRd == 0) || err) st |= CO_fifo_st_errTok;
else {
char *sRet;
uint64_t u64 = strtoull(buf, &sRet, 0);
@ -878,11 +878,11 @@ size_t CO_fifo_cpyTok2I8(CO_fifo_t *dest, CO_fifo_t *src, CO_fifo_st *status) {
size_t nWr = 0;
size_t nRd = CO_fifo_readToken(src, buf, sizeof(buf), &closed, &err);
CO_fifo_st st = (uint8_t)closed;
if (nRd == 0 || err) st |= CO_fifo_st_errTok;
if ((nRd == 0) || err) st |= CO_fifo_st_errTok;
else {
char *sRet;
int32_t i32 = strtol(buf, &sRet, 0);
if (sRet != strchr(buf, '\0') || i32 < INT8_MIN || i32 > INT8_MAX) {
if ((sRet != strchr(buf, '\0')) || (i32 < INT8_MIN) || (i32 > INT8_MAX)) {
st |= CO_fifo_st_errVal;
} else {
int8_t num = (int8_t) i32;
@ -901,11 +901,11 @@ size_t CO_fifo_cpyTok2I16(CO_fifo_t *dest, CO_fifo_t *src, CO_fifo_st *status) {
size_t nWr = 0;
size_t nRd = CO_fifo_readToken(src, buf, sizeof(buf), &closed, &err);
CO_fifo_st st = (uint8_t)closed;
if (nRd == 0 || err) st |= CO_fifo_st_errTok;
if ((nRd == 0) || err) st |= CO_fifo_st_errTok;
else {
char *sRet;
int32_t i32 = strtol(buf, &sRet, 0);
if (sRet != strchr(buf, '\0') || i32 < INT16_MIN || i32 > INT16_MAX) {
if ((sRet != strchr(buf, '\0')) || (i32 < INT16_MIN) || (i32 > INT16_MAX)) {
st |= CO_fifo_st_errVal;
} else {
int16_t num = CO_SWAP_16((int16_t) i32);
@ -924,7 +924,7 @@ size_t CO_fifo_cpyTok2I32(CO_fifo_t *dest, CO_fifo_t *src, CO_fifo_st *status) {
size_t nWr = 0;
size_t nRd = CO_fifo_readToken(src, buf, sizeof(buf), &closed, &err);
CO_fifo_st st = (uint8_t)closed;
if (nRd == 0 || err) st |= CO_fifo_st_errTok;
if ((nRd == 0) || err) st |= CO_fifo_st_errTok;
else {
char *sRet;
int32_t i32 = strtol(buf, &sRet, 0);
@ -946,7 +946,7 @@ size_t CO_fifo_cpyTok2I64(CO_fifo_t *dest, CO_fifo_t *src, CO_fifo_st *status) {
size_t nWr = 0;
size_t nRd = CO_fifo_readToken(src, buf, sizeof(buf), &closed, &err);
CO_fifo_st st = (uint8_t)closed;
if (nRd == 0 || err) st |= CO_fifo_st_errTok;
if ((nRd == 0) || err) st |= CO_fifo_st_errTok;
else {
char *sRet;
int64_t i64 = strtoll(buf, &sRet, 0);
@ -968,7 +968,7 @@ size_t CO_fifo_cpyTok2R32(CO_fifo_t *dest, CO_fifo_t *src, CO_fifo_st *status) {
size_t nWr = 0;
size_t nRd = CO_fifo_readToken(src, buf, sizeof(buf), &closed, &err);
CO_fifo_st st = (uint8_t)closed;
if (nRd == 0 || err) st |= CO_fifo_st_errTok;
if ((nRd == 0) || err) st |= CO_fifo_st_errTok;
else {
char *sRet;
float32_t f32 = strtof(buf, &sRet);
@ -990,7 +990,7 @@ size_t CO_fifo_cpyTok2R64(CO_fifo_t *dest, CO_fifo_t *src, CO_fifo_st *status) {
size_t nWr = 0;
size_t nRd = CO_fifo_readToken(src, buf, sizeof(buf), &closed, &err);
CO_fifo_st st = (uint8_t)closed;
if (nRd == 0 || err) st |= CO_fifo_st_errTok;
if ((nRd == 0) || err) st |= CO_fifo_st_errTok;
else {
char *sRet;
float64_t f64 = strtof(buf, &sRet);
@ -1012,7 +1012,7 @@ size_t CO_fifo_cpyTok2Hex(CO_fifo_t *dest, CO_fifo_t *src, CO_fifo_st *status) {
uint8_t firstChar;
CO_fifo_st st = 0;
if (dest == NULL || src == NULL) {
if ((dest == NULL) || (src == NULL)) {
return 0;
}
@ -1038,7 +1038,7 @@ size_t CO_fifo_cpyTok2Hex(CO_fifo_t *dest, CO_fifo_t *src, CO_fifo_st *status) {
/* repeat until destination space available and no error and not finished
* and source characters available */
while (destSpace > 0 && (st & CO_fifo_st_errMask) == 0 && !finished) {
while ((destSpace > 0) && ((st & CO_fifo_st_errMask) == 0) && !finished) {
uint8_t c;
if (!CO_fifo_getc(src, &c)) {
break;
@ -1047,7 +1047,7 @@ size_t CO_fifo_cpyTok2Hex(CO_fifo_t *dest, CO_fifo_t *src, CO_fifo_st *status) {
if (step == 6) {
/* command is inside comment, waiting for command delimiter */
bool_t insideComment = true;
if (c == DELIM_COMMAND || CO_fifo_trimSpaces(src, &insideComment)) {
if ((c == DELIM_COMMAND) || CO_fifo_trimSpaces(src, &insideComment)) {
st |= CO_fifo_st_closed;
finished = true;
}
@ -1091,7 +1091,7 @@ size_t CO_fifo_cpyTok2Hex(CO_fifo_t *dest, CO_fifo_t *src, CO_fifo_st *status) {
step = 0;
}
bool_t insideComment = false;
if (c == DELIM_COMMAND || CO_fifo_trimSpaces(src, &insideComment)) {
if ((c == DELIM_COMMAND) || CO_fifo_trimSpaces(src, &insideComment)) {
/* newline found, finish */
st |= CO_fifo_st_closed;
finished = true;
@ -1105,7 +1105,7 @@ size_t CO_fifo_cpyTok2Hex(CO_fifo_t *dest, CO_fifo_t *src, CO_fifo_st *status) {
if (!finished) {
st |= CO_fifo_st_partial;
/* memorize variables for next iteration */
dest->aux = (uint32_t)step << 8 | firstChar;
dest->aux = ((uint32_t)step << 8) | firstChar;
}
if (status != NULL) *status = st;
@ -1119,7 +1119,7 @@ size_t CO_fifo_cpyTok2Vs(CO_fifo_t *dest, CO_fifo_t *src, CO_fifo_st *status) {
uint8_t step;
CO_fifo_st st = 0;
if (dest == NULL || src == NULL) {
if ((dest == NULL) || (src == NULL)) {
return 0;
}
@ -1143,7 +1143,7 @@ size_t CO_fifo_cpyTok2Vs(CO_fifo_t *dest, CO_fifo_t *src, CO_fifo_st *status) {
/* repeat until destination space available and no error and not finished
* and source characters available */
while (destSpace > 0 && (st & CO_fifo_st_errMask) == 0 && !finished) {
while ((destSpace > 0) && ((st & CO_fifo_st_errMask) == 0) && !finished) {
uint8_t c;
if (!CO_fifo_getc(src, &c)) {
break;
@ -1171,10 +1171,10 @@ size_t CO_fifo_cpyTok2Vs(CO_fifo_t *dest, CO_fifo_t *src, CO_fifo_st *status) {
* double quote (with two double quotes) */
step += 2;
}
else if (isgraph((int)c) == 0 && step == 2) {
else if ((isgraph((int)c) == 0) && (step == 2)) {
/* end of single word string */
bool_t insideComment = false;
if (c == DELIM_COMMAND
if ((c == DELIM_COMMAND)
|| CO_fifo_trimSpaces(src, &insideComment)
) {
st |= CO_fifo_st_closed;
@ -1213,7 +1213,7 @@ size_t CO_fifo_cpyTok2Vs(CO_fifo_t *dest, CO_fifo_t *src, CO_fifo_st *status) {
if (isgraph((int)c) == 0) {
/* end of quoted string */
bool_t insideComment = false;
if (c == DELIM_COMMAND
if ((c == DELIM_COMMAND)
|| CO_fifo_trimSpaces(src, &insideComment)
) {
st |= CO_fifo_st_closed;
@ -1233,7 +1233,7 @@ size_t CO_fifo_cpyTok2Vs(CO_fifo_t *dest, CO_fifo_t *src, CO_fifo_st *status) {
case 5: { /* String token is finished, waiting for command delimiter */
bool_t insideComment = false;
if (c == DELIM_COMMAND || CO_fifo_trimSpaces(src, &insideComment)) {
if ((c == DELIM_COMMAND) || CO_fifo_trimSpaces(src, &insideComment)) {
st |= CO_fifo_st_closed;
finished = true;
}
@ -1250,7 +1250,7 @@ size_t CO_fifo_cpyTok2Vs(CO_fifo_t *dest, CO_fifo_t *src, CO_fifo_st *status) {
}
case 6: { /* String token is finished, waiting for command delimiter */
bool_t insideComment = true;
if (c == DELIM_COMMAND || CO_fifo_trimSpaces(src, &insideComment)) {
if ((c == DELIM_COMMAND) || CO_fifo_trimSpaces(src, &insideComment)) {
st |= CO_fifo_st_closed;
finished = true;
}
@ -1282,7 +1282,7 @@ size_t CO_fifo_cpyTok2B64(CO_fifo_t *dest, CO_fifo_t *src, CO_fifo_st *status) {
uint32_t dword;
CO_fifo_st st = 0;
if (dest == NULL || src == NULL) {
if ((dest == NULL) || (src == NULL)) {
return 0;
}
@ -1308,7 +1308,7 @@ size_t CO_fifo_cpyTok2B64(CO_fifo_t *dest, CO_fifo_t *src, CO_fifo_st *status) {
/* repeat until destination space available and no error and not finished
* and source characters available */
while (destSpace >= 3 && (st & CO_fifo_st_errMask) == 0 && !finished) {
while ((destSpace >= 3) && ((st & CO_fifo_st_errMask) == 0) && !finished) {
uint8_t c;
if (!CO_fifo_getc(src, &c)) {
break;
@ -1317,14 +1317,14 @@ size_t CO_fifo_cpyTok2B64(CO_fifo_t *dest, CO_fifo_t *src, CO_fifo_st *status) {
if (step >= 5) {
/* String token is finished, waiting for command delimiter */
bool_t insideComment = step > 5;
if (c == DELIM_COMMAND || CO_fifo_trimSpaces(src, &insideComment)) {
if ((c == DELIM_COMMAND) || CO_fifo_trimSpaces(src, &insideComment)) {
st |= CO_fifo_st_closed;
finished = true;
}
else if (insideComment) {
step = 6;
}
else if (isgraph((int)c) != 0 && c != (uint8_t)'=') {
else if ((isgraph((int)c) != 0) && (c != (uint8_t)'=')) {
if (c == DELIM_COMMENT) /* comment start */
step = 6;
else /* syntax error */
@ -1335,7 +1335,7 @@ size_t CO_fifo_cpyTok2B64(CO_fifo_t *dest, CO_fifo_t *src, CO_fifo_st *status) {
uint8_t code = base64DecTable[c & 0x7F];
if ((c & 0x80) != 0 || (code & 0x80) != 0) {
if (((c & 0x80) != 0) || ((code & 0x80) != 0)) {
st |= CO_fifo_st_errTok;
}
else if (code >= 64 /* '=' (pad) or DELIM_COMMAND or space */) {
@ -1356,7 +1356,7 @@ size_t CO_fifo_cpyTok2B64(CO_fifo_t *dest, CO_fifo_t *src, CO_fifo_st *status) {
}
bool_t insideComment = false;
if (c == DELIM_COMMAND || CO_fifo_trimSpaces(src, &insideComment)) {
if ((c == DELIM_COMMAND) || CO_fifo_trimSpaces(src, &insideComment)) {
st |= CO_fifo_st_closed;
finished = true;
}
@ -1380,7 +1380,7 @@ size_t CO_fifo_cpyTok2B64(CO_fifo_t *dest, CO_fifo_t *src, CO_fifo_st *status) {
if (!finished) {
st |= CO_fifo_st_partial;
/* memorize variables for next iteration */
dest->aux = (uint32_t)step << 24 | (dword & 0xFFFFFF);
dest->aux = ((uint32_t)step << 24) | (dword & 0xFFFFFF);
}
if (status != NULL) *status = st;

48
304/CO_SRDO.c
View file

@ -127,7 +127,7 @@ OD_write_dummy(OD_stream_t *stream, const void *buf, OD_size_t count, OD_size_t
static ODR_t
OD_read_dummy(OD_stream_t *stream, void *buf, OD_size_t count, OD_size_t *countRead)
{
if (buf == NULL || stream == NULL || countRead == NULL) {
if ((buf == NULL) || (stream == NULL) || (countRead == NULL)) {
return ODR_DEV_INCOMPAT;
}
@ -166,7 +166,7 @@ OD_read_SRDO_communicationParam(OD_stream_t* stream, void* buf, OD_size_t count,
ODR_t returnCode = OD_readOriginal(stream, buf, count, countRead);
/* When reading COB_ID, add Node-Id to the read value, if necessary */
if (returnCode == ODR_OK && (stream->subIndex == 5U || stream->subIndex == 6U) && *countRead == 4) {
if ((returnCode == ODR_OK) && ((stream->subIndex == 5U) || (stream->subIndex == 6U)) && (*countRead == 4)) {
CO_SRDO_t* SRDO = stream->object;
uint32_t value = CO_getUint32(buf);
@ -227,7 +227,7 @@ OD_write_SRDO_communicationParam(OD_stream_t* stream, const void* buf, OD_size_t
if (value != 254) {
return ODR_INVALID_VALUE;
}
} else if (stream->subIndex == 5U || stream->subIndex == 6U) { /* COB_ID */
} else if ((stream->subIndex == 5U) || (stream->subIndex == 6U)) { /* COB_ID */
uint32_t value = CO_getUint32(buf);
uint16_t index = stream->subIndex - 5U;
uint16_t defaultCOB_ID = SRDO->defaultCOB_ID + index;
@ -378,7 +378,7 @@ CO_SRDO_init_start(CO_SRDOGuard_t* SRDOGuard, OD_entry_t* OD_13FE_configurationV
/* Configure SRDOGuard->OD_IO_configurationValid variable.
* It will be used for writing 0 to OD variable 13FE,00 */
odRet = OD_getSub(OD_13FE_configurationValid, 0, &SRDOGuard->OD_IO_configurationValid, false);
if (odRet != ODR_OK || SRDOGuard->OD_IO_configurationValid.stream.dataLength != 1) {
if ((odRet != ODR_OK) || (SRDOGuard->OD_IO_configurationValid.stream.dataLength != 1)) {
if (errInfo != NULL) {
*errInfo = (((uint32_t)OD_getIndex(OD_13FE_configurationValid)) << 8) | 1U;
}
@ -497,7 +497,7 @@ CO_SRDO_init(CO_SRDO_t* SRDO, uint8_t SRDO_Index, CO_SRDOGuard_t* SRDOGuard, OD_
}
/* if OD contains default COB_IDs, add node-id */
if (COB_ID1_normal == defaultCOB_ID && COB_ID2_inverted == (defaultCOB_ID + 1) && nodeId <= 64U) {
if ((COB_ID1_normal == defaultCOB_ID) && (COB_ID2_inverted == (defaultCOB_ID + 1)) && (nodeId <= 64U)) {
uint32_t add = (uint32_t)SRDO->nodeId * 2;
COB_ID1_normal += add;
COB_ID2_inverted += add;
@ -510,12 +510,12 @@ CO_SRDO_init(CO_SRDO_t* SRDO, uint8_t SRDO_Index, CO_SRDOGuard_t* SRDOGuard, OD_
}
/* If configurationValid is set and SRDO is valid, continue with further configuration */
if (err == 0 && configurationValid == CO_SRDO_VALID_MAGIC && informationDirection != CO_SRDO_INVALID) {
if ((err == 0) && (configurationValid == CO_SRDO_VALID_MAGIC) && (informationDirection != CO_SRDO_INVALID)) {
configurationInProgress = true;
}
/* Verify parameters from OD */
if (err == 0 && configurationInProgress) {
if ((err == 0) && configurationInProgress) {
if (cp_highestSubindexSupported != 6) {
err = ERR_INFO(0x1301 + SRDO_Index, 0, 2);
}
@ -531,13 +531,13 @@ CO_SRDO_init(CO_SRDO_t* SRDO, uint8_t SRDO_Index, CO_SRDOGuard_t* SRDOGuard, OD_
else if (transmissionType != 254) {
err = ERR_INFO(0x1301 + SRDO_Index, 4, 2);
}
else if (COB_ID1_normal < 0x101 || (COB_ID1_normal & 1) == 0) {
else if ((COB_ID1_normal < 0x101) || ((COB_ID1_normal & 1) == 0)) {
err = ERR_INFO(0x1301 + SRDO_Index, 5, 2);
}
else if ((COB_ID1_normal + 1) != COB_ID2_inverted || COB_ID2_inverted > 0x180) {
else if (((COB_ID1_normal + 1) != COB_ID2_inverted) || (COB_ID2_inverted > 0x180)) {
err = ERR_INFO(0x1301 + SRDO_Index, 6, 2);
}
else if (mappedObjectsCount > CO_SRDO_MAX_MAPPED_ENTRIES || (mappedObjectsCount & 1) != 0) {
else if ((mappedObjectsCount > CO_SRDO_MAX_MAPPED_ENTRIES) || ((mappedObjectsCount & 1) != 0)) {
err = ERR_INFO(0x1381 + SRDO_Index, 0, 2);
}
else {
@ -546,7 +546,7 @@ CO_SRDO_init(CO_SRDO_t* SRDO, uint8_t SRDO_Index, CO_SRDOGuard_t* SRDOGuard, OD_
}
/* Verify CRC */
if (err == 0 && configurationInProgress) {
if ((err == 0) && configurationInProgress) {
uint16_t crcResult = 0x0000;
uint16_t tmp_u16;
uint32_t tmp_u32;
@ -573,7 +573,7 @@ CO_SRDO_init(CO_SRDO_t* SRDO, uint8_t SRDO_Index, CO_SRDOGuard_t* SRDOGuard, OD_
}
/* Configure mappings */
if (err == 0 && configurationInProgress) {
if ((err == 0) && configurationInProgress) {
size_t srdoDataLength[2] = {0, 0};
for (uint8_t i = 0; i < mappedObjectsCount; i++) {
@ -590,7 +590,7 @@ CO_SRDO_init(CO_SRDO_t* SRDO, uint8_t SRDO_Index, CO_SRDOGuard_t* SRDOGuard, OD_
err = ERR_INFO(0x1381 + SRDO_Index, i + 1, 4);
}
/* is there a reference to the dummy entry */
else if (index < 0x20 && subIndex == 0) {
else if ((index < 0x20) && (subIndex == 0)) {
OD_stream_t *stream = &OD_IO->stream;
(void)memset(stream, 0, sizeof(OD_stream_t));
stream->dataLength = stream->dataOffset = mappedLength;
@ -608,9 +608,9 @@ CO_SRDO_init(CO_SRDO_t* SRDO, uint8_t SRDO_Index, CO_SRDOGuard_t* SRDOGuard, OD_
else {
/* verify access attributes, byte alignment and length */
OD_attr_t testAttribute = (informationDirection == CO_SRDO_RX) ? ODA_RSRDO : ODA_TSRDO;
if ((OD_IOcopy.stream.attribute & testAttribute) == 0
|| (mappedLengthBits & 0x07) != 0
|| OD_IOcopy.stream.dataLength < mappedLength
if (((OD_IOcopy.stream.attribute & testAttribute) == 0)
|| ((mappedLengthBits & 0x07) != 0)
|| (OD_IOcopy.stream.dataLength < mappedLength)
) {
err = ERR_INFO(0x1381 + SRDO_Index, i + 1, 6);
}
@ -630,7 +630,7 @@ CO_SRDO_init(CO_SRDO_t* SRDO, uint8_t SRDO_Index, CO_SRDOGuard_t* SRDOGuard, OD_
if (srdoDataLength[0] != srdoDataLength[1]) {
err = ERR_INFO(0x1381 + SRDO_Index, 0, 7);
}
else if (srdoDataLength[0] == 0 || srdoDataLength[0] > CO_SRDO_MAX_SIZE) {
else if ((srdoDataLength[0] == 0) || (srdoDataLength[0] > CO_SRDO_MAX_SIZE)) {
err = ERR_INFO(0x1381 + SRDO_Index, 0, 8);
}
else {
@ -641,7 +641,7 @@ CO_SRDO_init(CO_SRDO_t* SRDO, uint8_t SRDO_Index, CO_SRDOGuard_t* SRDOGuard, OD_
}
/* Configure CAN tx buffers */
if (err == 0 && configurationInProgress && informationDirection == CO_SRDO_TX) {
if ((err == 0) && configurationInProgress && (informationDirection == CO_SRDO_TX)) {
SRDO->CANtxBuff[0] = CO_CANtxBufferInit(CANdevTxNormal, /* CAN device */
CANdevTxIdxNormal, /* index of specific buffer inside CAN module */
@ -667,7 +667,7 @@ CO_SRDO_init(CO_SRDO_t* SRDO, uint8_t SRDO_Index, CO_SRDOGuard_t* SRDOGuard, OD_
}
/* Configure CAN rx buffers */
if (err == 0 && configurationInProgress && informationDirection == CO_SRDO_RX) {
if ((err == 0) && configurationInProgress && (informationDirection == CO_SRDO_RX)) {
CO_ReturnError_t ret;
ret = CO_CANrxBufferInit(CANdevRxNormal, /* CAN device */
@ -739,15 +739,15 @@ CO_SRDO_state_t
CO_SRDO_process(CO_SRDO_t* SRDO, uint32_t timeDifference_us, uint32_t* timerNext_us, bool_t NMTisOperational) {
(void)timerNext_us; /* may be unused */
if (NMTisOperational && SRDO->informationDirection != CO_SRDO_INVALID && SRDO->SRDOGuard->configurationValid
&& SRDO->internalState >= CO_SRDO_state_unknown) {
if (NMTisOperational && (SRDO->informationDirection != CO_SRDO_INVALID) && SRDO->SRDOGuard->configurationValid
&& (SRDO->internalState >= CO_SRDO_state_unknown)) {
SRDO->cycleTimer = (SRDO->cycleTimer > timeDifference_us) ? (SRDO->cycleTimer - timeDifference_us) : 0U;
SRDO->validationTimer = (SRDO->validationTimer > timeDifference_us) ? (SRDO->validationTimer - timeDifference_us) : 0U;
/* Detect transition to NMT operational */
if (!SRDO->NMTisOperationalPrevious) {
SRDO->cycleTimer = (SRDO->informationDirection == CO_SRDO_TX)
? (uint32_t)SRDO->nodeId * 500U /* 0.5ms * node-ID delay*/
? ((uint32_t)SRDO->nodeId * 500U) /* 0.5ms * node-ID delay*/
: SRDO->cycleTime_us;
SRDO->validationTimer = SRDO->cycleTime_us;
SRDO->internalState = CO_SRDO_state_initializing;
@ -822,7 +822,7 @@ CO_SRDO_process(CO_SRDO_t* SRDO, uint32_t timeDifference_us, uint32_t* timerNext
dataSRDO[plain_inverted] += mappedLength;
}
if (verifyLength[0] != verifyLength[1] || verifyLength[0] > CO_SRDO_MAX_SIZE || verifyLength[0] != SRDO->dataLength) {
if ((verifyLength[0] != verifyLength[1]) || (verifyLength[0] > CO_SRDO_MAX_SIZE) || (verifyLength[0] != SRDO->dataLength)) {
SRDO->internalState = CO_SRDO_state_error_internal; /* should not happen */
}
else {
@ -955,7 +955,7 @@ CO_SRDO_process(CO_SRDO_t* SRDO, uint32_t timeDifference_us, uint32_t* timerNext
} /* for (uint8_t i = 0; i < SRDO->mappedObjectsCount; i++) */
/* safety check, this should not happen */
if (verifyLength[0] != verifyLength[1] || verifyLength[0] > CO_SRDO_MAX_SIZE || verifyLength[0] != SRDO->dataLength) {
if ((verifyLength[0] != verifyLength[1]) || (verifyLength[0] > CO_SRDO_MAX_SIZE) || (verifyLength[0] != SRDO->dataLength)) {
SRDO->internalState = CO_SRDO_state_error_internal;
}
else {

10
305/CO_LSS.h
View file

@ -220,16 +220,16 @@ static const uint16_t CO_LSS_bitTimingTableLookup[] = {
/**
* Macro to check if node id is valid
*/
#define CO_LSS_NODE_ID_VALID(nid) ((nid >= 1 && nid <= 0x7F) || nid == CO_LSS_NODE_ID_ASSIGNMENT)
#define CO_LSS_NODE_ID_VALID(nid) (((nid >= 1) && (nid <= 0x7F)) || (nid == CO_LSS_NODE_ID_ASSIGNMENT))
/**
* Macro to check if two LSS addresses are equal
*/
#define CO_LSS_ADDRESS_EQUAL(/*CO_LSS_address_t*/ a1, /*CO_LSS_address_t*/ a2) \
(a1.identity.productCode == a2.identity.productCode && \
a1.identity.revisionNumber == a2.identity.revisionNumber && \
a1.identity.serialNumber == a2.identity.serialNumber && \
a1.identity.vendorID == a2.identity.vendorID)
((a1.identity.productCode == a2.identity.productCode) && \
(a1.identity.revisionNumber == a2.identity.revisionNumber) && \
(a1.identity.serialNumber == a2.identity.serialNumber) && \
(a1.identity.vendorID == a2.identity.vendorID))
/** @} */ /*@defgroup CO_LSS*/

66
305/CO_LSSmaster.c
View file

@ -83,8 +83,8 @@ static void CO_LSSmaster_receive(void *object, void *msg)
LSSmaster = (CO_LSSmaster_t*)object; /* this is the correct pointer type of the first argument */
/* verify message length and message overflow (previous message was not processed yet) */
if(DLC==8 && !CO_FLAG_READ(LSSmaster->CANrxNew) &&
LSSmaster->command!=CO_LSSmaster_COMMAND_WAITING){
if((DLC==8) && !CO_FLAG_READ(LSSmaster->CANrxNew) &&
(LSSmaster->command!=CO_LSSmaster_COMMAND_WAITING)){
/* copy data and set 'new message' flag */
(void)memcpy(LSSmaster->CANrxData, data, sizeof(LSSmaster->CANrxData));
@ -137,7 +137,7 @@ CO_ReturnError_t CO_LSSmaster_init(
CO_ReturnError_t ret = CO_ERROR_NO;
/* verify arguments */
if (LSSmaster==NULL || CANdevRx==NULL || CANdevTx==NULL){
if ((LSSmaster==NULL) || (CANdevRx==NULL) || (CANdevTx==NULL)){
return CO_ERROR_ILLEGAL_ARGUMENT;
}
@ -295,8 +295,8 @@ CO_LSSmaster_return_t CO_LSSmaster_switchStateSelect(
}
/* Initiate select */
if (LSSmaster->state==CO_LSSmaster_STATE_WAITING &&
LSSmaster->command==CO_LSSmaster_COMMAND_WAITING){
if ((LSSmaster->state==CO_LSSmaster_STATE_WAITING) &&
(LSSmaster->command==CO_LSSmaster_COMMAND_WAITING)){
ret = CO_LSSmaster_switchStateSelectInitiate(LSSmaster, lssAddress);
}
@ -305,7 +305,7 @@ CO_LSSmaster_return_t CO_LSSmaster_switchStateSelect(
ret = CO_LSSmaster_switchStateSelectWait(LSSmaster, timeDifference_us);
}
if (ret!=CO_LSSmaster_INVALID_STATE && ret!=CO_LSSmaster_WAIT_SLAVE) {
if ((ret!=CO_LSSmaster_INVALID_STATE) && (ret!=CO_LSSmaster_WAIT_SLAVE)) {
/* finished */
LSSmaster->command = CO_LSSmaster_COMMAND_WAITING;
}
@ -397,7 +397,7 @@ static CO_LSSmaster_return_t CO_LSSmaster_configureCheckWait(
ret = CO_LSSmaster_check_timeout(LSSmaster, timeDifference_us);
}
if (ret!=CO_LSSmaster_INVALID_STATE && ret!=CO_LSSmaster_WAIT_SLAVE) {
if ((ret!=CO_LSSmaster_INVALID_STATE) && (ret!=CO_LSSmaster_WAIT_SLAVE)) {
/* finished */
LSSmaster->command = CO_LSSmaster_COMMAND_WAITING;
}
@ -432,8 +432,8 @@ CO_LSSmaster_return_t CO_LSSmaster_configureBitTiming(
}
/* Initiate config bit */
if (LSSmaster->state==CO_LSSmaster_STATE_CFG_SLECTIVE &&
LSSmaster->command==CO_LSSmaster_COMMAND_WAITING){
if ((LSSmaster->state==CO_LSSmaster_STATE_CFG_SLECTIVE) &&
(LSSmaster->command==CO_LSSmaster_COMMAND_WAITING)){
LSSmaster->command = CO_LSSmaster_COMMAND_CFG_BIT_TIMING;
LSSmaster->timeoutTimer = 0;
@ -454,7 +454,7 @@ CO_LSSmaster_return_t CO_LSSmaster_configureBitTiming(
CO_LSS_CFG_BIT_TIMING);
}
if (ret!=CO_LSSmaster_INVALID_STATE && ret!=CO_LSSmaster_WAIT_SLAVE) {
if ((ret!=CO_LSSmaster_INVALID_STATE) && (ret!=CO_LSSmaster_WAIT_SLAVE)) {
/* finished */
LSSmaster->command = CO_LSSmaster_COMMAND_WAITING;
}
@ -470,16 +470,16 @@ CO_LSSmaster_return_t CO_LSSmaster_configureNodeId(
{
CO_LSSmaster_return_t ret = CO_LSSmaster_INVALID_STATE;
if (LSSmaster==NULL || !CO_LSS_NODE_ID_VALID(nodeId)){
if ((LSSmaster==NULL) || !CO_LSS_NODE_ID_VALID(nodeId)){
return CO_LSSmaster_ILLEGAL_ARGUMENT;
}
/* Initiate config node ID */
if ((LSSmaster->state==CO_LSSmaster_STATE_CFG_SLECTIVE ||
if (((LSSmaster->state==CO_LSSmaster_STATE_CFG_SLECTIVE) ||
/* Let un-config node ID also be run in global mode for unconfiguring all nodes */
(LSSmaster->state==CO_LSSmaster_STATE_CFG_GLOBAL &&
nodeId == CO_LSS_NODE_ID_ASSIGNMENT)) &&
LSSmaster->command==CO_LSSmaster_COMMAND_WAITING) {
((LSSmaster->state==CO_LSSmaster_STATE_CFG_GLOBAL) &&
(nodeId == CO_LSS_NODE_ID_ASSIGNMENT))) &&
(LSSmaster->command==CO_LSSmaster_COMMAND_WAITING)) {
LSSmaster->command = CO_LSSmaster_COMMAND_CFG_NODE_ID;
LSSmaster->timeoutTimer = 0;
@ -499,7 +499,7 @@ CO_LSSmaster_return_t CO_LSSmaster_configureNodeId(
CO_LSS_CFG_NODE_ID);
}
if (ret!=CO_LSSmaster_INVALID_STATE && ret!=CO_LSSmaster_WAIT_SLAVE) {
if ((ret!=CO_LSSmaster_INVALID_STATE) && (ret!=CO_LSSmaster_WAIT_SLAVE)) {
/* finished */
LSSmaster->command = CO_LSSmaster_COMMAND_WAITING;
}
@ -519,8 +519,8 @@ CO_LSSmaster_return_t CO_LSSmaster_configureStore(
}
/* Initiate config store */
if (LSSmaster->state==CO_LSSmaster_STATE_CFG_SLECTIVE &&
LSSmaster->command==CO_LSSmaster_COMMAND_WAITING){
if ((LSSmaster->state==CO_LSSmaster_STATE_CFG_SLECTIVE) &&
(LSSmaster->command==CO_LSSmaster_COMMAND_WAITING)){
LSSmaster->command = CO_LSSmaster_COMMAND_CFG_STORE;
LSSmaster->timeoutTimer = 0;
@ -539,7 +539,7 @@ CO_LSSmaster_return_t CO_LSSmaster_configureStore(
CO_LSS_CFG_STORE);
}
if (ret!=CO_LSSmaster_INVALID_STATE && ret!=CO_LSSmaster_WAIT_SLAVE) {
if ((ret!=CO_LSSmaster_INVALID_STATE) && (ret!=CO_LSSmaster_WAIT_SLAVE)) {
/* finished */
LSSmaster->command = CO_LSSmaster_COMMAND_WAITING;
}
@ -560,8 +560,8 @@ CO_LSSmaster_return_t CO_LSSmaster_ActivateBit(
/* for activating bit timing, we need to have all slaves set to config
* state. This check makes it a bit harder to shoot ourselves in the foot */
if (LSSmaster->state==CO_LSSmaster_STATE_CFG_GLOBAL &&
LSSmaster->command==CO_LSSmaster_COMMAND_WAITING){
if ((LSSmaster->state==CO_LSSmaster_STATE_CFG_GLOBAL) &&
(LSSmaster->command==CO_LSSmaster_COMMAND_WAITING)){
CO_FLAG_CLEAR(LSSmaster->CANrxNew);
LSSmaster->TXbuff->data[0] = CO_LSS_CFG_ACTIVATE_BIT_TIMING;
@ -630,7 +630,7 @@ CO_LSSmaster_return_t CO_LSSmaster_InquireLssAddress(
CO_LSSmaster_return_t ret = CO_LSSmaster_INVALID_STATE;
CO_LSSmaster_command_t next = CO_LSSmaster_COMMAND_WAITING;
if (LSSmaster==NULL || lssAddress==NULL){
if ((LSSmaster==NULL) || (lssAddress==NULL)){
return CO_LSSmaster_ILLEGAL_ARGUMENT;
}
@ -671,8 +671,8 @@ CO_LSSmaster_return_t CO_LSSmaster_InquireLssAddress(
CO_LSS_INQUIRE_SERIAL, &lssAddress->identity.serialNumber);
}
/* Check for next request */
if (LSSmaster->state == CO_LSSmaster_STATE_CFG_SLECTIVE ||
LSSmaster->state == CO_LSSmaster_STATE_CFG_GLOBAL) {
if ((LSSmaster->state == CO_LSSmaster_STATE_CFG_SLECTIVE) ||
(LSSmaster->state == CO_LSSmaster_STATE_CFG_GLOBAL)) {
if (LSSmaster->command == CO_LSSmaster_COMMAND_WAITING) {
LSSmaster->command = CO_LSSmaster_COMMAND_INQUIRE_VENDOR;
@ -700,7 +700,7 @@ CO_LSSmaster_return_t CO_LSSmaster_InquireLssAddress(
}
}
if (ret!=CO_LSSmaster_INVALID_STATE && ret!=CO_LSSmaster_WAIT_SLAVE) {
if ((ret!=CO_LSSmaster_INVALID_STATE) && (ret!=CO_LSSmaster_WAIT_SLAVE)) {
/* finished */
LSSmaster->command = CO_LSSmaster_COMMAND_WAITING;
}
@ -717,14 +717,14 @@ CO_LSSmaster_return_t CO_LSSmaster_Inquire(
{
CO_LSSmaster_return_t ret = CO_LSSmaster_INVALID_STATE;
if (LSSmaster==NULL || value==NULL){
if ((LSSmaster==NULL) || (value==NULL)){
return CO_LSSmaster_ILLEGAL_ARGUMENT;
}
/* send request */
if ((LSSmaster->state==CO_LSSmaster_STATE_CFG_SLECTIVE ||
LSSmaster->state==CO_LSSmaster_STATE_CFG_GLOBAL) &&
LSSmaster->command == CO_LSSmaster_COMMAND_WAITING) {
if (((LSSmaster->state==CO_LSSmaster_STATE_CFG_SLECTIVE) ||
(LSSmaster->state==CO_LSSmaster_STATE_CFG_GLOBAL)) &&
(LSSmaster->command == CO_LSSmaster_COMMAND_WAITING)) {
LSSmaster->command = CO_LSSmaster_COMMAND_INQUIRE;
LSSmaster->timeoutTimer = 0;
@ -988,7 +988,7 @@ CO_LSSmaster_return_t CO_LSSmaster_IdentifyFastscan(
CO_LSS_fastscan_lss_sub_next next;
/* parameter validation */
if (LSSmaster==NULL || fastscan==NULL){
if ((LSSmaster==NULL) || (fastscan==NULL)){
return CO_LSSmaster_ILLEGAL_ARGUMENT;
}
if (fastscan->scan[0] == CO_LSSmaster_FS_SKIP) {
@ -1007,9 +1007,9 @@ CO_LSSmaster_return_t CO_LSSmaster_IdentifyFastscan(
}
/* state machine validation */
if (LSSmaster->state!=CO_LSSmaster_STATE_WAITING ||
(LSSmaster->command!=CO_LSSmaster_COMMAND_WAITING &&
LSSmaster->command!=CO_LSSmaster_COMMAND_IDENTIFY_FASTSCAN)) {
if ((LSSmaster->state!=CO_LSSmaster_STATE_WAITING) ||
((LSSmaster->command!=CO_LSSmaster_COMMAND_WAITING) &&
(LSSmaster->command!=CO_LSSmaster_COMMAND_IDENTIFY_FASTSCAN))) {
/* state machine not ready, other command is already processed */
return CO_LSSmaster_INVALID_STATE;
}

24
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<=CO_LSS_FASTSCAN_BIT31) || (bit==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)
/* '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 != 5) && (index <= CO_LSS_BIT_TIMING_AUTO))
/*
* Read received message from CAN module.
@ -50,7 +50,7 @@ static void CO_LSSslave_receive(void *object, void *msg)
CO_LSSslave_t *LSSslave = (CO_LSSslave_t*)object;
uint8_t DLC = CO_CANrxMsg_readDLC(msg);
if(DLC == 8U && !CO_FLAG_READ(LSSslave->sendResponse)) {
if((DLC == 8U) && !CO_FLAG_READ(LSSslave->sendResponse)) {
bool_t request_LSSslave_process = false;
uint8_t *data = CO_CANrxMsg_readData(msg);
CO_LSS_cs_t cs = (CO_LSS_cs_t) data[0];
@ -60,9 +60,9 @@ static void CO_LSSslave_receive(void *object, void *msg)
switch (mode) {
case CO_LSS_STATE_WAITING:
if (LSSslave->lssState == CO_LSS_STATE_CONFIGURATION &&
LSSslave->activeNodeID == CO_LSS_NODE_ID_ASSIGNMENT &&
*LSSslave->pendingNodeID != CO_LSS_NODE_ID_ASSIGNMENT)
if ((LSSslave->lssState == CO_LSS_STATE_CONFIGURATION) &&
(LSSslave->activeNodeID == CO_LSS_NODE_ID_ASSIGNMENT) &&
(*LSSslave->pendingNodeID != CO_LSS_NODE_ID_ASSIGNMENT))
{
/* Slave process function will request NMT Reset comm.*/
LSSslave->service = cs;
@ -115,8 +115,8 @@ static void CO_LSSslave_receive(void *object, void *msg)
}
case CO_LSS_IDENT_FASTSCAN: {
/* fastscan is only active on unconfigured nodes */
if (*LSSslave->pendingNodeID == CO_LSS_NODE_ID_ASSIGNMENT &&
LSSslave->activeNodeID == CO_LSS_NODE_ID_ASSIGNMENT)
if ((*LSSslave->pendingNodeID == CO_LSS_NODE_ID_ASSIGNMENT) &&
(LSSslave->activeNodeID == CO_LSS_NODE_ID_ASSIGNMENT))
{
uint8_t bitCheck = data[5];
uint8_t lssSub = data[6];
@ -153,7 +153,7 @@ static void CO_LSSslave_receive(void *object, void *msg)
ack = true;
LSSslave->fastscanPos = lssNext;
if (bitCheck == 0 && lssNext < lssSub) {
if ((bitCheck == 0) && (lssNext < lssSub)) {
/* complete match, enter configuration state */
LSSslave->lssState = CO_LSS_STATE_CONFIGURATION;
}
@ -215,8 +215,8 @@ CO_ReturnError_t CO_LSSslave_init(
CO_ReturnError_t ret = CO_ERROR_NO;
/* verify arguments */
if (LSSslave==NULL || pendingBitRate == NULL || pendingNodeID == NULL ||
CANdevRx==NULL || CANdevTx==NULL ||
if ((LSSslave==NULL) || (pendingBitRate == NULL) || (pendingNodeID == NULL) ||
(CANdevRx==NULL) || (CANdevTx==NULL) ||
!CO_LSS_NODE_ID_VALID(*pendingNodeID)
) {
return CO_ERROR_ILLEGAL_ARGUMENT;
@ -375,7 +375,7 @@ bool_t CO_LSSslave_process(CO_LSSslave_t *LSSslave) {
errorCode = CO_LSS_CFG_BIT_TIMING_OK;
errorCodeManuf = CO_LSS_CFG_BIT_TIMING_OK;
if (tableSelector == 0 && CO_LSS_BIT_TIMING_VALID(tableIndex)) {
if ((tableSelector == 0) && CO_LSS_BIT_TIMING_VALID(tableIndex)) {
uint16_t bit = CO_LSS_bitTimingTableLookup[tableIndex];
bool_t bit_rate_supported = LSSslave->pFunctLSScheckBitRate(
LSSslave->functLSScheckBitRateObject, bit);

94
309/CO_gateway_ascii.c
View file

@ -139,7 +139,7 @@ void CO_GTWA_initRead(CO_GTWA_t* gtwa,
/******************************************************************************/
#if (CO_CONFIG_GTW) & CO_CONFIG_GTW_ASCII_LOG
void CO_GTWA_log_print(CO_GTWA_t* gtwa, const char *message) {
if (gtwa != NULL && message != NULL) {
if ((gtwa != NULL) && (message != NULL)) {
const char *c;
for (c = &message[0]; *c != 0; c++) {
@ -243,7 +243,7 @@ static inline uint32_t getU32(char *token, uint32_t min,
char *sRet;
uint32_t num = strtoul(token, &sRet, 0);
if (sRet != strchr(token, '\0') || num < min || num > max) {
if ((sRet != strchr(token, '\0')) || (num < min) || (num > max)) {
*err = true;
}
@ -262,7 +262,7 @@ static bool_t checkNetNode(CO_GTWA_t *gtwa,
eCode = CO_GTWA_respErrorNoDefaultNodeSet;
e = true;
}
else if (node < NodeMin || node > 127) {
else if ((node < NodeMin) || (node > 127)) {
eCode = CO_GTWA_respErrorUnsupportedNode;
e = true;
}
@ -349,7 +349,7 @@ static const CO_GTWA_dataType_t dataTypes[] = {
/* get data type from token */
static const CO_GTWA_dataType_t *CO_GTWA_getDataType(char *token, bool_t *err) {
if (token != NULL && *err == false) {
if ((token != NULL) && (*err == false)) {
int i;
int len = sizeof(dataTypes) / sizeof(CO_GTWA_dataType_t);
@ -655,7 +655,7 @@ void CO_GTWA_process(CO_GTWA_t *gtwa,
* COMMAND PARSER
***************************************************************************/
/* if idle, search for new command, skip comments or empty lines */
while (gtwa->state == CO_GTWA_ST_IDLE
while ((gtwa->state == CO_GTWA_ST_IDLE)
&& CO_fifo_CommSearch(&gtwa->commFifo, false)
) {
char tok[20];
@ -671,16 +671,16 @@ void CO_GTWA_process(CO_GTWA_t *gtwa,
n = CO_fifo_readToken(&gtwa->commFifo, tok, sizeof(tok), &closed, &err);
/* Break if error in token or token was found, but closed with
* command delimiter. */
if (err || (n > 0 && closed != 0)) {
if (err || ((n > 0) && (closed != 0))) {
err = true;
break;
}
/* If empty line or just comment, continue with next command */
else if (n == 0 && closed != 0) {
else if ((n == 0) && (closed != 0)) {
responseWithEmpty(gtwa);
continue;
}
if (tok[0] != '[' || tok[strlen(tok)-1] != ']') {
if ((tok[0] != '[') || (tok[strlen(tok)-1] != ']')) {
err = true;
break;
}
@ -695,7 +695,7 @@ void CO_GTWA_process(CO_GTWA_t *gtwa,
closed = -1;
n = CO_fifo_readToken(&gtwa->commFifo, tok, sizeof(tok),
&closed, &err);
if (err || n == 0) {
if (err || (n == 0)) {
/* empty token, break on error */
err = true;
break;
@ -789,7 +789,7 @@ void CO_GTWA_process(CO_GTWA_t *gtwa,
bool_t NodeErr = checkNet(gtwa, net, &respErrorCode);
uint8_t value;
if (closed != 0 || NodeErr) {
if ((closed != 0) || NodeErr) {
err = true;
break;
}
@ -810,7 +810,7 @@ void CO_GTWA_process(CO_GTWA_t *gtwa,
bool_t NodeErr = checkNet(gtwa, net, &respErrorCode);
uint16_t value;
if (closed != 0 || NodeErr) {
if ((closed != 0) || NodeErr) {
err = true;
break;
}
@ -830,7 +830,7 @@ void CO_GTWA_process(CO_GTWA_t *gtwa,
bool_t NodeErr = checkNet(gtwa, net, &respErrorCode);
uint16_t value;
if (closed != 0 || NodeErr) {
if ((closed != 0) || NodeErr) {
err = true;
break;
}
@ -842,7 +842,7 @@ void CO_GTWA_process(CO_GTWA_t *gtwa,
value = (uint16_t)getU32(tok, 0, 1, &err);
if (err) break;
gtwa->SDOblockTransferEnable = value==1 ? true : false;
gtwa->SDOblockTransferEnable = (value==1) ? true : false;
responseWithOK(gtwa);
}
#endif /* (CO_CONFIG_GTW) & CO_CONFIG_GTW_ASCII_SDO */
@ -855,13 +855,13 @@ void CO_GTWA_process(CO_GTWA_t *gtwa,
#if (CO_CONFIG_GTW) & CO_CONFIG_GTW_ASCII_SDO
/* Upload SDO command - 'r[ead] <index> <subindex> <datatype>' */
else if (strcmp(tok, "r") == 0 || strcmp(tok, "read") == 0) {
else if ((strcmp(tok, "r") == 0) || (strcmp(tok, "read") == 0)) {
uint16_t idx;
uint8_t subidx;
CO_SDO_return_t SDO_ret;
bool_t NodeErr = checkNetNode(gtwa, net, node, 1, &respErrorCode);
if (closed != 0 || NodeErr) {
if ((closed != 0) || NodeErr) {
err = true;
break;
}
@ -877,7 +877,7 @@ void CO_GTWA_process(CO_GTWA_t *gtwa,
n = CO_fifo_readToken(&gtwa->commFifo, tok, sizeof(tok),
&closed, &err);
subidx = (uint8_t)getU32(tok, 0, 0xFF, &err);
if (err || n == 0) {
if (err || (n == 0)) {
err = true;
break;
}
@ -924,7 +924,7 @@ void CO_GTWA_process(CO_GTWA_t *gtwa,
}
/* Download SDO comm. - w[rite] <index> <subindex> <datatype> <value> */
else if (strcmp(tok, "w") == 0 || strcmp(tok, "write") == 0) {
else if ((strcmp(tok, "w") == 0) || (strcmp(tok, "write") == 0)) {
uint16_t idx;
uint8_t subidx;
CO_fifo_st status;
@ -932,7 +932,7 @@ void CO_GTWA_process(CO_GTWA_t *gtwa,
size_t size;
bool_t NodeErr = checkNetNode(gtwa, net, node, 1, &respErrorCode);
if (closed != 0 || NodeErr) {
if ((closed != 0) || NodeErr) {
err = true;
break;
}
@ -992,15 +992,15 @@ void CO_GTWA_process(CO_GTWA_t *gtwa,
/* is syntax error in command or size is zero or not the last token
* in command */
if ((status & CO_fifo_st_errMask) != 0 || size == 0
|| (gtwa->SDOdataCopyStatus == false && closed != 1)
if (((status & CO_fifo_st_errMask) != 0) || (size == 0)
|| ((gtwa->SDOdataCopyStatus == false) && (closed != 1))
) {
err = true;
break;
}
/* if data size was not known before and is known now, update SDO */
if (gtwa->SDOdataType->length == 0 && !gtwa->SDOdataCopyStatus) {
if ((gtwa->SDOdataType->length == 0) && !gtwa->SDOdataCopyStatus) {
CO_SDOclientDownloadInitiateSize(gtwa->SDO_C, size);
}
@ -1018,7 +1018,7 @@ void CO_GTWA_process(CO_GTWA_t *gtwa,
bool_t NodeErr = checkNetNode(gtwa, net, node, 0, &respErrorCode);
CO_NMT_command_t command2 = CO_NMT_ENTER_OPERATIONAL;
if (closed != 1 || NodeErr) {
if ((closed != 1) || NodeErr) {
err = true;
break;
}
@ -1040,7 +1040,7 @@ void CO_GTWA_process(CO_GTWA_t *gtwa,
bool_t NodeErr = checkNetNode(gtwa, net, node, 0, &respErrorCode);
CO_NMT_command_t command2 = CO_NMT_ENTER_STOPPED;
if (closed != 1 || NodeErr) {
if ((closed != 1) || NodeErr) {
err = true;
break;
}
@ -1057,14 +1057,14 @@ void CO_GTWA_process(CO_GTWA_t *gtwa,
}
/* NMT Set node to pre-operational - 'preop[erational]' */
else if (strcmp(tok, "preop") == 0 ||
strcmp(tok, "preoperational") == 0
else if ((strcmp(tok, "preop") == 0) ||
(strcmp(tok, "preoperational") == 0)
) {
CO_ReturnError_t ret;
bool_t NodeErr = checkNetNode(gtwa, net, node, 0, &respErrorCode);
CO_NMT_command_t command2 = CO_NMT_ENTER_PRE_OPERATIONAL;
if (closed != 1 || NodeErr) {
if ((closed != 1) || NodeErr) {
err = true;
break;
}
@ -1086,7 +1086,7 @@ void CO_GTWA_process(CO_GTWA_t *gtwa,
bool_t NodeErr = checkNetNode(gtwa, net, node, 0, &respErrorCode);
CO_NMT_command_t command2;
if (closed != 0 || NodeErr) {
if ((closed != 0) || NodeErr) {
err = true;
break;
}
@ -1099,8 +1099,8 @@ void CO_GTWA_process(CO_GTWA_t *gtwa,
convertToLower(tok, sizeof(tok));
if (strcmp(tok, "node") == 0) {
command2 = CO_NMT_RESET_NODE;
} else if (strcmp(tok, "comm") == 0 ||
strcmp(tok, "communication") == 0
} else if ((strcmp(tok, "comm") == 0) ||
(strcmp(tok, "communication") == 0)
) {
command2 = CO_NMT_RESET_COMMUNICATION;
} else {
@ -1127,7 +1127,7 @@ void CO_GTWA_process(CO_GTWA_t *gtwa,
bool_t NodeErr = checkNet(gtwa, net, &respErrorCode);
uint8_t select;
if (closed != 0 || NodeErr) {
if ((closed != 0) || NodeErr) {
err = true;
break;
}
@ -1162,7 +1162,7 @@ void CO_GTWA_process(CO_GTWA_t *gtwa,
bool_t NodeErr = checkNet(gtwa, net, &respErrorCode);
CO_LSS_address_t *addr = &gtwa->lssAddress;
if (closed != 0 || NodeErr) {
if ((closed != 0) || NodeErr) {
err = true;
break;
}
@ -1193,7 +1193,7 @@ void CO_GTWA_process(CO_GTWA_t *gtwa,
else if (strcmp(tok, "lss_set_node") == 0) {
bool_t NodeErr = checkNet(gtwa, net, &respErrorCode);
if (closed != 0 || NodeErr) {
if ((closed != 0) || NodeErr) {
err = true;
break;
}
@ -1202,7 +1202,7 @@ void CO_GTWA_process(CO_GTWA_t *gtwa,
closed = 1;
CO_fifo_readToken(&gtwa->commFifo, tok, sizeof(tok), &closed, &err);
gtwa->lssNID = (uint8_t)getU32(tok, 0, 0xFF, &err);
if (gtwa->lssNID > 0x7F && gtwa->lssNID < 0xFF) err = true;
if ((gtwa->lssNID > 0x7F) && (gtwa->lssNID < 0xFF)) err = true;
if (err) break;
/* continue with state machine */
@ -1218,7 +1218,7 @@ void CO_GTWA_process(CO_GTWA_t *gtwa,
int maxIndex = (sizeof(CO_LSS_bitTimingTableLookup) /
sizeof(CO_LSS_bitTimingTableLookup[0])) - 1;
if (closed != 0 || NodeErr) {
if ((closed != 0)|| NodeErr) {
err = true;
break;
}
@ -1247,7 +1247,7 @@ void CO_GTWA_process(CO_GTWA_t *gtwa,
uint16_t switchDelay;
CO_LSSmaster_return_t ret;
if (closed != 0 || NodeErr) {
if ((closed != 0) || NodeErr) {
err = true;
break;
}
@ -1273,7 +1273,7 @@ void CO_GTWA_process(CO_GTWA_t *gtwa,
else if (strcmp(tok, "lss_store") == 0) {
bool_t NodeErr = checkNet(gtwa, net, &respErrorCode);
if (closed != 1 || NodeErr) {
if ((closed != 1) || NodeErr) {
err = true;
break;
}
@ -1316,7 +1316,7 @@ void CO_GTWA_process(CO_GTWA_t *gtwa,
else if (strcmp(tok, "lss_get_node") == 0) {
bool_t NodeErr = checkNet(gtwa, net, &respErrorCode);
if (closed != 1 || NodeErr) {
if ((closed != 1) || NodeErr) {
err = true;
break;
}
@ -1389,7 +1389,7 @@ void CO_GTWA_process(CO_GTWA_t *gtwa,
}
/* If timeout not specified, use 100ms. Should work in most cases */
gtwa->lssTimeout_ms = timeout_ms == 0 ? 100 : timeout_ms;
gtwa->lssTimeout_ms = (timeout_ms == 0) ? 100 : timeout_ms;
CO_LSSmaster_changeTimeout(gtwa->LSSmaster, gtwa->lssTimeout_ms);
gtwa->lssNodeCount = 0;
gtwa->lssSubState = 0;
@ -1568,8 +1568,8 @@ void CO_GTWA_process(CO_GTWA_t *gtwa,
gtwa->state = CO_GTWA_ST_IDLE;
}
/* Response data must be read, partially or whole */
else if (ret == CO_SDO_RT_uploadDataBufferFull
|| ret == CO_SDO_RT_ok_communicationEnd
else if ((ret == CO_SDO_RT_uploadDataBufferFull)
|| (ret == CO_SDO_RT_ok_communicationEnd)
) {
size_t fifoRemain;
@ -1595,7 +1595,7 @@ void CO_GTWA_process(CO_GTWA_t *gtwa,
fifoRemain = CO_fifo_getOccupied(&gtwa->SDO_C->bufFifo);
/* end of communication, print newline and enter idle state */
if (ret == CO_SDO_RT_ok_communicationEnd && fifoRemain == 0) {
if ((ret == CO_SDO_RT_ok_communicationEnd) && (fifoRemain == 0)) {
gtwa->respBufCount +=
sprintf(&gtwa->respBuf[gtwa->respBufCount], "\r\n");
gtwa->state = CO_GTWA_ST_IDLE;
@ -1615,7 +1615,7 @@ void CO_GTWA_process(CO_GTWA_t *gtwa,
gtwa->state = CO_GTWA_ST_IDLE;
break;
}
} while (gtwa->respHold == false && fifoRemain > 0);
} while ((gtwa->respHold == false) && (fifoRemain > 0));
}
break;
}
@ -1641,8 +1641,8 @@ void CO_GTWA_process(CO_GTWA_t *gtwa,
gtwa->SDOdataCopyStatus = (status & CO_fifo_st_partial) != 0;
/* is syntax error in command or not the last token in command */
if ((status & CO_fifo_st_errMask) != 0
|| (gtwa->SDOdataCopyStatus == false && closed != 1)
if (((status & CO_fifo_st_errMask) != 0)
|| ((gtwa->SDOdataCopyStatus == false) && (closed != 1))
) {
abortCode = CO_SDO_AB_DEVICE_INCOMPAT;
abort = true; /* abort SDO communication */
@ -2011,7 +2011,7 @@ void CO_GTWA_process(CO_GTWA_t *gtwa,
do {
size_t lenHelpRemain = lenHelp - gtwa->helpStringOffset;
size_t lenCopied = lenBuf < lenHelpRemain ? lenBuf : lenHelpRemain;
size_t lenCopied = (lenBuf < lenHelpRemain) ? lenBuf : lenHelpRemain;
(void)memcpy(gtwa->respBuf,
&gtwa->helpString[gtwa->helpStringOffset],
@ -2040,7 +2040,7 @@ void CO_GTWA_process(CO_GTWA_t *gtwa,
i = 4;
}
else {
i = CO_LED_RED(gtwa->LEDs, CO_LED_CANopen) * 2 +
i = (CO_LED_RED(gtwa->LEDs, CO_LED_CANopen) * 2) +
CO_LED_GREEN(gtwa->LEDs, CO_LED_CANopen);
}
if (i > (CO_GTWA_LED_PRINTOUTS_SIZE - 1))
@ -2067,7 +2067,7 @@ void CO_GTWA_process(CO_GTWA_t *gtwa,
/* execute next CANopen processing immediately, if idle and more commands
* available */
if (timerNext_us != NULL && gtwa->state == CO_GTWA_ST_IDLE
if ((timerNext_us != NULL) && (gtwa->state == CO_GTWA_ST_IDLE)
&& CO_fifo_CommSearch(&gtwa->commFifo, false)
) {
*timerNext_us = 0;

20
storage/CO_storage.c
View file

@ -35,15 +35,15 @@ static ODR_t OD_write_1010(OD_stream_t *stream, const void *buf,
OD_size_t count, OD_size_t *countWritten)
{
/* verify arguments */
if (stream == NULL || stream->subIndex == 0 || buf == NULL || count != 4
|| countWritten == NULL
if ((stream == NULL) || (stream->subIndex == 0) || (buf == NULL) || (count != 4)
|| (countWritten == NULL)
) {
return ODR_DEV_INCOMPAT;
}
CO_storage_t *storage = stream->object;
if (stream->subIndex == 0 || storage->store == NULL || !storage->enabled) {
if ((stream->subIndex == 0) || (storage->store == NULL) || !storage->enabled) {
return ODR_READONLY;
}
@ -59,7 +59,7 @@ static ODR_t OD_write_1010(OD_stream_t *stream, const void *buf,
for (uint8_t i = 0; i < storage->entriesCount; i++) {
CO_storage_entry_t *entry = &storage->entries[i];
if (stream->subIndex == 1 || entry->subIndexOD == stream->subIndex) {
if ((stream->subIndex == 1) || (entry->subIndexOD == stream->subIndex)) {
if (found == 0) found = 1;
if ((entry->attr & CO_storage_cmd) != 0) {
ODR_t code = storage->store(entry, storage->CANmodule);
@ -70,7 +70,7 @@ static ODR_t OD_write_1010(OD_stream_t *stream, const void *buf,
}
if (found != 2)
returnCode = found == 0 ? ODR_SUB_NOT_EXIST : ODR_READONLY;
returnCode = (found == 0) ? ODR_SUB_NOT_EXIST : ODR_READONLY;
if (returnCode == ODR_OK) *countWritten = sizeof(uint32_t);
return returnCode;
@ -86,15 +86,15 @@ static ODR_t OD_write_1011(OD_stream_t *stream, const void *buf,
OD_size_t count, OD_size_t *countWritten)
{
/* verify arguments */
if (stream == NULL || stream->subIndex == 0 || buf == NULL || count != 4
|| countWritten == NULL
if ((stream == NULL) || (stream->subIndex == 0) || (buf == NULL) || (count != 4)
|| (countWritten == NULL)
) {
return ODR_DEV_INCOMPAT;
}
CO_storage_t *storage = stream->object;
if (stream->subIndex == 0 || storage->restore == NULL || !storage->enabled){
if ((stream->subIndex == 0) || (storage->restore == NULL) || !storage->enabled){
return ODR_READONLY;
}
@ -110,7 +110,7 @@ static ODR_t OD_write_1011(OD_stream_t *stream, const void *buf,
for (uint8_t i = 0; i < storage->entriesCount; i++) {
CO_storage_entry_t *entry = &storage->entries[i];
if (stream->subIndex == 1 || entry->subIndexOD == stream->subIndex) {
if ((stream->subIndex == 1) || (entry->subIndexOD == stream->subIndex)) {
if (found == 0) found = 1;
if ((entry->attr & CO_storage_restore) != 0) {
ODR_t code = storage->restore(entry, storage->CANmodule);
@ -121,7 +121,7 @@ static ODR_t OD_write_1011(OD_stream_t *stream, const void *buf,
}
if (found != 2)
returnCode = found == 0 ? ODR_SUB_NOT_EXIST : ODR_READONLY;
returnCode = (found == 0) ? ODR_SUB_NOT_EXIST : ODR_READONLY;
if (returnCode == ODR_OK) *countWritten = sizeof(uint32_t);
return returnCode;

12
storage/CO_storageEeprom.c
View file

@ -63,7 +63,7 @@ static ODR_t storeEeprom(CO_storage_entry_t *entry, CO_CANmodule_t *CANmodule) {
(uint8_t *)&signatureRead,
entry->eepromAddrSignature,
sizeof(signatureRead));
if(signature != signatureRead || !writeOk) {
if((signature != signatureRead) || !writeOk) {
return ODR_HW;
}
@ -95,7 +95,7 @@ static ODR_t restoreEeprom(CO_storage_entry_t *entry,
(uint8_t *)&signatureRead,
entry->eepromAddrSignature,
sizeof(signatureRead));
if(signature != signatureRead || !writeOk) {
if((signature != signatureRead) || !writeOk) {
return ODR_HW;
}
@ -117,8 +117,8 @@ CO_ReturnError_t CO_storageEeprom_init(CO_storage_t *storage,
bool_t eepromOvf = false;
/* verify arguments */
if (storage == NULL || entries == NULL || entriesCount == 0
|| storageInitError == NULL
if ((storage == NULL) || (entries == NULL) || (entriesCount == 0)
|| (storageInitError == NULL)
) {
return CO_ERROR_ILLEGAL_ARGUMENT;
}
@ -162,7 +162,7 @@ CO_ReturnError_t CO_storageEeprom_init(CO_storage_t *storage,
bool_t isAuto = (entry->attr & CO_storage_auto) != 0;
/* verify arguments */
if (entry->addr == NULL || entry->len == 0 || entry->subIndexOD < 2) {
if ((entry->addr == NULL) || (entry->len == 0) || (entry->subIndexOD < 2)) {
*storageInitError = i;
return CO_ERROR_ILLEGAL_ARGUMENT;
}
@ -225,7 +225,7 @@ CO_ReturnError_t CO_storageEeprom_init(CO_storage_t *storage,
/******************************************************************************/
void CO_storageEeprom_auto_process(CO_storage_t *storage, bool_t saveAll) {
/* verify arguments */
if (storage == NULL || !storage->enabled) {
if ((storage == NULL) || !storage->enabled) {
return;
}