nikon/CANopenNode
1
0
Fork 0
Code Activity Actions

static analysis: Ignoring return value of function 'memcpy' [MISRA 2012 Directive 4.7, required]

Browse source
This commit is contained in:
temi54c1l8 2024-06-10 10:30:59 +02:00
parent 1b63929837
commit ddaa8974f1
10 changed files with 54 additions and 54 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
301/CO_Emergency.c
View file

@ -272,7 +272,7 @@ static ODR_t OD_read_statusBits(OD_stream_t *stream, void *buf,
stream->dataLength = countReadLocal;
}
memcpy (buf, &em->errorStatusBits[0], countReadLocal);
(void)memcpy (buf, &em->errorStatusBits[0], countReadLocal);
*countRead = countReadLocal;
return ODR_OK;
@ -301,7 +301,7 @@ static ODR_t OD_write_statusBits(OD_stream_t *stream, const void *buf,
stream->dataLength = countWrite;
}
memcpy (&em->errorStatusBits[0], buf, countWrite);
(void)memcpy (&em->errorStatusBits[0], buf, countWrite);
*countWritten = countWrite;
return ODR_OK;
@ -328,8 +328,8 @@ static void CO_EM_receive(void *object, void *msg) {
uint16_t errorCode;
uint32_t infoCode;
memcpy(&errorCode, &data[0], sizeof(errorCode));
memcpy(&infoCode, &data[4], sizeof(infoCode));
(void)memcpy(&errorCode, &data[0], sizeof(errorCode));
(void)memcpy(&infoCode, &data[4], sizeof(infoCode));
em->pFunctSignalRx(ident,
CO_SWAP_16(errorCode),
data[2],
@ -653,7 +653,7 @@ void CO_EM_process(CO_EM_t *em,
em->fifo[fifoPpPtr].msg |= (uint32_t) errorRegister << 16;
/* send emergency message */
memcpy(em->CANtxBuff->data, &em->fifo[fifoPpPtr].msg,
(void)memcpy(em->CANtxBuff->data, &em->fifo[fifoPpPtr].msg,
sizeof(em->CANtxBuff->data));
CO_CANsend(em->CANdevTx, em->CANtxBuff);

4
301/CO_ODinterface.c
View file

@ -65,7 +65,7 @@ ODR_t OD_readOriginal(OD_stream_t *stream, void *buf,
}
}
memcpy(buf, dataOrig, dataLenToCopy);
(void)memcpy(buf, dataOrig, dataLenToCopy);
*countRead = dataLenToCopy;
return returnCode;
@ -116,7 +116,7 @@ ODR_t OD_writeOriginal(OD_stream_t *stream, const void *buf,
return ODR_DATA_LONG;
}
memcpy(dataOrig, buf, dataLenToCopy);
(void)memcpy(dataOrig, buf, dataLenToCopy);
*countWritten = dataLenToCopy;
return returnCode;

10
301/CO_PDO.c
View file

@ -491,7 +491,7 @@ static void CO_PDO_receive(void *object, void *msg) {
#endif
/* copy data into appropriate buffer and set 'new message' flag */
memcpy(RPDO->CANrxData[bufNo], data,sizeof(RPDO->CANrxData[bufNo]));
(void)memcpy(RPDO->CANrxData[bufNo], data,sizeof(RPDO->CANrxData[bufNo]));
CO_FLAG_SET(RPDO->CANrxNew[bufNo]);
#if (CO_CONFIG_PDO) & CO_CONFIG_FLAG_CALLBACK_PRE
@ -529,7 +529,7 @@ static ODR_t OD_write_14xx(OD_stream_t *stream, const void *buf,
CO_RPDO_t *RPDO = stream->object;
CO_PDO_common_t *PDO = &RPDO->PDO_common;
uint8_t bufCopy[4];
memcpy(bufCopy, buf, count);
(void)memcpy(bufCopy, buf, count);
switch (stream->subIndex) {
case 1: { /* COB-ID used by PDO */
@ -843,7 +843,7 @@ void CO_RPDO_process(CO_RPDO_t *RPDO,
uint8_t *dataOD;
if (ODdataLength > mappedLength) {
memset(buf, 0, sizeof(buf));
memcpy(buf, dataRPDO, mappedLength);
(void)memcpy(buf, dataRPDO, mappedLength);
dataOD = buf;
}
else {
@ -960,7 +960,7 @@ static ODR_t OD_write_18xx(OD_stream_t *stream, const void *buf,
CO_TPDO_t *TPDO = stream->object;
CO_PDO_common_t *PDO = &TPDO->PDO_common;
uint8_t bufCopy[4];
memcpy(bufCopy, buf, count);
(void)memcpy(bufCopy, buf, count);
switch (stream->subIndex) {
case 1: { /* COB-ID used by PDO */
@ -1289,7 +1289,7 @@ static CO_ReturnError_t CO_TPDOsend(CO_TPDO_t *TPDO) {
/* If auxiliary buffer, copy it to the TPDO */
if (ODdataLength > mappedLength) {
memcpy(dataTPDO, buf, mappedLength);
(void)memcpy(dataTPDO, buf, mappedLength);
}
/* In event driven TPDO indicate transmission of OD variable */

22
301/CO_SDOclient.c
View file

@ -77,7 +77,7 @@ static void CO_SDOclient_receive(void *object, void *msg) {
) {
#endif
/* copy data and set 'new message' flag */
memcpy((void *)&SDO_C->CANrxData[0], (const void *)&data[0], 8);
(void)memcpy((void *)&SDO_C->CANrxData[0], (const void *)&data[0], 8);
CO_FLAG_SET(SDO_C->CANrxNew);
#if (CO_CONFIG_SDO_CLI) & CO_CONFIG_FLAG_CALLBACK_PRE
/* Optional signal to RTOS, which can resume task, which handles
@ -106,7 +106,7 @@ static void CO_SDOclient_receive(void *object, void *msg) {
if ((data[0] & 0x80) != 0) {
/* copy data to temporary buffer, because we don't know the
* number of bytes not containing data */
memcpy((void *)&SDO_C->block_dataUploadLast[0],
(void)memcpy((void *)&SDO_C->block_dataUploadLast[0],
(const void *)&data[1], 7);
SDO_C->finished = true;
state = CO_SDO_ST_UPLOAD_BLK_SUBBLOCK_CRSP;
@ -674,7 +674,7 @@ CO_SDO_return_t CO_SDOclientDownload(CO_SDOclient_t *SDO_C,
/* is SDO abort */
if (SDO_C->CANrxData[0] == 0x80) {
uint32_t code;
memcpy(&code, &SDO_C->CANrxData[4], sizeof(code));
(void)memcpy(&code, &SDO_C->CANrxData[4], sizeof(code));
abortCode = (CO_SDO_abortCode_t)CO_SWAP_32(code);
SDO_C->state = CO_SDO_ST_IDLE;
ret = CO_SDO_RT_endedWithServerAbort;
@ -922,7 +922,7 @@ CO_SDO_return_t CO_SDOclientDownload(CO_SDOclient_t *SDO_C,
if (SDO_C->sizeInd > 0) {
uint32_t size = CO_SWAP_32((uint32_t)SDO_C->sizeInd);
SDO_C->CANtxBuff->data[0] |= 0x01;
memcpy(&SDO_C->CANtxBuff->data[4], &size, sizeof(size));
(void)memcpy(&SDO_C->CANtxBuff->data[4], &size, sizeof(size));
}
#else
SDO_C->state = CO_SDO_ST_IDLE;
@ -988,7 +988,7 @@ CO_SDO_return_t CO_SDOclientDownload(CO_SDOclient_t *SDO_C,
if (SDO_C->sizeInd > 0) {
uint32_t size = CO_SWAP_32((uint32_t)SDO_C->sizeInd);
SDO_C->CANtxBuff->data[0] |= 0x02;
memcpy(&SDO_C->CANtxBuff->data[4], &size, sizeof(size));
(void)memcpy(&SDO_C->CANtxBuff->data[4], &size, sizeof(size));
}
/* reset timeout timer and send message */
@ -1076,7 +1076,7 @@ CO_SDO_return_t CO_SDOclientDownload(CO_SDOclient_t *SDO_C,
SDO_C->CANtxBuff->data[2] = (uint8_t)(SDO_C->index >> 8);
SDO_C->CANtxBuff->data[3] = SDO_C->subIndex;
memcpy(&SDO_C->CANtxBuff->data[4], &code, sizeof(code));
(void)memcpy(&SDO_C->CANtxBuff->data[4], &code, sizeof(code));
CO_CANsend(SDO_C->CANdevTx, SDO_C->CANtxBuff);
SDO_C->state = CO_SDO_ST_IDLE;
ret = CO_SDO_RT_endedWithClientAbort;
@ -1289,7 +1289,7 @@ CO_SDO_return_t CO_SDOclientUpload(CO_SDOclient_t *SDO_C,
/* is SDO abort */
if (SDO_C->CANrxData[0] == 0x80) {
uint32_t code;
memcpy(&code, &SDO_C->CANrxData[4], sizeof(code));
(void)memcpy(&code, &SDO_C->CANrxData[4], sizeof(code));
abortCode = (CO_SDO_abortCode_t)CO_SWAP_32(code);
SDO_C->state = CO_SDO_ST_IDLE;
ret = CO_SDO_RT_endedWithServerAbort;
@ -1334,7 +1334,7 @@ CO_SDO_return_t CO_SDOclientUpload(CO_SDOclient_t *SDO_C,
/* segmented transfer, is size indicated? */
if (SDO_C->CANrxData[0] & 0x01) {
uint32_t size;
memcpy(&size, &SDO_C->CANrxData[4], sizeof(size));
(void)memcpy(&size, &SDO_C->CANrxData[4], sizeof(size));
SDO_C->sizeInd = CO_SWAP_32(size);
}
SDO_C->toggle = 0x00;
@ -1428,7 +1428,7 @@ CO_SDO_return_t CO_SDOclientUpload(CO_SDOclient_t *SDO_C,
}
if (SDO_C->CANrxData[0] & 0x02) {
uint32_t size;
memcpy(&size, &SDO_C->CANrxData[4], sizeof(size));
(void)memcpy(&size, &SDO_C->CANrxData[4], sizeof(size));
SDO_C->sizeInd = CO_SWAP_32(size);
}
@ -1477,7 +1477,7 @@ CO_SDO_return_t CO_SDOclientUpload(CO_SDOclient_t *SDO_C,
/* segmented transfer, is size indicated? */
if (SDO_C->CANrxData[0] & 0x01) {
uint32_t size;
memcpy(&size, &SDO_C->CANrxData[4], sizeof(size));
(void)memcpy(&size, &SDO_C->CANrxData[4], sizeof(size));
SDO_C->sizeInd = CO_SWAP_32(size);
}
SDO_C->toggle = 0x00;
@ -1787,7 +1787,7 @@ CO_SDO_return_t CO_SDOclientUpload(CO_SDOclient_t *SDO_C,
SDO_C->CANtxBuff->data[2] = (uint8_t)(SDO_C->index >> 8);
SDO_C->CANtxBuff->data[3] = SDO_C->subIndex;
memcpy(&SDO_C->CANtxBuff->data[4], &code, sizeof(code));
(void)memcpy(&SDO_C->CANtxBuff->data[4], &code, sizeof(code));
CO_CANsend(SDO_C->CANdevTx, SDO_C->CANtxBuff);
SDO_C->state = CO_SDO_ST_IDLE;
ret = CO_SDO_RT_endedWithClientAbort;

24
301/CO_SDOserver.c
View file

@ -89,7 +89,7 @@ static void CO_SDO_receive(void *object, void *msg) {
/* Copy data. There is always enough space in buffer,
* because block_blksize was calculated before */
memcpy(SDO->buf + SDO->bufOffsetWr, &data[1], 7);
(void)memcpy(SDO->buf + SDO->bufOffsetWr, &data[1], 7);
SDO->bufOffsetWr += 7;
SDO->sizeTran += 7;
@ -149,7 +149,7 @@ static void CO_SDO_receive(void *object, void *msg) {
else {
/* copy data and set 'new message' flag, data will be processed in
* CO_SDOserver_process() */
memcpy(SDO->CANrxData, data, DLC);
(void)memcpy(SDO->CANrxData, data, DLC);
CO_FLAG_SET(SDO->CANrxNew);
#if (CO_CONFIG_SDO_SRV) & CO_CONFIG_FLAG_CALLBACK_PRE
/* Optional signal to RTOS, which can resume task, which handles
@ -827,7 +827,7 @@ CO_SDO_return_t CO_SDOserver_process(CO_SDOserver_t *SDO,
/* copy data to the temp buffer, swap data if necessary */
uint8_t buf[6] = {0};
memcpy(buf, &SDO->CANrxData[4], dataSizeToWrite);
(void)memcpy(buf, &SDO->CANrxData[4], dataSizeToWrite);
#ifdef CO_BIG_ENDIAN
if ((SDO->OD_IO.stream.attribute & ODA_MB) != 0) {
reverseBytes(buf, dataSizeToWrite);
@ -884,7 +884,7 @@ CO_SDO_return_t CO_SDOserver_process(CO_SDOserver_t *SDO,
uint32_t size;
OD_size_t sizeInOd = SDO->OD_IO.stream.dataLength;
memcpy(&size, &SDO->CANrxData[4], sizeof(size));
(void)memcpy(&size, &SDO->CANrxData[4], sizeof(size));
SDO->sizeInd = CO_SWAP_32(size);
/* Indicated size of SDO matches sizeof OD variable? */
@ -933,7 +933,7 @@ CO_SDO_return_t CO_SDOserver_process(CO_SDOserver_t *SDO,
/* get data size and write data to the buffer */
OD_size_t count = 7 - ((SDO->CANrxData[0] >> 1) & 0x07);
memcpy(SDO->buf + SDO->bufOffsetWr, &SDO->CANrxData[1], count);
(void)memcpy(SDO->buf + SDO->bufOffsetWr, &SDO->CANrxData[1], count);
SDO->bufOffsetWr += count;
SDO->sizeTran += count;
@ -999,7 +999,7 @@ CO_SDO_return_t CO_SDOserver_process(CO_SDOserver_t *SDO,
uint32_t size;
OD_size_t sizeInOd = SDO->OD_IO.stream.dataLength;
memcpy(&size, &SDO->CANrxData[4], sizeof(size));
(void)memcpy(&size, &SDO->CANrxData[4], sizeof(size));
SDO->sizeInd = CO_SWAP_32(size);
/* Indicated size of SDO matches sizeof OD variable? */
@ -1288,7 +1288,7 @@ CO_SDO_return_t CO_SDOserver_process(CO_SDOserver_t *SDO,
if (SDO->sizeInd > 0 && SDO->sizeInd <= 4) {
/* expedited transfer */
SDO->CANtxBuff->data[0] = (uint8_t)(0x43|((4-SDO->sizeInd)<<2));
memcpy(&SDO->CANtxBuff->data[4], &SDO->buf, SDO->sizeInd);
(void)memcpy(&SDO->CANtxBuff->data[4], &SDO->buf, SDO->sizeInd);
SDO->state = CO_SDO_ST_IDLE;
ret = CO_SDO_RT_ok_communicationEnd;
}
@ -1299,7 +1299,7 @@ CO_SDO_return_t CO_SDOserver_process(CO_SDOserver_t *SDO,
uint32_t sizeInd = SDO->sizeInd;
uint32_t sizeIndSw = CO_SWAP_32(sizeInd);
SDO->CANtxBuff->data[0] = 0x41;
memcpy(&SDO->CANtxBuff->data[4],
(void)memcpy(&SDO->CANtxBuff->data[4],
&sizeIndSw, sizeof(sizeIndSw));
}
else {
@ -1377,7 +1377,7 @@ CO_SDO_return_t CO_SDOserver_process(CO_SDOserver_t *SDO,
}
/* copy data segment to CAN message */
memcpy(&SDO->CANtxBuff->data[1], SDO->buf + SDO->bufOffsetRd,
(void)memcpy(&SDO->CANtxBuff->data[1], SDO->buf + SDO->bufOffsetRd,
count);
SDO->bufOffsetRd += count;
SDO->sizeTran += count;
@ -1513,7 +1513,7 @@ CO_SDO_return_t CO_SDOserver_process(CO_SDOserver_t *SDO,
if (SDO->sizeInd > 0) {
uint32_t size = CO_SWAP_32(SDO->sizeInd);
SDO->CANtxBuff->data[0] |= 0x02;
memcpy(&SDO->CANtxBuff->data[4], &size, sizeof(size));
(void)memcpy(&SDO->CANtxBuff->data[4], &size, sizeof(size));
}
/* reset timeout timer and send message */
@ -1536,7 +1536,7 @@ CO_SDO_return_t CO_SDOserver_process(CO_SDOserver_t *SDO,
}
/* copy data segment to CAN message */
memcpy(&SDO->CANtxBuff->data[1], SDO->buf + SDO->bufOffsetRd,
(void)memcpy(&SDO->CANtxBuff->data[1], SDO->buf + SDO->bufOffsetRd,
count);
SDO->bufOffsetRd += count;
SDO->block_noData = (uint8_t)(7 - count);
@ -1606,7 +1606,7 @@ CO_SDO_return_t CO_SDOserver_process(CO_SDOserver_t *SDO,
SDO->CANtxBuff->data[2] = (uint8_t)(SDO->index >> 8);
SDO->CANtxBuff->data[3] = SDO->subIndex;
memcpy(&SDO->CANtxBuff->data[4], &code, sizeof(code));
(void)memcpy(&SDO->CANtxBuff->data[4], &code, sizeof(code));
CO_CANsend(SDO->CANdevTx, SDO->CANtxBuff);
SDO->state = CO_SDO_ST_IDLE;
ret = CO_SDO_RT_endedWithServerAbort;

2
301/CO_TIME.c
View file

@ -42,7 +42,7 @@ static void CO_TIME_receive(void *object, void *msg) {
uint8_t *data = CO_CANrxMsg_readData(msg);
if (DLC == CO_TIME_MSG_LENGTH) {
memcpy(TIME->timeStamp, data, sizeof(TIME->timeStamp));
(void)memcpy(TIME->timeStamp, data, sizeof(TIME->timeStamp));
CO_FLAG_SET(TIME->CANrxNew);
#if (CO_CONFIG_TIME) & CO_CONFIG_FLAG_CALLBACK_PRE

10
304/CO_SRDO.c
View file

@ -57,7 +57,7 @@ CO_SRDO_receive_normal(void* object, void* msg) {
if ((SRDO->informationDirection == CO_SRDO_RX) && (DLC >= SRDO->dataLength) && !CO_FLAG_READ(SRDO->CANrxNew[1])) {
/* copy data into appropriate buffer and set 'new message' flag */
memcpy(SRDO->CANrxData[0], data, sizeof(SRDO->CANrxData[0]));
(void)memcpy(SRDO->CANrxData[0], data, sizeof(SRDO->CANrxData[0]));
CO_FLAG_SET(SRDO->CANrxNew[0]);
#if (CO_CONFIG_SRDO) & CO_CONFIG_FLAG_CALLBACK_PRE
@ -81,7 +81,7 @@ CO_SRDO_receive_inverted(void* object, void* msg) {
if ((SRDO->informationDirection == CO_SRDO_RX) && (DLC >= SRDO->dataLength) && CO_FLAG_READ(SRDO->CANrxNew[0])) {
/* copy data into appropriate buffer and set 'new message' flag */
memcpy(SRDO->CANrxData[1], data, sizeof(SRDO->CANrxData[1]));
(void)memcpy(SRDO->CANrxData[1], data, sizeof(SRDO->CANrxData[1]));
CO_FLAG_SET(SRDO->CANrxNew[1]);
#if (CO_CONFIG_SRDO) & CO_CONFIG_FLAG_CALLBACK_PRE
@ -198,7 +198,7 @@ OD_write_SRDO_communicationParam(OD_stream_t* stream, const void* buf, OD_size_t
CO_SRDO_t* SRDO = stream->object;
CO_SRDOGuard_t* SRDOGuard = SRDO->SRDOGuard;
uint8_t bufCopy[4];
memcpy(bufCopy, buf, count);
(void)memcpy(bufCopy, buf, count);
/* Writing Object Dictionary variable */
if (SRDOGuard->NMTisOperational) {
@ -816,7 +816,7 @@ CO_SRDO_process(CO_SRDO_t* SRDO, uint32_t timeDifference_us, uint32_t* timerNext
/* If auxiliary buffer, copy it to the SRDO */
if (ODdataLength > mappedLength) {
memcpy(dataSRDO[plain_inverted], buf, mappedLength);
(void)memcpy(dataSRDO[plain_inverted], buf, mappedLength);
}
dataSRDO[plain_inverted] += mappedLength;
@ -923,7 +923,7 @@ CO_SRDO_process(CO_SRDO_t* SRDO, uint32_t timeDifference_us, uint32_t* timerNext
uint8_t *dataOD;
if (ODdataLength > mappedLength) {
memset(buf, 0, sizeof(buf));
memcpy(buf, dataSRDO[plain_inverted], mappedLength);
(void)memcpy(buf, dataSRDO[plain_inverted], mappedLength);
dataOD = buf;
}
else {

2
305/CO_LSSmaster.c
View file

@ -87,7 +87,7 @@ static void CO_LSSmaster_receive(void *object, void *msg)
LSSmaster->command!=CO_LSSmaster_COMMAND_WAITING){
/* copy data and set 'new message' flag */
memcpy(LSSmaster->CANrxData, data, sizeof(LSSmaster->CANrxData));
(void)memcpy(LSSmaster->CANrxData, data, sizeof(LSSmaster->CANrxData));
CO_FLAG_SET(LSSmaster->CANrxNew);

22
305/CO_LSSslave.c
View file

@ -83,25 +83,25 @@ static void CO_LSSslave_receive(void *object, void *msg)
switch (cs) {
case CO_LSS_SWITCH_STATE_SEL_VENDOR: {
uint32_t valSw;
memcpy(&valSw, &data[1], sizeof(valSw));
(void)memcpy(&valSw, &data[1], sizeof(valSw));
LSSslave->lssSelect.identity.vendorID = CO_SWAP_32(valSw);
break;
}
case CO_LSS_SWITCH_STATE_SEL_PRODUCT: {
uint32_t valSw;
memcpy(&valSw, &data[1], sizeof(valSw));
(void)memcpy(&valSw, &data[1], sizeof(valSw));
LSSslave->lssSelect.identity.productCode = CO_SWAP_32(valSw);
break;
}
case CO_LSS_SWITCH_STATE_SEL_REV: {
uint32_t valSw;
memcpy(&valSw, &data[1], sizeof(valSw));
(void)memcpy(&valSw, &data[1], sizeof(valSw));
LSSslave->lssSelect.identity.revisionNumber = CO_SWAP_32(valSw);
break;
}
case CO_LSS_SWITCH_STATE_SEL_SERIAL: {
uint32_t valSw;
memcpy(&valSw, &data[1], sizeof(valSw));
(void)memcpy(&valSw, &data[1], sizeof(valSw));
LSSslave->lssSelect.identity.serialNumber = CO_SWAP_32(valSw);
if (CO_LSS_ADDRESS_EQUAL(LSSslave->lssAddress,
@ -132,7 +132,7 @@ static void CO_LSSslave_receive(void *object, void *msg)
break;
}
memcpy(&valSw, &data[1], sizeof(valSw));
(void)memcpy(&valSw, &data[1], sizeof(valSw));
idNumber = CO_SWAP_32(valSw);
ack = false;
@ -180,7 +180,7 @@ static void CO_LSSslave_receive(void *object, void *msg)
}
}
else { /* LSSslave->lssState == CO_LSS_STATE_CONFIGURATION */
memcpy(&LSSslave->CANdata, &data[0], sizeof(LSSslave->CANdata));
(void)memcpy(&LSSslave->CANdata, &data[0], sizeof(LSSslave->CANdata));
LSSslave->service = cs;
request_LSSslave_process = true;
}
@ -228,7 +228,7 @@ CO_ReturnError_t CO_LSSslave_init(
memset(LSSslave, 0, sizeof(CO_LSSslave_t));
/* Configure object variables */
memcpy(&LSSslave->lssAddress, lssAddress, sizeof(LSSslave->lssAddress));
(void)memcpy(&LSSslave->lssAddress, lssAddress, sizeof(LSSslave->lssAddress));
LSSslave->lssState = CO_LSS_STATE_WAITING;
LSSslave->fastscanPos = CO_LSS_FASTSCAN_VENDOR_ID;
@ -444,28 +444,28 @@ bool_t CO_LSSslave_process(CO_LSSslave_t *LSSslave) {
case CO_LSS_INQUIRE_VENDOR: {
LSSslave->TXbuff->data[0] = LSSslave->service;
valSw = CO_SWAP_32(LSSslave->lssAddress.identity.vendorID);
memcpy(&LSSslave->TXbuff->data[1], &valSw, sizeof(valSw));
(void)memcpy(&LSSslave->TXbuff->data[1], &valSw, sizeof(valSw));
CANsend = true;
break;
}
case CO_LSS_INQUIRE_PRODUCT: {
LSSslave->TXbuff->data[0] = LSSslave->service;
valSw = CO_SWAP_32(LSSslave->lssAddress.identity.productCode);
memcpy(&LSSslave->TXbuff->data[1], &valSw, sizeof(valSw));
(void)memcpy(&LSSslave->TXbuff->data[1], &valSw, sizeof(valSw));
CANsend = true;
break;
}
case CO_LSS_INQUIRE_REV: {
LSSslave->TXbuff->data[0] = LSSslave->service;
valSw = CO_SWAP_32(LSSslave->lssAddress.identity.revisionNumber);
memcpy(&LSSslave->TXbuff->data[1], &valSw, sizeof(valSw));
(void)memcpy(&LSSslave->TXbuff->data[1], &valSw, sizeof(valSw));
CANsend = true;
break;
}
case CO_LSS_INQUIRE_SERIAL: {
LSSslave->TXbuff->data[0] = LSSslave->service;
valSw = CO_SWAP_32(LSSslave->lssAddress.identity.serialNumber);
memcpy(&LSSslave->TXbuff->data[1], &valSw, sizeof(valSw));
(void)memcpy(&LSSslave->TXbuff->data[1], &valSw, sizeof(valSw));
CANsend = true;
break;
}

2
309/CO_gateway_ascii.c
View file

@ -2013,7 +2013,7 @@ void CO_GTWA_process(CO_GTWA_t *gtwa,
size_t lenHelpRemain = lenHelp - gtwa->helpStringOffset;
size_t lenCopied = lenBuf < lenHelpRemain ? lenBuf : lenHelpRemain;
memcpy(gtwa->respBuf,
(void)memcpy(gtwa->respBuf,
&gtwa->helpString[gtwa->helpStringOffset],
lenCopied);