www.pudn.com > ethercat-slave-source-code.rar > SampleApplicationInterface.c, change:2015-03-03,size:20621b
/**
* \addtogroup SlaveLibrary EtherCAT Slave Library
* @{
*/
/**
\file SampleApplicationInterface.c
\author EthercatSSC@beckhoff.com
\version 5.10
<br>Changes to version V5.01:<br>
V5.10 ECAT9: Change slave library interface application<br>
<br>Changes to version - :<br>
V5.01 : Start file change log
*/
/*-----------------------------------------------------------------------------------------
------
------ Includes
------
-----------------------------------------------------------------------------------------*/
#ifdef _WIN32
#include <stdio.h>
#include <tchar.h>
#endif
#include "ecat_def.h"
#if SAMPLE_APPLICATION_INTERFACE
#include "ecatslv.h"
#include "ecatappl.h"
/* ECATCHANGE_START(V5.10) ECAT9*/
#include "sdoserv.h"
#define IMPL_OR_EXTERN 1
#include "EtherCATSampleLibrary.h"
#undef IMPL_OR_EXTERN
/* ECATCHANGE_END(V5.10) ECAT9*/
#define _SAMPLE_APPLICATION_INTERFACE_
#include "SampleApplicationInterface.h"
#undef _SAMPLE_APPLICATION_INTERFACE_
void Ecat_StateTrans(unsigned short state);
/*--------------------------------------------------------------------------------------
------
------ local types and defines
------
--------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------
------
------ local variables and constants
------
-----------------------------------------------------------------------------------------*/
UINT8 HardwareOpened = 0;
/* ECATCHANGE_START(V5.10) ECAT9*/
UINT16 nInputSize = 4;
UINT16 nOutputSize = 4;
ECAT_SLAVE_INTERFACE SlaveInterface;
/* ECATCHANGE_END(V5.10) ECAT9*/
extern TSDOINFOENTRYDESC OBJMEM EntryDesc0x6000;
extern TSDOINFOENTRYDESC OBJMEM EntryDesc0x7010;
/*-----------------------------------------------------------------------------------------
------
------ application specific functions
------
-----------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------
------
------ generic functions
------
-----------------------------------------------------------------------------------------*/
/////////////////////////////////////////////////////////////////////////////////////////
/**
\brief The function is called when an error state was acknowledged by the master
*////////////////////////////////////////////////////////////////////////////////////////
void APPL_AckErrorInd(UINT16 stateTrans)
{
}
/////////////////////////////////////////////////////////////////////////////////////////
/**
\return AL Status Code (see ecatslv.h ALSTATUSCODE_....)
\brief The function is called in the state transition from INIT to PREOP when
all general settings were checked to start the mailbox handler. This function
informs the application about the state transition, the application can refuse
the state transition when returning an AL Status error code.
The return code NOERROR_INWORK can be used, if the application cannot confirm
the state transition immediately, in that case this function will be called cyclically
until a value unequal NOERROR_INWORK is returned
*////////////////////////////////////////////////////////////////////////////////////////
UINT16 APPL_StartMailboxHandler(void)
{
/* ECATCHANGE_START(V5.10) ECAT9*/
if(SlaveInterface.pStateTrans != NULL)
{
SlaveInterface.pStateTrans(INIT_2_PREOP);
}
/* ECATCHANGE_END(V5.10) ECAT9*/
return ALSTATUSCODE_NOERROR;
}
/////////////////////////////////////////////////////////////////////////////////////////
/**
\return 0, NOERROR_INWORK
\brief The function is called in the state transition from PREEOP to INIT
to stop the mailbox handler. This functions informs the application
about the state transition, the application cannot refuse
the state transition.
*////////////////////////////////////////////////////////////////////////////////////////
UINT16 APPL_StopMailboxHandler(void)
{
/* ECATCHANGE_START(V5.10) ECAT9*/
if(SlaveInterface.pStateTrans != NULL)
{
SlaveInterface.pStateTrans(PREOP_2_INIT);
}
/* ECATCHANGE_END(V5.10) ECAT9*/
return ALSTATUSCODE_NOERROR;
}
/////////////////////////////////////////////////////////////////////////////////////////
/**
\param pIntMask pointer to the AL Event Mask which will be written to the AL event Mask
register (0x204) when this function is succeeded. The event mask can be adapted
in this function
\return AL Status Code (see ecatslv.h ALSTATUSCODE_....)
\brief The function is called in the state transition from PREOP to SAFEOP when
all general settings were checked to start the input handler. This function
informs the application about the state transition, the application can refuse
the state transition when returning an AL Status error code.
The return code NOERROR_INWORK can be used, if the application cannot confirm
the state transition immediately, in that case the application need to be complete
the transition by calling ECAT_StateChange.
*////////////////////////////////////////////////////////////////////////////////////////
UINT16 APPL_StartInputHandler(UINT16 *pIntMask)
{
/* ECATCHANGE_START(V5.10) ECAT9*/
if(SlaveInterface.pStateTrans != NULL)
{
SlaveInterface.pStateTrans(PREOP_2_SAFEOP);
}
/* ECATCHANGE_END(V5.10) ECAT9*/
return ALSTATUSCODE_NOERROR;
}
/////////////////////////////////////////////////////////////////////////////////////////
/**
\return 0, NOERROR_INWORK
\brief The function is called in the state transition from SAFEOP to PREEOP
to stop the input handler. This functions informs the application
about the state transition, the application cannot refuse
the state transition.
*////////////////////////////////////////////////////////////////////////////////////////
UINT16 APPL_StopInputHandler(void)
{
/* ECATCHANGE_START(V5.10) ECAT9*/
if(SlaveInterface.pStateTrans != NULL)
{
SlaveInterface.pStateTrans(SAFEOP_2_PREOP);
}
/* ECATCHANGE_END(V5.10) ECAT9*/
return ALSTATUSCODE_NOERROR;
}
/////////////////////////////////////////////////////////////////////////////////////////
/**
\return AL Status Code (see ecatslv.h ALSTATUSCODE_....)
\brief The function is called in the state transition from SAFEOP to OP when
all general settings were checked to start the output handler. This function
informs the application about the state transition, the application can refuse
the state transition when returning an AL Status error code.
The return code NOERROR_INWORK can be used, if the application cannot confirm
the state transition immediately, in that case the application need to be complete
the transition by calling ECAT_StateChange.
*////////////////////////////////////////////////////////////////////////////////////////
UINT16 APPL_StartOutputHandler(void)
{
/* ECATCHANGE_START(V5.10) ECAT9*/
if(SlaveInterface.pStateTrans != NULL)
{
SlaveInterface.pStateTrans(SAFEOP_2_OP);
}
/* ECATCHANGE_END(V5.10) ECAT9*/
return ALSTATUSCODE_NOERROR;
}
/////////////////////////////////////////////////////////////////////////////////////////
/**
\return 0, NOERROR_INWORK
\brief The function is called in the state transition from OP to SAFEOP
to stop the output handler. This functions informs the application
about the state transition, the application cannot refuse
the state transition.
*////////////////////////////////////////////////////////////////////////////////////////
UINT16 APPL_StopOutputHandler(void)
{
/* ECATCHANGE_START(V5.10) ECAT9*/
if(SlaveInterface.pStateTrans != NULL)
{
SlaveInterface.pStateTrans(OP_2_SAFEOP);
}
/* ECATCHANGE_END(V5.10) ECAT9*/
return ALSTATUSCODE_NOERROR;
}
/////////////////////////////////////////////////////////////////////////////////////////
/**
\return 0(ALSTATUSCODE_NOERROR), NOERROR_INWORK
\param pInputSize pointer to save the input process data length
\param pOutputSize pointer to save the output process data length
\brief This function calculates the process data sizes from the actual SM-PDO-Assign
and PDO mapping
*////////////////////////////////////////////////////////////////////////////////////////
UINT16 APPL_GenerateMapping(UINT16 *pInputSize,UINT16 *pOutputSize)
{
return ALSTATUSCODE_NOERROR;
}
/////////////////////////////////////////////////////////////////////////////////////////
/**
\param pData pointer to input process data
\brief This function will copies the inputs from the local memory to the ESC memory
to the hardware
*////////////////////////////////////////////////////////////////////////////////////////
#if _PIC18 && AL_EVENT_ENABLED
/* the pragma interrupt_level is used to tell the compiler that these functions will not
be called at the same time from the main function and the interrupt routine */
#pragma interrupt_level 1
#endif
void APPL_InputMapping(UINT16* pData)
{
/* ECATCHANGE_START(V5.10) ECAT9*/
if(pData != NULL && SlaveInterface.pInput != NULL && nInputSize > 0)
{
MEMCPY(pData,SlaveInterface.pInput,nInputSize);
}
/* ECATCHANGE_END(V5.10) ECAT9*/
}
/////////////////////////////////////////////////////////////////////////////////////////
/**
\param pData pointer to output process data
\brief This function will copies the outputs from the ESC memory to the local memory
to the hardware
*////////////////////////////////////////////////////////////////////////////////////////
#if _PIC18 && AL_EVENT_ENABLED
/* the pragma interrupt_level is used to tell the compiler that these functions will not
be called at the same time from the main function and the interrupt routine */
#pragma interrupt_level 1
#endif
void APPL_OutputMapping(UINT16* pData)
{
/* ECATCHANGE_END(V5.10) ECAT9*/
if(pData != NULL && SlaveInterface.pOutput != NULL && nOutputSize > 0)
{
MEMCPY(SlaveInterface.pOutput,pData,nOutputSize);
}
/* ECATCHANGE_END(V5.10) ECAT9*/
}
/////////////////////////////////////////////////////////////////////////////////////////
/**
\brief This function will called from the synchronisation ISR
or from the mainloop if no synchronisation is supported
*////////////////////////////////////////////////////////////////////////////////////////
void APPL_Application(void)
{
/* ECATCHANGE_START(V5.10) ECAT9*/
if (SlaveInterface.pApplication != NULL)
{
SlaveInterface.pApplication();
}
/* ECATCHANGE_END(V5.10) ECAT9*/
}
/* ECATCHANGE_START(V5.10) ECAT9*/
/////////////////////////////////////////////////////////////////////////////////////////
/**
\param index index of the requested object.
\param subindex subindex of the requested object.
\param objSize size of the requested object data, calculated with OBJ_GetObjectLength
\param pData Pointer to the buffer where the data can be copied to
\param bCompleteAccess Indicates if a complete read of all subindices of the
object shall be done or not
\return result of the read operation (0 (success) or an abort code (ABORTIDX_.... defined in
sdosrv.h))
\brief This function reads the process data object
*////////////////////////////////////////////////////////////////////////////////////////
UINT8 ReadProcessDataObject( UINT16 index, UINT8 subindex, UINT32 dataSize, UINT16 MBXMEM * pData, UINT8 bCompleteAccess )
{
if(index == 0x7010 || index == 0x6000)
{
if(subindex > 0)
{
return ABORTIDX_SUBINDEX_NOT_EXISTING;
}
if(index == 0x7010)
{
if(dataSize > nPdOutputSize)
{
return ABORTIDX_PARAM_LENGTH_TOO_LONG;
}
else
MEMCPY(pData,SlaveInterface.pOutput,dataSize);
}
else
{
if(dataSize > nPdInputSize)
{
return ABORTIDX_PARAM_LENGTH_TOO_LONG;
}
else
MEMCPY(pData,SlaveInterface.pInput,dataSize);
}
}
else
{
return ABORTIDX_UNSUPPORTED_ACCESS;
}
return 0x00;
}
/////////////////////////////////////////////////////////////////////////////////////////
/**
\param index index of the requested object.
\param subindex subindex of the requested object.
\param dataSize received data size of the SDO Download
\param pData Pointer to the buffer where the written data can be copied from
\param bCompleteAccess Indicates if a complete write of all subindices of the
object shall be done or not
\return result of the write operation (0 (success) or an abort code (ABORTIDX_.... defined in
sdosrv.h))
\brief This function writes the process data object
*////////////////////////////////////////////////////////////////////////////////////////
UINT8 WriteProcessDataObject( UINT16 index, UINT8 subindex, UINT32 dataSize, UINT16 MBXMEM * pData, UINT8 bCompleteAccess )
{
if(index == 0x7010)
{
if(subindex > 0)
{
return ABORTIDX_SUBINDEX_NOT_EXISTING;
}
if(dataSize > nPdOutputSize)
{
return ABORTIDX_PARAM_LENGTH_TOO_LONG;
}
MEMCPY(SlaveInterface.pOutput,pData,dataSize);
}
else
{
return ABORTIDX_UNSUPPORTED_ACCESS;
}
return 0x00;
}
/* ECATCHANGE_END(V5.10) ECAT9*/
#if EXPLICIT_DEVICE_ID
/////////////////////////////////////////////////////////////////////////////////////////
/**
\return The Explicit Device ID of the EtherCAT slave
\brief Calculate the Explicit Device ID
*////////////////////////////////////////////////////////////////////////////////////////
UINT16 APPL_GetDeviceID()
{
return 0xBABA;
}
#endif
/* ECATCHANGE_START(V5.10) ECAT9*/
pECAT_SLAVE_INTERFACE Ecat_Open(unsigned short InputSize, unsigned short OutputSize)
{
UINT16 result = 0;
UINT16 counter = 0;
//Open function shall only called once
if(HardwareOpened != 0)
return &SlaveInterface;
/*Free Input process data memory*/
if(SlaveInterface.pInput != NULL)
{
FREEMEM(SlaveInterface.pInput);
SlaveInterface.pInput = NULL;
}
nPdInputSize = InputSize;
/* Allocate Input process data memory
4kB DPRAM of the ESC ((DPRAM - 2*mailbox) / number of process data directions / SyncManager buffer mode
=> (4kB - 256Byte) / 2 /3 => 640 Byte*/
if(nPdInputSize > 0 && nPdInputSize <= 640)
{
SlaveInterface.pInput = (unsigned long *) ALLOCMEM(nPdInputSize);
}
/*Allocation was not success full or no input process data defined*/
if(SlaveInterface.pInput == NULL)
{
if(nPdInputSize > 0)
{
/*Allocation failed*/
return NULL;
}
sTxPDOassign.u16SubIndex0 = 0;
TxPDOMap.u16SubIndex0 = 0;
for(counter = 0; counter < PDO_MAPPING_ENTIRES; counter++)
TxPDOMap.aEntries[counter] = 0x00000000;
#if COE_SUPPORTED
EntryDesc0x6000.BitLength = 0;
#endif
}
else
{
UINT16 tmpPdCnt = nPdInputSize;
UINT32 EntryValue = 0x60000000;
counter = 0;
HMEMSET(SlaveInterface.pInput,0x00,nPdInputSize);
sTxPDOassign.u16SubIndex0 = 1;
if(tmpPdCnt <= 31)
{
/* up to 31Byte fits into one Pdo mapping entry*/
TxPDOMap.aEntries[0] = (EntryValue | (tmpPdCnt*8));
TxPDOMap.u16SubIndex0 = 1;
}
else
{
/*The process data reference doesn't fit into one entry*/
while(tmpPdCnt > 0)
{
/*all following entries have no index and subindex reference*/
if(counter > 0)
EntryValue = 0x00000000;
if(tmpPdCnt >= 30)
{
TxPDOMap.aEntries[counter] = EntryValue | 240;
tmpPdCnt -= 30;
}
else
{
/*last reference*/
TxPDOMap.aEntries[counter] = EntryValue | (tmpPdCnt * 8);
tmpPdCnt = 0;
}
counter++;
}
TxPDOMap.u16SubIndex0 = counter;
}
#if COE_SUPPORTED
EntryDesc0x6000.BitLength = (nPdInputSize *8);
#endif
}
/*Free Output process data memory*/
if(SlaveInterface.pOutput!= NULL)
{
FREEMEM(SlaveInterface.pOutput);
SlaveInterface.pOutput = NULL;
}
nPdOutputSize = OutputSize;
/* Allocate Output process data memory
4kB DPRAM of the ESC ((DPRAM - 2*mailbox) / number of process data directions / SyncManager buffer mode
=> (4kB - 256Byte) / 2 /3 => 640 Byte*/
if(nPdOutputSize > 0 && nPdOutputSize <= 640)
{
SlaveInterface.pOutput = (unsigned long *) ALLOCMEM(nPdOutputSize);
}
/*Allocation was not success full or no input process data defined*/
if(SlaveInterface.pOutput == NULL)
{
if(nPdOutputSize > 0)
{
/*Allocation failed*/
return NULL;
}
sRxPDOassign.u16SubIndex0 = 0;
RxPDOMap.u16SubIndex0 = 0;
for(counter = 0; counter < PDO_MAPPING_ENTIRES; counter++)
RxPDOMap.aEntries[counter] = 0x00000000;
#if COE_SUPPORTED
EntryDesc0x7010.BitLength = 0;
#endif
}
else
{
UINT16 tmpPdCnt = nPdOutputSize;
UINT32 EntryValue = 0x70100000;
counter = 0;
HMEMSET(SlaveInterface.pOutput,0x00,nPdOutputSize);
sRxPDOassign.u16SubIndex0 = 1;
if(tmpPdCnt <= 31)
{
/* up to 31Byte fits into one Pdo mapping entry*/
RxPDOMap.aEntries[0] = (EntryValue | (tmpPdCnt*8));
RxPDOMap.u16SubIndex0 = 1;
}
else
{
/*The process data reference doesn't fit into one entry*/
while(tmpPdCnt > 0)
{
/*all following entries have no index and subindex reference*/
if(counter > 0)
EntryValue = 0x00000000;
if(tmpPdCnt >= 30)
{
RxPDOMap.aEntries[counter] = EntryValue | 240;
tmpPdCnt -= 30;
}
else
{
/*last reference*/
RxPDOMap.aEntries[counter] = EntryValue | (tmpPdCnt * 8);
tmpPdCnt = 0;
}
counter++;
}
RxPDOMap.u16SubIndex0 = counter;
}
#if COE_SUPPORTED
EntryDesc0x7010.BitLength = (nPdOutputSize *8);
#endif
}
SlaveInterface.pApplication = NULL;
SlaveInterface.pStateTrans = NULL;
result = HW_Init();
if(result == 0)
{
MainInit();
HardwareOpened = 1;
}
else
return NULL;
return &SlaveInterface;
}
/* ECATCHANGE_END(V5.10) ECAT9*/
void Ecat_OnTimer(void)
{
if(HardwareOpened == 0)
return;
MainLoop();
}
void Ecat_Close(void)
{
if(HardwareOpened == 0)
return;
HW_Release();
HardwareOpened = 0;
}
#endif //#if SAMPLE_APPLICATION_INTERFACE
/** @} */