/*
* Configure RPDO Communication parameter.
*
* Function is called from commuincation reset or when parameter changes.
*
* Function configures following variable from CO_RPDO_t: _valid_. It also
* configures CAN rx buffer. If configuration fails, emergency message is send
* and device is not able to enter NMT operational.
*
* @param RPDO RPDO object.
* @param COB_IDUsedByRPDO _RPDO communication parameter_, _COB-ID for PDO_ variable
* from Object dictionary (index 0x1400+, subindex 1).
*/
static void CO_RPDOconfigCom(CO_RPDO_t* RPDO, uint32_t COB_IDUsedByRPDO){
uint16_t ID;
CO_ReturnError_t r;
ID = (uint16_t)COB_IDUsedByRPDO;
/* is RPDO used? */
if((COB_IDUsedByRPDO & 0xBFFFF800L) == 0 && RPDO->dataLength && ID){
/* is used default COB-ID? */
if(ID == RPDO->defaultCOB_ID) ID += RPDO->nodeId;
RPDO->valid = true;
}
else{
ID = 0;
RPDO->valid = false;
RPDO->CANrxNew = 0;
}
r = CO_CANrxBufferInit(
RPDO->CANdevRx, /* CAN device */
RPDO->CANdevRxIdx, /* rx buffer index */
ID, /* CAN identifier */
0x7FF, /* mask */
0, /* rtr */
(void*)RPDO, /* object passed to receive function */
CO_PDO_receive); /* this function will process received message */
if(r != CO_ERROR_NO){
RPDO->valid = false;
RPDO->CANrxNew = 0;
}
}
INTEGER8 CO_SDOclient_setup( CO_SDOclient_t *SDO_C,
UNSIGNED32 COB_IDClientToServer,
UNSIGNED32 COB_IDServerToClient,
UNSIGNED8 nodeIDOfTheSDOServer)
{
//verify parameters
if((COB_IDClientToServer&0x7FFFF800L) || (COB_IDServerToClient&0x7FFFF800L) ||
nodeIDOfTheSDOServer > 127) return -2;
//Configure object variables
SDO_C->state = 0;
//setup Object Dictionary variables
if((COB_IDClientToServer & 0x80000000L) || (COB_IDServerToClient & 0x80000000L) || nodeIDOfTheSDOServer == 0) {
//SDO is NOT used
SDO_C->ObjDict_SDOClientParameter->COB_IDClientToServer = 0x80000000L;
SDO_C->ObjDict_SDOClientParameter->COB_IDServerToClient = 0x80000000L;
SDO_C->ObjDict_SDOClientParameter->nodeIDOfTheSDOServer = 0;
}
else {
if(COB_IDClientToServer == 0 || COB_IDServerToClient == 0) {
SDO_C->ObjDict_SDOClientParameter->COB_IDClientToServer = 0x600 + nodeIDOfTheSDOServer;
SDO_C->ObjDict_SDOClientParameter->COB_IDServerToClient = 0x580 + nodeIDOfTheSDOServer;
}
else {
SDO_C->ObjDict_SDOClientParameter->COB_IDClientToServer = COB_IDClientToServer;
SDO_C->ObjDict_SDOClientParameter->COB_IDServerToClient = COB_IDServerToClient;
}
SDO_C->ObjDict_SDOClientParameter->nodeIDOfTheSDOServer = nodeIDOfTheSDOServer;
}
//configure SDO client CAN reception
CO_CANrxBufferInit( SDO_C->CANdevRx, //CAN device
SDO_C->CANdevRxIdx, //rx buffer index
(UNSIGNED16)SDO_C->ObjDict_SDOClientParameter->COB_IDServerToClient,//CAN identifier
0x7FF, //mask
0, //rtr
(void*)SDO_C, //object passed to receive function
CO_SDOclient_receive); //this function will process received message
//configure SDO client CAN transmission
SDO_C->CANtxBuff = CO_CANtxBufferInit(
SDO_C->CANdevTx, //CAN device
SDO_C->CANdevTxIdx, //index of specific buffer inside CAN module
(UNSIGNED16)SDO_C->ObjDict_SDOClientParameter->COB_IDClientToServer,//CAN identifier
0, //rtr
8, //number of data bytes
0); //synchronous message flag bit
return 0;
}
/*
* Function for accessing _COB ID SYNC Message_ (index 0x1005) from SDO server.
*
* For more information see file CO_SDO.h.
*/
static CO_SDO_abortCode_t CO_ODF_1005(CO_ODF_arg_t *ODF_arg){
CO_SYNC_t *SYNC;
uint32_t value;
CO_SDO_abortCode_t ret = CO_SDO_AB_NONE;
SYNC = (CO_SYNC_t*) ODF_arg->object;
value = CO_getUint32(ODF_arg->data);
if(!ODF_arg->reading){
uint8_t configureSyncProducer = 0;
/* only 11-bit CAN identifier is supported */
if(value & 0x20000000UL){
ret = CO_SDO_AB_INVALID_VALUE;
}
else{
/* is 'generate Sync messge' bit set? */
if(value & 0x40000000UL){
/* if bit was set before, value can not be changed */
if(SYNC->isProducer){
ret = CO_SDO_AB_DATA_DEV_STATE;
}
else{
configureSyncProducer = 1;
}
}
}
/* configure sync producer and consumer */
if(ret == CO_SDO_AB_NONE){
SYNC->COB_ID = (uint16_t)(value & 0x7FFU);
if(configureSyncProducer){
uint8_t len = 0U;
if(SYNC->counterOverflowValue != 0U){
len = 1U;
SYNC->counter = 0U;
SYNC->timer = 0U;
}
SYNC->CANtxBuff = CO_CANtxBufferInit(
SYNC->CANdevTx, /* CAN device */
SYNC->CANdevTxIdx, /* index of specific buffer inside CAN module */
SYNC->COB_ID, /* CAN identifier */
0, /* rtr */
len, /* number of data bytes */
0); /* synchronous message flag bit */
SYNC->isProducer = true;
}
else{
SYNC->isProducer = false;
}
CO_CANrxBufferInit(
SYNC->CANdevRx, /* CAN device */
SYNC->CANdevRxIdx, /* rx buffer index */
SYNC->COB_ID, /* CAN identifier */
0x7FF, /* mask */
0, /* rtr */
(void*)SYNC, /* object passed to receive function */
CO_SYNC_receive); /* this function will process received message */
}
}
return ret;
}
CO_ReturnError_t CO_SYNC_init(
CO_SYNC_t *SYNC,
CO_EM_t *em,
CO_SDO_t *SDO,
uint8_t *operatingState,
uint32_t COB_ID_SYNCMessage,
uint32_t communicationCyclePeriod,
uint8_t synchronousCounterOverflowValue,
CO_CANmodule_t *CANdevRx,
uint16_t CANdevRxIdx,
CO_CANmodule_t *CANdevTx,
uint16_t CANdevTxIdx)
{
uint8_t len = 0;
/* verify arguments */
if(SYNC==NULL || em==NULL || SDO==NULL || operatingState==NULL ||
CANdevRx==NULL || CANdevTx==NULL){
return CO_ERROR_ILLEGAL_ARGUMENT;
}
/* Configure object variables */
SYNC->isProducer = (COB_ID_SYNCMessage&0x40000000L) ? true : false;
SYNC->COB_ID = COB_ID_SYNCMessage&0x7FF;
SYNC->periodTime = communicationCyclePeriod;
SYNC->periodTimeoutTime = communicationCyclePeriod / 2 * 3;
/* overflow? */
if(SYNC->periodTimeoutTime < communicationCyclePeriod) SYNC->periodTimeoutTime = 0xFFFFFFFFL;
SYNC->counterOverflowValue = synchronousCounterOverflowValue;
if(synchronousCounterOverflowValue) len = 1;
SYNC->curentSyncTimeIsInsideWindow = true;
SYNC->CANrxNew = false;
SYNC->timer = 0;
SYNC->counter = 0;
SYNC->receiveError = 0U;
SYNC->em = em;
SYNC->operatingState = operatingState;
SYNC->cbSync = NULL;
SYNC->CANdevRx = CANdevRx;
SYNC->CANdevRxIdx = CANdevRxIdx;
/* Configure Object dictionary entry at index 0x1005, 0x1006 and 0x1019 */
CO_OD_configure(SDO, OD_H1005_COBID_SYNC, CO_ODF_1005, (void*)SYNC, 0, 0);
CO_OD_configure(SDO, OD_H1006_COMM_CYCL_PERIOD, CO_ODF_1006, (void*)SYNC, 0, 0);
CO_OD_configure(SDO, OD_H1019_SYNC_CNT_OVERFLOW, CO_ODF_1019, (void*)SYNC, 0, 0);
/* configure SYNC CAN reception */
CO_CANrxBufferInit(
CANdevRx, /* CAN device */
CANdevRxIdx, /* rx buffer index */
SYNC->COB_ID, /* CAN identifier */
0x7FF, /* mask */
0, /* rtr */
(void*)SYNC, /* object passed to receive function */
CO_SYNC_receive); /* this function will process received message */
/* configure SYNC CAN transmission */
SYNC->CANdevTx = CANdevTx;
SYNC->CANdevTxIdx = CANdevTxIdx;
SYNC->CANtxBuff = CO_CANtxBufferInit(
CANdevTx, /* CAN device */
CANdevTxIdx, /* index of specific buffer inside CAN module */
SYNC->COB_ID, /* CAN identifier */
0, /* rtr */
len, /* number of data bytes */
0); /* synchronous message flag bit */
return CO_ERROR_NO;
}
UNSIGNED32 CO_ODF_1005( void *object,
UNSIGNED16 index,
UNSIGNED8 subIndex,
UNSIGNED8 length,
UNSIGNED16 attribute,
UNSIGNED8 dir,
void *dataBuff,
const void *pData)
{
UNSIGNED8 configureSyncProducer = 0;
UNSIGNED32 abortCode;
CO_SYNC_t *SYNC;
UNSIGNED32 COB_ID;
SYNC = (CO_SYNC_t*) object; //this is the correct pointer type of the first argument
memcpySwap4((UNSIGNED8*)&COB_ID, (UNSIGNED8*)dataBuff);
if(dir == 1){ //Writing Object Dictionary variable
//only 11-bit CAN identifier is supported
if(COB_ID & 0x20000000L) return 0x06090030L; //Invalid value for parameter (download only).
//is 'generate Sync messge' bit set?
if(COB_ID&0x40000000L){
//if bit was set before, value can not be changed
if(SYNC->isProducer) return 0x08000022L; //Data cannot be transferred or stored to the application because of the present device state.
configureSyncProducer = 1;
}
}
abortCode = CO_ODF(object, index, subIndex, length, attribute, dir, dataBuff, pData);
if(abortCode == 0 && dir == 1){
SYNC->COB_ID = COB_ID&0x7FF;
if(configureSyncProducer){
UNSIGNED8 len = 0;
if(SYNC->counterOverflowValue){
len = 1;
SYNC->counter = 0;
SYNC->running = 0;
SYNC->timer = 0;
}
SYNC->CANtxBuff = CO_CANtxBufferInit(
SYNC->CANdevTx, //CAN device
SYNC->CANdevTxIdx, //index of specific buffer inside CAN module
SYNC->COB_ID, //CAN identifier
0, //rtr
len, //number of data bytes
0); //synchronous message flag bit
SYNC->isProducer = 1;
}
else{
SYNC->isProducer = 0;
}
CO_CANrxBufferInit(SYNC->CANdevRx, //CAN device
SYNC->CANdevRxIdx, //rx buffer index
SYNC->COB_ID, //CAN identifier
0x7FF, //mask
0, //rtr
(void*)SYNC, //object passed to receive function
CO_SYNC_receive); //this function will process received message
}
return abortCode;
}
INTEGER16 CO_SYNC_init(
CO_SYNC_t **ppSYNC,
CO_emergencyReport_t *EM,
CO_SDO_t *SDO,
UNSIGNED8 *operatingState,
UNSIGNED32 ObjDict_COB_ID_SYNCMessage,
UNSIGNED32 ObjDict_communicationCyclePeriod,
UNSIGNED8 ObjDict_synchronousCounterOverflowValue,
CO_CANmodule_t *CANdevRx, UNSIGNED16 CANdevRxIdx,
CO_CANmodule_t *CANdevTx, UNSIGNED16 CANdevTxIdx)
{
UNSIGNED8 len = 0;
CO_SYNC_t *SYNC;
//allocate memory if not already allocated
if((*ppSYNC) == NULL){
if(((*ppSYNC) = (CO_SYNC_t*) malloc(sizeof(CO_SYNC_t))) == NULL){ return CO_ERROR_OUT_OF_MEMORY;}
}
SYNC = *ppSYNC; //pointer to (newly created) object
//Configure object variables
SYNC->isProducer = (ObjDict_COB_ID_SYNCMessage&0x40000000L) ? 1 : 0;
SYNC->COB_ID = ObjDict_COB_ID_SYNCMessage&0x7FF;
SYNC->periodTime = ObjDict_communicationCyclePeriod;
SYNC->periodTimeoutTime = ObjDict_communicationCyclePeriod / 2 * 3;
//overflow?
if(SYNC->periodTimeoutTime < ObjDict_communicationCyclePeriod) SYNC->periodTimeoutTime = 0xFFFFFFFFL;
SYNC->counterOverflowValue = ObjDict_synchronousCounterOverflowValue;
if(ObjDict_synchronousCounterOverflowValue) len = 1;
SYNC->curentSyncTimeIsInsideWindow = 1;
CANdevTx->curentSyncTimeIsInsideWindow = &SYNC->curentSyncTimeIsInsideWindow; //parameter inside CAN module.
SYNC->running = 0;
SYNC->timer = 0;
SYNC->counter = 0;
SYNC->EM = EM;
SYNC->operatingState = operatingState;
SYNC->CANdevRx = CANdevRx;
SYNC->CANdevRxIdx = CANdevRxIdx;
//Configure SDO server for first argument of CO_ODF_1005, CO_ODF_1006 and CO_ODF_1019.
CO_OD_configureArgumentForODF(SDO, 0x1005, (void*)SYNC);
CO_OD_configureArgumentForODF(SDO, 0x1006, (void*)SYNC);
CO_OD_configureArgumentForODF(SDO, 0x1019, (void*)SYNC);
//configure SYNC CAN reception
CO_CANrxBufferInit( CANdevRx, //CAN device
CANdevRxIdx, //rx buffer index
SYNC->COB_ID, //CAN identifier
0x7FF, //mask
0, //rtr
(void*)SYNC, //object passed to receive function
CO_SYNC_receive); //this function will process received message
//configure SYNC CAN transmission
SYNC->CANdevTx = CANdevTx;
SYNC->CANdevTxIdx = CANdevTxIdx;
SYNC->CANtxBuff = CO_CANtxBufferInit(
CANdevTx, //CAN device
CANdevTxIdx, //index of specific buffer inside CAN module
SYNC->COB_ID, //CAN identifier
0, //rtr
len, //number of data bytes
0); //synchronous message flag bit
return CO_ERROR_NO;
}
int16_t CO_SDO_init(
CO_SDO_t *SDO,
uint16_t COB_IDClientToServer,
uint16_t COB_IDServerToClient,
uint16_t ObjDictIndex_SDOServerParameter,
CO_SDO_t *parentSDO,
const CO_OD_entry_t OD[],
uint16_t ODSize,
CO_OD_extension_t *ODExtensions,
uint8_t nodeId,
CO_CANmodule_t *CANdevRx,
uint16_t CANdevRxIdx,
CO_CANmodule_t *CANdevTx,
uint16_t CANdevTxIdx)
{
/* configure own object dictionary */
if(parentSDO == NULL){
uint16_t i;
SDO->ownOD = CO_true;
SDO->OD = OD;
SDO->ODSize = ODSize;
SDO->ODExtensions = ODExtensions;
/* clear pointers in ODExtensions */
for(i=0U; i<ODSize; i++){
SDO->ODExtensions[i].pODFunc = NULL;
SDO->ODExtensions[i].object = NULL;
SDO->ODExtensions[i].flags = NULL;
}
}
/* copy object dictionary from parent */
else{
SDO->ownOD = CO_false;
SDO->OD = parentSDO->OD;
SDO->ODSize = parentSDO->ODSize;
SDO->ODExtensions = parentSDO->ODExtensions;
}
/* Configure object variables */
SDO->nodeId = nodeId;
SDO->state = CO_SDO_ST_IDLE;
SDO->CANrxNew = CO_false;
SDO->pFunctSignal = 0;
SDO->functArg = 0;
/* Configure Object dictionary entry at index 0x1200 */
if(ObjDictIndex_SDOServerParameter == OD_H1200_SDO_SERVER_PARAM){
CO_OD_configure(SDO, ObjDictIndex_SDOServerParameter, CO_ODF_1200, (void*)&SDO->nodeId, 0U, 0U);
}
/* configure SDO server CAN reception */
CO_CANrxBufferInit(
CANdevRx, /* CAN device */
CANdevRxIdx, /* rx buffer index */
COB_IDClientToServer, /* CAN identifier */
0x7FF, /* mask */
0, /* rtr */
(void*)SDO, /* object passed to receive function */
CO_SDO_receive); /* this function will process received message */
/* configure SDO server CAN transmission */
SDO->CANdevTx = CANdevTx;
SDO->CANtxBuff = CO_CANtxBufferInit(
CANdevTx, /* CAN device */
CANdevTxIdx, /* index of specific buffer inside CAN module */
COB_IDServerToClient, /* CAN identifier */
0, /* rtr */
8, /* number of data bytes */
0); /* synchronous message flag bit */
return CO_ERROR_NO;
}
