nikon/CANopenNode
1
0
Fork 0
Code Activity Actions

Replace CO_memcpySwap4()

Browse source
This commit is contained in:
Janez 2020-07-23 13:37:50 +02:00
parent 756c76d08a
commit 1410a20e95
5 changed files with 66 additions and 55 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

29
301/CO_Emergency.c
View file

@ -52,13 +52,13 @@ static void CO_EM_receive(void *object, void *msg) {
uint16_t errorCode;
uint32_t infoCode;
CO_memcpySwap2(&errorCode, &data[0]);
CO_memcpySwap4(&infoCode, &data[4]);
memcpy(&errorCode, &data[0], sizeof(errorCode));
memcpy(&infoCode, &data[4], sizeof(infoCode));
em->pFunctSignalRx(ident,
errorCode,
data[2],
data[3],
infoCode);
CO_SWAP_16(errorCode),
data[2],
data[3],
CO_SWAP_32(infoCode));
}
}
}
@ -384,13 +384,13 @@ void CO_EM_process(
if (em->pFunctSignalRx != NULL) {
uint16_t errorCode;
uint32_t infoCode;
CO_memcpySwap2(&errorCode, &em->bufReadPtr[0]);
CO_memcpySwap4(&infoCode, &em->bufReadPtr[4]);
memcpy(&errorCode, &em->bufReadPtr[0], sizeof(errorCode));
memcpy(&infoCode, &em->bufReadPtr[4], sizeof(infoCode));
em->pFunctSignalRx(0,
errorCode,
CO_SWAP_16(errorCode),
em->bufReadPtr[2],
em->bufReadPtr[3],
infoCode);
CO_SWAP_32(infoCode));
}
#endif
@ -482,12 +482,14 @@ void CO_errorReport(CO_EM_t *em, const uint8_t errorBit, const uint16_t errorCod
}
else{
uint8_t bufCopy[8];
uint16_t errorCodeSw = CO_SWAP_16(errorCode);
uint32_t infoCodeSw = CO_SWAP_32(infoCode);
/* prepare data for emergency message */
CO_memcpySwap2(&bufCopy[0], &errorCode);
memcpy(&bufCopy[0], &errorCodeSw, sizeof(errorCodeSw));
bufCopy[2] = 0; /* error register will be set later */
bufCopy[3] = errorBit;
CO_memcpySwap4(&bufCopy[4], &infoCode);
memcpy(&bufCopy[4], &infoCodeSw, sizeof(infoCodeSw));
/* copy data to the buffer, increment writePtr and verify buffer full */
CO_LOCK_EMCY();
@ -542,13 +544,14 @@ void CO_errorReset(CO_EM_t *em, const uint8_t errorBit, const uint32_t infoCode)
}
else{
uint8_t bufCopy[8];
uint32_t infoCodeSw = CO_SWAP_32(infoCode);
/* prepare data for emergency message */
bufCopy[0] = 0;
bufCopy[1] = 0;
bufCopy[2] = 0; /* error register will be set later */
bufCopy[3] = errorBit;
CO_memcpySwap4(&bufCopy[4], &infoCode);
memcpy(&bufCopy[4], &infoCodeSw, sizeof(infoCodeSw));
/* copy data to the buffer, increment writePtr and verify buffer full */
CO_LOCK_EMCY();

39
301/CO_SDOclient.c
View file

@ -440,8 +440,8 @@ CO_SDOclient_return_t CO_SDOclientDownload(CO_SDOclient_t *SDO_C,
/* is SDO abort */
if (SDO_C->CANrxData[0] == 0x80) {
uint32_t code;
CO_memcpySwap4(&code , &SDO_C->CANrxData[4]);
abortCode = (CO_SDO_abortCode_t)code;
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_SDOcli_endedWithServerAbort;
}
@ -670,9 +670,9 @@ CO_SDOclient_return_t CO_SDOclientDownload(CO_SDOclient_t *SDO_C,
#if (CO_CONFIG_SDO_CLI) & CO_CONFIG_SDO_SEGMENTED
/* segmented transfer, indicate data size */
if (SDO_C->sizeInd > 0) {
uint32_t size = SDO_C->sizeInd;
uint32_t size = CO_SWAP_32(SDO_C->sizeInd);
SDO_C->CANtxBuff->data[0] |= 0x01;
CO_memcpySwap4(&SDO_C->CANtxBuff->data[4], &size);
memcpy(&SDO_C->CANtxBuff->data[4], &size, sizeof(size));
}
#else
SDO_C->state = CO_SDO_ST_IDLE;
@ -736,9 +736,9 @@ CO_SDOclient_return_t CO_SDOclientDownload(CO_SDOclient_t *SDO_C,
/* indicate data size */
if (SDO_C->sizeInd > 0) {
uint32_t size = SDO_C->sizeInd;
uint32_t size = CO_SWAP_32(SDO_C->sizeInd);
SDO_C->CANtxBuff->data[0] |= 0x02;
CO_memcpySwap4(&SDO_C->CANtxBuff->data[4], &size);
memcpy(&SDO_C->CANtxBuff->data[4], &size, sizeof(size));
}
/* reset timeout timer and send message */
@ -815,14 +815,14 @@ CO_SDOclient_return_t CO_SDOclientDownload(CO_SDOclient_t *SDO_C,
if (ret == CO_SDOcli_waitingServerResponse) {
if (SDO_C->state == CO_SDO_ST_ABORT) {
uint32_t code = (uint32_t)abortCode;
uint32_t code = CO_SWAP_32((uint32_t)abortCode);
/* Send SDO abort message */
SDO_C->CANtxBuff->data[0] = 0x80;
SDO_C->CANtxBuff->data[1] = (uint8_t)SDO_C->index;
SDO_C->CANtxBuff->data[2] = (uint8_t)(SDO_C->index >> 8);
SDO_C->CANtxBuff->data[3] = SDO_C->subIndex;
CO_memcpySwap4(&SDO_C->CANtxBuff->data[4], &code);
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_SDOcli_endedWithClientAbort;
@ -966,8 +966,8 @@ CO_SDOclient_return_t CO_SDOclientUpload(CO_SDOclient_t *SDO_C,
/* is SDO abort */
if (SDO_C->CANrxData[0] == 0x80) {
uint32_t code;
CO_memcpySwap4(&code , &SDO_C->CANrxData[4]);
abortCode = (CO_SDO_abortCode_t)code;
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_SDOcli_endedWithServerAbort;
}
@ -1006,8 +1006,8 @@ CO_SDOclient_return_t CO_SDOclientUpload(CO_SDOclient_t *SDO_C,
/* segmented transfer, is size indicated? */
if (SDO_C->CANrxData[0] & 0x01) {
uint32_t size;
CO_memcpySwap4(&size, &SDO_C->CANrxData[4]);
SDO_C->sizeInd = size;
memcpy(&size, &SDO_C->CANrxData[4], sizeof(size));
SDO_C->sizeInd = CO_SWAP_32(size);
}
SDO_C->toggle = 0x00;
SDO_C->state = CO_SDO_ST_UPLOAD_SEGMENT_REQ;
@ -1100,8 +1100,8 @@ CO_SDOclient_return_t CO_SDOclientUpload(CO_SDOclient_t *SDO_C,
}
if (SDO_C->CANrxData[0] & 0x02) {
uint32_t size;
CO_memcpySwap4(&size, &SDO_C->CANrxData[4]);
SDO_C->sizeInd = size;
memcpy(&size, &SDO_C->CANrxData[4], sizeof(size));
SDO_C->sizeInd = CO_SWAP_32(size);
}
/* verify index and subindex */
@ -1149,8 +1149,8 @@ CO_SDOclient_return_t CO_SDOclientUpload(CO_SDOclient_t *SDO_C,
/* segmented transfer, is size indicated? */
if (SDO_C->CANrxData[0] & 0x01) {
uint32_t size;
CO_memcpySwap4(&size, &SDO_C->CANrxData[4]);
SDO_C->sizeInd = size;
memcpy(&size, &SDO_C->CANrxData[4], sizeof(size));
SDO_C->sizeInd = CO_SWAP_32(size);
}
SDO_C->toggle = 0x00;
SDO_C->state = CO_SDO_ST_UPLOAD_SEGMENT_REQ;
@ -1192,7 +1192,8 @@ CO_SDOclient_return_t CO_SDOclientUpload(CO_SDOclient_t *SDO_C,
/* verify CRC */
if (SDO_C->block_crcEnabled) {
uint16_t crcServer;
CO_memcpySwap2(&crcServer, &SDO_C->CANrxData[1]);
crcServer = ((uint16_t) SDO_C->CANrxData[2]) << 8;
crcServer |= SDO_C->CANrxData[1];
if (crcServer != SDO_C->block_crc) {
abortCode = CO_SDO_AB_CRC;
SDO_C->state = CO_SDO_ST_ABORT;
@ -1425,14 +1426,14 @@ CO_SDOclient_return_t CO_SDOclientUpload(CO_SDOclient_t *SDO_C,
if (ret == CO_SDOcli_waitingServerResponse) {
if (SDO_C->state == CO_SDO_ST_ABORT) {
uint32_t code = (uint32_t)abortCode;
uint32_t code = CO_SWAP_32((uint32_t)abortCode);
/* Send SDO abort message */
SDO_C->CANtxBuff->data[0] = 0x80;
SDO_C->CANtxBuff->data[1] = (uint8_t)SDO_C->index;
SDO_C->CANtxBuff->data[2] = (uint8_t)(SDO_C->index >> 8);
SDO_C->CANtxBuff->data[3] = SDO_C->subIndex;
CO_memcpySwap4(&SDO_C->CANtxBuff->data[4], &code);
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_SDOcli_endedWithClientAbort;

42
305/CO_LSSslave.c
View file

@ -74,25 +74,26 @@ static void CO_LSSslave_receive(void *object, void *msg)
}
}
else if(LSSslave->lssState == CO_LSS_STATE_WAITING) {
uint32_t valSw;
switch (cs) {
case CO_LSS_SWITCH_STATE_SEL_VENDOR: {
CO_memcpySwap4(&LSSslave->lssSelect.identity.vendorID,
&data[1]);
memcpy(&valSw, &data[1], sizeof(valSw));
LSSslave->lssSelect.identity.vendorID = CO_SWAP_32(valSw);
break;
}
case CO_LSS_SWITCH_STATE_SEL_PRODUCT: {
CO_memcpySwap4(&LSSslave->lssSelect.identity.productCode,
&data[1]);
memcpy(&valSw, &data[1], sizeof(valSw));
LSSslave->lssSelect.identity.productCode = CO_SWAP_32(valSw);
break;
}
case CO_LSS_SWITCH_STATE_SEL_REV: {
CO_memcpySwap4(&LSSslave->lssSelect.identity.revisionNumber,
&data[1]);
memcpy(&valSw, &data[1], sizeof(valSw));
LSSslave->lssSelect.identity.revisionNumber = CO_SWAP_32(valSw);
break;
}
case CO_LSS_SWITCH_STATE_SEL_SERIAL: {
CO_memcpySwap4(&LSSslave->lssSelect.identity.serialNumber,
&data[1]);
memcpy(&valSw, &data[1], sizeof(valSw));
LSSslave->lssSelect.identity.serialNumber = CO_SWAP_32(valSw);
if (CO_LSS_ADDRESS_EQUAL(LSSslave->lssAddress,
LSSslave->lssSelect)
@ -111,6 +112,7 @@ static void CO_LSSslave_receive(void *object, void *msg)
uint8_t bitCheck = data[5];
uint8_t lssSub = data[6];
uint8_t lssNext = data[7];
uint32_t valSw;
uint32_t idNumber;
bool_t ack;
@ -121,7 +123,8 @@ static void CO_LSSslave_receive(void *object, void *msg)
break;
}
CO_memcpySwap4(&idNumber, &data[1]);
memcpy(&valSw, &data[1], sizeof(valSw));
idNumber = CO_SWAP_32(valSw);
ack = false;
if (bitCheck == CO_LSS_FASTSCAN_CONFIRM) {
@ -317,6 +320,7 @@ bool_t CO_LSSslave_process(CO_LSSslave_t *LSSslave) {
uint8_t tableSelector;
uint8_t tableIndex;
bool_t CANsend = false;
uint32_t valSw;
memset(&LSSslave->TXbuff->data[0], 0, sizeof(LSSslave->TXbuff->data));
@ -394,8 +398,8 @@ bool_t CO_LSSslave_process(CO_LSSslave_t *LSSslave) {
/* notify application */
if (LSSslave->pFunctLSSactivateBitRate != NULL) {
uint16_t delay;
CO_memcpySwap2(&delay, &LSSslave->CANdata[1]);
uint16_t delay = ((uint16_t) LSSslave->CANdata[2]) << 8;
delay |= LSSslave->CANdata[1];
LSSslave->pFunctLSSactivateBitRate(
LSSslave->functLSSactivateBitRateObject, delay);
}
@ -429,29 +433,29 @@ bool_t CO_LSSslave_process(CO_LSSslave_t *LSSslave) {
}
case CO_LSS_INQUIRE_VENDOR: {
LSSslave->TXbuff->data[0] = LSSslave->service;
CO_memcpySwap4(&LSSslave->TXbuff->data[1],
&LSSslave->lssAddress.identity.vendorID);
valSw = CO_SWAP_32(LSSslave->lssAddress.identity.vendorID);
memcpy(&LSSslave->TXbuff->data[1], &valSw, sizeof(valSw));
CANsend = true;
break;
}
case CO_LSS_INQUIRE_PRODUCT: {
LSSslave->TXbuff->data[0] = LSSslave->service;
CO_memcpySwap4(&LSSslave->TXbuff->data[1],
&LSSslave->lssAddress.identity.productCode);
valSw = CO_SWAP_32(LSSslave->lssAddress.identity.productCode);
memcpy(&LSSslave->TXbuff->data[1], &valSw, sizeof(valSw));
CANsend = true;
break;
}
case CO_LSS_INQUIRE_REV: {
LSSslave->TXbuff->data[0] = LSSslave->service;
CO_memcpySwap4(&LSSslave->TXbuff->data[1],
&LSSslave->lssAddress.identity.revisionNumber);
valSw = CO_SWAP_32(LSSslave->lssAddress.identity.revisionNumber);
memcpy(&LSSslave->TXbuff->data[1], &valSw, sizeof(valSw));
CANsend = true;
break;
}
case CO_LSS_INQUIRE_SERIAL: {
LSSslave->TXbuff->data[0] = LSSslave->service;
CO_memcpySwap4(&LSSslave->TXbuff->data[1],
&LSSslave->lssAddress.identity.serialNumber);
valSw = CO_SWAP_32(LSSslave->lssAddress.identity.serialNumber);
memcpy(&LSSslave->TXbuff->data[1], &valSw, sizeof(valSw));
CANsend = true;
break;
}

4
README.md
View file

@ -5,8 +5,8 @@ CANopenNode is free and open source CANopen protocol stack.
CANopen is the internationally standardized (EN 50325-4)
([CiA301](http://can-cia.org/standardization/technical-documents))
CAN-based higher-layer protocol for embedded control system. For more
information on CANopen see http://www.can-cia.org/
higher-layer protocol for embedded control system built on top of CAN.
For more information on CANopen see http://www.can-cia.org/
CANopenNode is written in ANSI C in object-oriented way. It runs on
different microcontrollers, as standalone application or with RTOS.

7
extra/CO_trace.c
View file

@ -25,6 +25,7 @@
#include "extra/CO_trace.h"
#include <stdio.h>
#include <string.h>
#ifndef CO_OWN_INTTYPES
#include <inttypes.h> /* for PRIu32("u" or "lu") and PRId32("d" or "ld") */
#endif
@ -47,8 +48,10 @@ static uint32_t printPointCsvUnsigned(char *s, uint32_t size, uint32_t timeStamp
}
static uint32_t printPointBinary(char *s, uint32_t size, uint32_t timeStamp, int32_t value) {
if(size < 8) return 0;
CO_memcpySwap4(s, &timeStamp);
CO_memcpySwap4(s+4, &value);
uint32_t timeStampSw = CO_SWAP_32(timeStamp);
int32_t valueSw = CO_SWAP_32(value);
memcpy(s, &timeStampSw, sizeof(timeStampSw));
memcpy(s+4, &valueSw, sizeof(valueSw));
return 8;
}
static uint32_t printPointSvgStart(char *s, uint32_t size, uint32_t timeStamp, int32_t value) {