nikon/CANopenNode
1
0
Fork 0
Code Activity Actions

Remove /*********...*/ comment delimiters.

Browse source
This commit is contained in:
Janez 2024-07-06 18:53:40 +02:00
parent 2857d749be
commit 0d016a0019
18 changed files with 0 additions and 96 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
301/CO_Emergency.c
View file

@ -336,7 +336,6 @@ static void CO_EM_receive(void *object, void *msg) {
#endif
/******************************************************************************/
CO_ReturnError_t CO_EM_init(CO_EM_t *em,
CO_CANmodule_t *CANdevTx,
const OD_entry_t *OD_1001_errReg,
@ -521,7 +520,6 @@ CO_ReturnError_t CO_EM_init(CO_EM_t *em,
}
/******************************************************************************/
#if ((CO_CONFIG_EM) & CO_CONFIG_EM_CONSUMER) != 0
void CO_EM_initCallbackRx(CO_EM_t *em,
void (*pFunctSignalRx)(const uint16_t ident,
@ -549,7 +547,6 @@ void CO_EM_initCallbackPre(CO_EM_t *em,
#endif
/******************************************************************************/
void CO_EM_process(CO_EM_t *em,
bool_t NMTisPreOrOperational,
uint32_t timeDifference_us,
@ -723,7 +720,6 @@ void CO_EM_process(CO_EM_t *em,
}
/******************************************************************************/
void CO_error(CO_EM_t *em, bool_t setError, const uint8_t errorBit,
uint16_t errorCode, uint32_t infoCode)
{

12
301/CO_HBconsumer.c
View file

@ -106,7 +106,6 @@ static ODR_t OD_write_1016(OD_stream_t *stream, const void *buf,
#endif
/******************************************************************************/
CO_ReturnError_t CO_HBconsumer_init(CO_HBconsumer_t *HBcons,
CO_EM_t *em,
CO_HBconsNode_t *monitoredNodes,
@ -171,7 +170,6 @@ CO_ReturnError_t CO_HBconsumer_init(CO_HBconsumer_t *HBcons,
}
/******************************************************************************/
static CO_ReturnError_t CO_HBconsumer_initEntry(CO_HBconsumer_t *HBcons,
uint8_t idx,
uint8_t nodeId,
@ -233,7 +231,6 @@ static CO_ReturnError_t CO_HBconsumer_initEntry(CO_HBconsumer_t *HBcons,
#if ((CO_CONFIG_HB_CONS) & CO_CONFIG_FLAG_CALLBACK_PRE) != 0
/******************************************************************************/
void CO_HBconsumer_initCallbackPre(
CO_HBconsumer_t *HBcons,
void *object,
@ -251,7 +248,6 @@ void CO_HBconsumer_initCallbackPre(
#if ((CO_CONFIG_HB_CONS) & CO_CONFIG_HB_CONS_CALLBACK_CHANGE) != 0
/******************************************************************************/
void CO_HBconsumer_initCallbackNmtChanged(
CO_HBconsumer_t *HBcons,
uint8_t idx,
@ -272,7 +268,6 @@ void CO_HBconsumer_initCallbackNmtChanged(
#if ((CO_CONFIG_HB_CONS) & CO_CONFIG_HB_CONS_CALLBACK_MULTI) != 0
/******************************************************************************/
void CO_HBconsumer_initCallbackNmtChanged(
CO_HBconsumer_t *HBcons,
uint8_t idx,
@ -291,7 +286,6 @@ void CO_HBconsumer_initCallbackNmtChanged(
}
/******************************************************************************/
void CO_HBconsumer_initCallbackHeartbeatStarted(
CO_HBconsumer_t *HBcons,
uint8_t idx,
@ -310,7 +304,6 @@ void CO_HBconsumer_initCallbackHeartbeatStarted(
}
/******************************************************************************/
void CO_HBconsumer_initCallbackTimeout(
CO_HBconsumer_t *HBcons,
uint8_t idx,
@ -329,7 +322,6 @@ void CO_HBconsumer_initCallbackTimeout(
}
/******************************************************************************/
void CO_HBconsumer_initCallbackRemoteReset(
CO_HBconsumer_t *HBcons,
uint8_t idx,
@ -349,7 +341,6 @@ void CO_HBconsumer_initCallbackRemoteReset(
#endif /* (CO_CONFIG_HB_CONS) & CO_CONFIG_HB_CONS_CALLBACK_MULTI */
/******************************************************************************/
void CO_HBconsumer_process(
CO_HBconsumer_t *HBcons,
bool_t NMTisPreOrOperational,
@ -498,7 +489,6 @@ void CO_HBconsumer_process(
#if ((CO_CONFIG_HB_CONS) & CO_CONFIG_HB_CONS_QUERY_FUNCT) != 0
/******************************************************************************/
int8_t CO_HBconsumer_getIdxByNodeId(
CO_HBconsumer_t *HBcons,
uint8_t nodeId)
@ -523,7 +513,6 @@ int8_t CO_HBconsumer_getIdxByNodeId(
}
/******************************************************************************/
CO_HBconsumer_state_t CO_HBconsumer_getState(
CO_HBconsumer_t *HBcons,
uint8_t idx)
@ -538,7 +527,6 @@ CO_HBconsumer_state_t CO_HBconsumer_getState(
return monitoredNode->HBstate;
}
/******************************************************************************/
int8_t CO_HBconsumer_getNmtState(
CO_HBconsumer_t *HBcons,
uint8_t idx,

4
301/CO_NMT_Heartbeat.c
View file

@ -74,7 +74,6 @@ static ODR_t OD_write_1017(OD_stream_t *stream, const void *buf,
}
/******************************************************************************/
CO_ReturnError_t CO_NMT_init(CO_NMT_t *NMT,
OD_entry_t *OD_1017_ProducerHbTime,
CO_EM_t *em,
@ -198,7 +197,6 @@ void CO_NMT_initCallbackPre(CO_NMT_t *NMT,
#if ((CO_CONFIG_NMT) & CO_CONFIG_NMT_CALLBACK_CHANGE) != 0
/******************************************************************************/
void CO_NMT_initCallbackChanged(CO_NMT_t *NMT,
void (*pFunctNMT)(CO_NMT_internalState_t state))
{
@ -212,7 +210,6 @@ void CO_NMT_initCallbackChanged(CO_NMT_t *NMT,
#endif
/******************************************************************************/
CO_NMT_reset_cmd_t CO_NMT_process(CO_NMT_t *NMT,
CO_NMT_internalState_t *NMTstate,
uint32_t timeDifference_us,
@ -330,7 +327,6 @@ CO_NMT_reset_cmd_t CO_NMT_process(CO_NMT_t *NMT,
#if ((CO_CONFIG_NMT) & CO_CONFIG_NMT_MASTER) != 0
/******************************************************************************/
CO_ReturnError_t CO_NMT_sendCommand(CO_NMT_t *NMT,
CO_NMT_command_t command,
uint8_t nodeID)

5
301/CO_Node_Guarding.c
View file

@ -97,7 +97,6 @@ static ODR_t OD_write_100D(OD_stream_t *stream, const void *buf,
}
/******************************************************************************/
CO_ReturnError_t CO_nodeGuardingSlave_init(CO_nodeGuardingSlave_t *ngs,
OD_entry_t *OD_100C_GuardTime,
OD_entry_t *OD_100D_LifeTimeFactor,
@ -199,7 +198,6 @@ CO_ReturnError_t CO_nodeGuardingSlave_init(CO_nodeGuardingSlave_t *ngs,
}
/******************************************************************************/
void CO_nodeGuardingSlave_process(CO_nodeGuardingSlave_t *ngs,
CO_NMT_internalState_t NMTstate,
bool_t slaveDisable,
@ -305,7 +303,6 @@ static void CO_ngm_receive(void *object, void *msg) {
}
/******************************************************************************/
CO_ReturnError_t CO_nodeGuardingMaster_init(CO_nodeGuardingMaster_t *ngm,
CO_EM_t *em,
CO_CANmodule_t *CANdevRx,
@ -358,7 +355,6 @@ CO_ReturnError_t CO_nodeGuardingMaster_init(CO_nodeGuardingMaster_t *ngm,
}
/******************************************************************************/
CO_ReturnError_t CO_nodeGuardingMaster_initNode(CO_nodeGuardingMaster_t *ngm,
uint8_t index,
uint8_t nodeId,
@ -392,7 +388,6 @@ CO_ReturnError_t CO_nodeGuardingMaster_initNode(CO_nodeGuardingMaster_t *ngm,
}
/******************************************************************************/
void CO_nodeGuardingMaster_process(CO_nodeGuardingMaster_t *ngm,
uint32_t timeDifference_us,
uint32_t *timerNext_us)

6
301/CO_ODinterface.c
View file

@ -22,7 +22,6 @@
#include "301/CO_ODinterface.h"
/******************************************************************************/
ODR_t OD_readOriginal(OD_stream_t *stream, void *buf,
OD_size_t count, OD_size_t *countRead)
{
@ -66,7 +65,6 @@ ODR_t OD_readOriginal(OD_stream_t *stream, void *buf,
return returnCode;
}
/******************************************************************************/
ODR_t OD_writeOriginal(OD_stream_t *stream, const void *buf,
OD_size_t count, OD_size_t *countWritten)
{
@ -142,7 +140,6 @@ 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 == 0U)) {
return NULL;
@ -181,7 +178,6 @@ OD_entry_t *OD_find(OD_t *od, uint16_t index) {
return NULL; /* entry does not exist in OD */
}
/******************************************************************************/
ODR_t OD_getSub(const OD_entry_t *entry, uint8_t subIndex,
OD_IO_t *io, bool_t odOrig)
{
@ -267,7 +263,6 @@ ODR_t OD_getSub(const OD_entry_t *entry, uint8_t subIndex,
return ODR_OK;
}
/******************************************************************************/
uint32_t OD_getSDOabCode(ODR_t returnCode) {
static const uint32_t abortCodes[(uint8_t)ODR_COUNT] = {
0x00000000UL, /* No abort */
@ -303,7 +298,6 @@ uint32_t OD_getSDOabCode(ODR_t returnCode) {
}
/******************************************************************************/
ODR_t OD_get_value(const OD_entry_t *entry, uint8_t subIndex,
void *val, OD_size_t len, bool_t odOrig)
{

4
301/CO_PDO.c
View file

@ -625,7 +625,6 @@ static ODR_t OD_write_14xx(OD_stream_t *stream, const void *buf,
#endif /* (CO_CONFIG_PDO) & CO_CONFIG_FLAG_OD_DYNAMIC */
/******************************************************************************/
CO_ReturnError_t CO_RPDO_init(CO_RPDO_t *RPDO,
OD_t *OD,
CO_EM_t *em,
@ -774,7 +773,6 @@ void CO_RPDO_initCallbackPre(CO_RPDO_t *RPDO,
#endif
/******************************************************************************/
void CO_RPDO_process(CO_RPDO_t *RPDO,
#if ((CO_CONFIG_PDO) & CO_CONFIG_RPDO_TIMERS_ENABLE) != 0
uint32_t timeDifference_us,
@ -1075,7 +1073,6 @@ static ODR_t OD_write_18xx(OD_stream_t *stream, const void *buf,
#endif /* (CO_CONFIG_PDO) & CO_CONFIG_FLAG_OD_DYNAMIC */
/******************************************************************************/
CO_ReturnError_t CO_TPDO_init(CO_TPDO_t *TPDO,
OD_t *OD,
CO_EM_t *em,
@ -1326,7 +1323,6 @@ static CO_ReturnError_t CO_TPDOsend(CO_TPDO_t *TPDO) {
}
/******************************************************************************/
void CO_TPDO_process(CO_TPDO_t *TPDO,
#if (((CO_CONFIG_PDO) & CO_CONFIG_TPDO_TIMERS_ENABLE) != 0) || defined CO_DOXYGEN
uint32_t timeDifference_us,

8
301/CO_SDOclient.c
View file

@ -247,7 +247,6 @@ static ODR_t OD_write_1280(OD_stream_t *stream, const void *buf,
#endif /* (CO_CONFIG_SDO_CLI) & CO_CONFIG_FLAG_OD_DYNAMIC */
/******************************************************************************/
CO_ReturnError_t CO_SDOclient_init(CO_SDOclient_t *SDO_C,
OD_t *OD,
OD_entry_t *OD_1280_SDOcliPar,
@ -336,7 +335,6 @@ CO_ReturnError_t CO_SDOclient_init(CO_SDOclient_t *SDO_C,
#if ((CO_CONFIG_SDO_CLI) & CO_CONFIG_FLAG_CALLBACK_PRE) != 0
/******************************************************************************/
void CO_SDOclient_initCallbackPre(CO_SDOclient_t *SDOclient,
void *object,
void (*pFunctSignal)(void *object))
@ -362,7 +360,6 @@ static inline void reverseBytes(void *start, OD_size_t size) {
#endif
/******************************************************************************/
CO_SDO_return_t CO_SDOclient_setup(CO_SDOclient_t *SDO_C,
uint32_t COB_IDClientToServer,
uint32_t COB_IDServerToClient,
@ -503,7 +500,6 @@ void CO_SDOclientDownloadInitSize(CO_SDOclient_t *SDO_C,
}
/******************************************************************************/
size_t CO_SDOclientDownloadBufWrite(CO_SDOclient_t *SDO_C,
const uint8_t *buf,
size_t count)
@ -516,7 +512,6 @@ size_t CO_SDOclientDownloadBufWrite(CO_SDOclient_t *SDO_C,
}
/******************************************************************************/
CO_SDO_return_t CO_SDOclientDownload(CO_SDOclient_t *SDO_C,
uint32_t timeDifference_us,
bool_t send_abort,
@ -1229,7 +1224,6 @@ CO_SDO_return_t CO_SDOclientUploadInitiate(CO_SDOclient_t *SDO_C,
}
/******************************************************************************/
CO_SDO_return_t CO_SDOclientUpload(CO_SDOclient_t *SDO_C,
uint32_t timeDifference_us,
bool_t send_abort,
@ -1959,7 +1953,6 @@ CO_SDO_return_t CO_SDOclientUpload(CO_SDOclient_t *SDO_C,
}
/******************************************************************************/
size_t CO_SDOclientUploadBufRead(CO_SDOclient_t *SDO_C,
uint8_t *buf,
size_t count)
@ -1972,7 +1965,6 @@ size_t CO_SDOclientUploadBufRead(CO_SDOclient_t *SDO_C,
}
/******************************************************************************/
void CO_SDOclientClose(CO_SDOclient_t *SDO_C) {
if (SDO_C != NULL) {
SDO_C->state = CO_SDO_ST_IDLE;

3
301/CO_SDOserver.c
View file

@ -308,7 +308,6 @@ static ODR_t OD_write_1201_additional(OD_stream_t *stream, const void *buf,
#endif /* (CO_CONFIG_SDO_SRV) & CO_CONFIG_FLAG_OD_DYNAMIC */
/******************************************************************************/
CO_ReturnError_t CO_SDOserver_init(CO_SDOserver_t *SDO,
OD_t *OD,
OD_entry_t *OD_1200_SDOsrvPar,
@ -434,7 +433,6 @@ CO_ReturnError_t CO_SDOserver_init(CO_SDOserver_t *SDO,
#if ((CO_CONFIG_SDO_SRV) & CO_CONFIG_FLAG_CALLBACK_PRE) != 0
/******************************************************************************/
void CO_SDOserver_initCallbackPre(CO_SDOserver_t *SDO,
void *object,
void (*pFunctSignalPre)(void *object))
@ -685,7 +683,6 @@ static bool_t readFromOd(CO_SDOserver_t *SDO,
#endif
/******************************************************************************/
CO_SDO_return_t CO_SDOserver_process(CO_SDOserver_t *SDO,
bool_t NMTisPreOrOperational,
uint32_t timeDifference_us,

3
301/CO_SYNC.c
View file

@ -196,7 +196,6 @@ static ODR_t OD_write_1019(OD_stream_t *stream, const void *buf,
#endif /* (CO_CONFIG_SYNC) & CO_CONFIG_FLAG_OD_DYNAMIC */
/******************************************************************************/
CO_ReturnError_t CO_SYNC_init(CO_SYNC_t *SYNC,
CO_EM_t *em,
OD_entry_t *OD_1005_cobIdSync,
@ -344,7 +343,6 @@ CO_ReturnError_t CO_SYNC_init(CO_SYNC_t *SYNC,
#if ((CO_CONFIG_SYNC) & CO_CONFIG_FLAG_CALLBACK_PRE) != 0
/******************************************************************************/
void CO_SYNC_initCallbackPre(
CO_SYNC_t *SYNC,
void *object,
@ -358,7 +356,6 @@ void CO_SYNC_initCallbackPre(
#endif
/******************************************************************************/
CO_SYNC_status_t CO_SYNC_process(CO_SYNC_t *SYNC,
bool_t NMTisPreOrOperational,
uint32_t timeDifference_us,

8
301/CO_fifo.c
View file

@ -47,7 +47,6 @@
#endif
#endif
/******************************************************************************/
void CO_fifo_init(CO_fifo_t *fifo, uint8_t *buf, size_t bufSize) {
if ((fifo == NULL) || (buf == NULL) || (bufSize < 2U)) {
@ -122,7 +121,6 @@ size_t CO_fifo_write(CO_fifo_t *fifo,
}
/******************************************************************************/
size_t CO_fifo_read(CO_fifo_t *fifo, uint8_t *buf, size_t count, bool_t *eof) {
size_t i;
const uint8_t *bufSrc;
@ -172,7 +170,6 @@ 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_ALT_READ) != 0
/******************************************************************************/
size_t CO_fifo_altBegin(CO_fifo_t *fifo, size_t offset) {
size_t i;
@ -255,7 +252,6 @@ size_t CO_fifo_altRead(CO_fifo_t *fifo, uint8_t *buf, size_t count) {
#if ((CO_CONFIG_FIFO) & CO_CONFIG_FIFO_ASCII_COMMANDS) != 0
/******************************************************************************/
bool_t CO_fifo_CommSearch(CO_fifo_t *fifo, bool_t clear) {
bool_t newCommand = false;
size_t count;
@ -310,7 +306,6 @@ 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;
bool_t alive_cycle = true;
@ -343,7 +338,6 @@ bool_t CO_fifo_trimSpaces(CO_fifo_t *fifo, bool_t *insideComment) {
}
/******************************************************************************/
size_t CO_fifo_readToken(CO_fifo_t *fifo,
char *buf,
size_t count,
@ -480,7 +474,6 @@ size_t CO_fifo_readToken(CO_fifo_t *fifo,
#if ((CO_CONFIG_FIFO) & CO_CONFIG_FIFO_ASCII_DATATYPES) != 0
/******************************************************************************/
/* Tables for mime-base64 encoding, as specified in RFC 2045, (without CR-LF,
* but one long string). Base64 is used for encoding binary data into easy
* transferable printable characters. In general, each three bytes of binary
@ -866,7 +859,6 @@ size_t CO_fifo_readB642a(CO_fifo_t *fifo, char *buf, size_t count, bool_t end) {
}
/******************************************************************************/
size_t CO_fifo_cpyTok2U8(CO_fifo_t *dest, CO_fifo_t *src, uint8_t *status) {
char buf[15];
uint8_t closed = 0xFFU;

2
301/crc16-ccitt.c
View file

@ -76,14 +76,12 @@ static const uint16_t crc16_ccitt_table[256] = {
};
/******************************************************************************/
void crc16_ccitt_single(uint16_t *crc, const uint8_t chr) {
uint8_t tmp = (uint8_t)(*crc >> 8U) ^ chr;
*crc = (uint16_t)((*crc << 8U) ^ crc16_ccitt_table[tmp]);
}
/******************************************************************************/
uint16_t crc16_ccitt(const uint8_t block[],
size_t blockLength,
uint16_t crc)

2
303/CO_LEDs.c
View file

@ -22,7 +22,6 @@
#if ((CO_CONFIG_LEDS) & CO_CONFIG_LEDS_ENABLE) != 0
/******************************************************************************/
CO_ReturnError_t CO_LEDs_init(CO_LEDs_t *LEDs) {
CO_ReturnError_t ret = CO_ERROR_NO;
@ -38,7 +37,6 @@ CO_ReturnError_t CO_LEDs_init(CO_LEDs_t *LEDs) {
}
/******************************************************************************/
void CO_LEDs_process(CO_LEDs_t *LEDs,
uint32_t timeDifference_us,
CO_NMT_internalState_t NMTstate,

12
305/CO_LSSmaster.c
View file

@ -121,7 +121,6 @@ static inline CO_LSSmaster_return_t CO_LSSmaster_check_timeout(
}
/******************************************************************************/
CO_ReturnError_t CO_LSSmaster_init(
CO_LSSmaster_t *LSSmaster,
uint16_t timeout_ms,
@ -178,7 +177,6 @@ CO_ReturnError_t CO_LSSmaster_init(
}
/******************************************************************************/
void CO_LSSmaster_changeTimeout(
CO_LSSmaster_t *LSSmaster,
uint16_t timeout_ms)
@ -190,7 +188,6 @@ void CO_LSSmaster_changeTimeout(
#if ((CO_CONFIG_LSS) & CO_CONFIG_FLAG_CALLBACK_PRE) != 0
/******************************************************************************/
void CO_LSSmaster_initCallbackPre(
CO_LSSmaster_t *LSSmaster,
void *object,
@ -280,7 +277,6 @@ static CO_LSSmaster_return_t CO_LSSmaster_switchStateSelectWait(
return ret;
}
/******************************************************************************/
CO_LSSmaster_return_t CO_LSSmaster_swStateSelect(
CO_LSSmaster_t *LSSmaster,
uint32_t timeDifference_us,
@ -317,7 +313,6 @@ CO_LSSmaster_return_t CO_LSSmaster_swStateSelect(
}
/******************************************************************************/
CO_LSSmaster_return_t CO_LSSmaster_swStateDeselect(
CO_LSSmaster_t *LSSmaster)
{
@ -404,7 +399,6 @@ static CO_LSSmaster_return_t CO_LSSmaster_configureCheckWait(
}
/******************************************************************************/
CO_LSSmaster_return_t CO_LSSmaster_configureBitTiming(
CO_LSSmaster_t *LSSmaster,
uint32_t timeDifference_us,
@ -462,7 +456,6 @@ CO_LSSmaster_return_t CO_LSSmaster_configureBitTiming(
}
/******************************************************************************/
CO_LSSmaster_return_t CO_LSSmaster_configureNodeId(
CO_LSSmaster_t *LSSmaster,
uint32_t timeDifference_us,
@ -508,7 +501,6 @@ CO_LSSmaster_return_t CO_LSSmaster_configureNodeId(
}
/******************************************************************************/
CO_LSSmaster_return_t CO_LSSmaster_configureStore(
CO_LSSmaster_t *LSSmaster,
uint32_t timeDifference_us)
@ -549,7 +541,6 @@ CO_LSSmaster_return_t CO_LSSmaster_configureStore(
}
/******************************************************************************/
CO_LSSmaster_return_t CO_LSSmaster_ActivateBit(
CO_LSSmaster_t *LSSmaster,
uint16_t switchDelay_ms)
@ -623,7 +614,6 @@ static CO_LSSmaster_return_t CO_LSSmaster_inquireCheckWait(
return ret;
}
/******************************************************************************/
CO_LSSmaster_return_t CO_LSSmaster_InquireLssAddress(
CO_LSSmaster_t *LSSmaster,
uint32_t timeDifference_us,
@ -713,7 +703,6 @@ CO_LSSmaster_return_t CO_LSSmaster_InquireLssAddress(
}
/******************************************************************************/
CO_LSSmaster_return_t CO_LSSmaster_Inquire(
CO_LSSmaster_t *LSSmaster,
uint32_t timeDifference_us,
@ -987,7 +976,6 @@ static uint8_t CO_LSSmaster_FsSearchNext(
return CO_LSS_FASTSCAN_VENDOR_ID;
}
/******************************************************************************/
CO_LSSmaster_return_t CO_LSSmaster_IdentifyFastscan(
CO_LSSmaster_t *LSSmaster,
uint32_t timeDifference_us,

6
305/CO_LSSslave.c
View file

@ -196,7 +196,6 @@ static void CO_LSSslave_receive(void *object, void *msg)
}
/******************************************************************************/
CO_ReturnError_t CO_LSSslave_init(
CO_LSSslave_t *LSSslave,
CO_LSS_address_t *lssAddress,
@ -263,7 +262,6 @@ CO_ReturnError_t CO_LSSslave_init(
#if ((CO_CONFIG_LSS) & CO_CONFIG_FLAG_CALLBACK_PRE) != 0
/******************************************************************************/
void CO_LSSslave_initCallbackPre(
CO_LSSslave_t *LSSslave,
void *object,
@ -277,7 +275,6 @@ void CO_LSSslave_initCallbackPre(
#endif
/******************************************************************************/
void CO_LSSslave_initCkBitRateCall(
CO_LSSslave_t *LSSslave,
void *object,
@ -290,7 +287,6 @@ void CO_LSSslave_initCkBitRateCall(
}
/******************************************************************************/
void CO_LSSslave_initActBitRateCall(
CO_LSSslave_t *LSSslave,
void *object,
@ -303,7 +299,6 @@ void CO_LSSslave_initActBitRateCall(
}
/******************************************************************************/
void CO_LSSslave_initCfgStoreCall(
CO_LSSslave_t *LSSslave,
void *object,
@ -316,7 +311,6 @@ void CO_LSSslave_initCfgStoreCall(
}
/******************************************************************************/
bool_t CO_LSSslave_process(CO_LSSslave_t *LSSslave) {
bool_t resetCommunication = false;

3
309/CO_gateway_ascii.c
View file

@ -43,7 +43,6 @@
#endif
#endif
/******************************************************************************/
CO_ReturnError_t CO_GTWA_init(CO_GTWA_t* gtwa,
#if (((CO_CONFIG_GTW) & CO_CONFIG_GTW_ASCII_SDO) != 0) || defined CO_DOXYGEN
CO_SDOclient_t* SDO_C,
@ -117,7 +116,6 @@ CO_ReturnError_t CO_GTWA_init(CO_GTWA_t* gtwa,
}
/******************************************************************************/
void CO_GTWA_initRead(CO_GTWA_t* gtwa,
size_t (*readCallback)(void *object,
const char *buf,
@ -132,7 +130,6 @@ void CO_GTWA_initRead(CO_GTWA_t* gtwa,
}
/******************************************************************************/
#if ((CO_CONFIG_GTW) & CO_CONFIG_GTW_ASCII_LOG) != 0
void CO_GTWA_log_print(CO_GTWA_t* gtwa, const char *message) {
if ((gtwa != NULL) && (message != NULL)) {

10
example/CO_driver_blank.c
View file

@ -24,13 +24,11 @@
#include "301/CO_driver.h"
/******************************************************************************/
void CO_CANsetConfigurationMode(void *CANptr){
/* Put CAN module in configuration mode */
}
/******************************************************************************/
void CO_CANsetNormalMode(CO_CANmodule_t *CANmodule){
/* Put CAN module in normal mode */
@ -38,7 +36,6 @@ void CO_CANsetNormalMode(CO_CANmodule_t *CANmodule){
}
/******************************************************************************/
CO_ReturnError_t CO_CANmodule_init(
CO_CANmodule_t *CANmodule,
void *CANptr,
@ -107,7 +104,6 @@ CO_ReturnError_t CO_CANmodule_init(
}
/******************************************************************************/
void CO_CANmodule_disable(CO_CANmodule_t *CANmodule) {
if (CANmodule != NULL) {
/* turn off the module */
@ -115,7 +111,6 @@ void CO_CANmodule_disable(CO_CANmodule_t *CANmodule) {
}
/******************************************************************************/
CO_ReturnError_t CO_CANrxBufferInit(
CO_CANmodule_t *CANmodule,
uint16_t index,
@ -155,7 +150,6 @@ CO_ReturnError_t CO_CANrxBufferInit(
}
/******************************************************************************/
CO_CANtx_t *CO_CANtxBufferInit(
CO_CANmodule_t *CANmodule,
uint16_t index,
@ -184,7 +178,6 @@ CO_CANtx_t *CO_CANtxBufferInit(
}
/******************************************************************************/
CO_ReturnError_t CO_CANsend(CO_CANmodule_t *CANmodule, CO_CANtx_t *buffer){
CO_ReturnError_t err = CO_ERROR_NO;
@ -214,7 +207,6 @@ CO_ReturnError_t CO_CANsend(CO_CANmodule_t *CANmodule, CO_CANtx_t *buffer){
}
/******************************************************************************/
void CO_CANclearPendingSyncPDOs(CO_CANmodule_t *CANmodule){
uint32_t tpdoDeleted = 0U;
@ -250,7 +242,6 @@ void CO_CANclearPendingSyncPDOs(CO_CANmodule_t *CANmodule){
}
/******************************************************************************/
/* Get error counters from the module. If necessary, function may use
* different way to determine errors. */
static uint16_t rxErrors=0, txErrors=0, overflow=0;
@ -305,7 +296,6 @@ void CO_CANmodule_process(CO_CANmodule_t *CANmodule) {
}
/******************************************************************************/
typedef struct {
uint32_t ident;
uint8_t DLC;

2
extra/CO_trace.c
View file

@ -394,7 +394,6 @@ static CO_SDO_abortCode_t CO_ODF_trace(CO_ODF_arg_t *ODF_arg) {
}
/******************************************************************************/
void CO_trace_init(
CO_trace_t *trace,
CO_SDO_t *SDO,
@ -451,7 +450,6 @@ void CO_trace_init(
}
/******************************************************************************/
void CO_trace_process(CO_trace_t *trace, uint32_t timestamp) {
if(trace->enabled) {

2
storage/CO_storageEeprom.c
View file

@ -98,7 +98,6 @@ static ODR_t restoreEeprom(CO_storage_entry_t *entry,
}
/******************************************************************************/
CO_ReturnError_t CO_storageEeprom_init(CO_storage_t *storage,
CO_CANmodule_t *CANmodule,
void *storageModule,
@ -219,7 +218,6 @@ 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) {