EtherCAT基于SOEM建立主站程序

基于SOEM创建主站步骤

参照EtherCAT状态机,可以为如下步骤

• 1 初始化SOEM，将socket绑定到ifname，调用 ecx_init
• 2 枚举并初始化从站，调用ecx_config_init函数
• 3 建立从站pdo与IOMap映射，调用ecx_config_map_group函数
• 4 等待所有从站运行到安全状态（SAFE_OP），调用ec_statecheck函数
• 5 切换到运行状态（OP state），通过发送一个有效过程数据实现

//等待所有从站进入运行状态
         /* wait for all slaves to reach OP state */
         do
         {
   
            ec_send_processdata();
            ec_receive_processdata(EC_TIMEOUTRET);
            ec_statecheck(0, EC_STATE_OPERATIONAL, 50000);
         }
         while (chk-- && (ec_slave[0].state != EC_STATE_OPERATIONAL));

主要函数介绍

ecx_init函数

功能：初始化SOEM，将socket绑定到ifname
ecx_init函数定义在ethercatmain.h文件，其有两种参数形式，由于大部分函数都是这两种格式，所以后文将不做区分处理。

int ec_init(const char * ifname);
int ecx_init(ecx_contextt *context, const char * ifname);

函数方法在ethercatmain.c中定义如下

/** Initialise lib in single NIC mode
 * @param[in]  context = context struct
 * @param[in] ifname   = Dev name, f.e. "eth0"
 * @return >0 if OK
 */
int ecx_init(ecx_contextt *context, const char * ifname)
{
   
   return ecx_setupnic(context->port, ifname, FALSE);
}

ecx_setupnic函数调用的oshw/linux/nicdrv.h文件,实现方法太长，本文不介绍。

/** Basic setup to connect NIC to socket.
 * @param[in] port        = port context struct
 * @param[in] ifname      = Name of NIC device, f.e. "eth0"
 * @param[in] secondary   = if >0 then use secondary stack instead of primary
 * @return >0 if succeeded
 */
int ecx_setupnic(ecx_portt *port, const char *ifname, int secondary)
{
   ...}

ecx_config_init函数

功能：枚举并初始化从站，返回发现从站的个数
定义在ethercatconfig.h文件，实现方法如下

/** Enumerate and init all slaves.
 *
 * @param[in] context      = context struct
 * @param[in] usetable     = TRUE when using configtable to init slaves, FALSE otherwise
 * @return Workcounter of slave discover datagram = number of slaves found
 */
int ecx_config_init(ecx_contextt *context, uint8 usetable)
{
   ...}

ecx_config_map_group函数

功能：将所有从站pdo映射到IOmap
定义在ethercatconfig.h文件，实现方法如下

/** Map all PDOs in one group of slaves to IOmap with Outputs/Inputs
* in sequential order (legacy SOEM way).
*
 *
 * @param[in]  context    = context struct
 * @param[out] pIOmap     = pointer to IOmap
 * @param[in]  group      = group to map, 0 = all groups
 * @return IOmap size
 */
int ecx_config_map_group(ecx_contextt *context, void *pIOmap, uint8 group)
{
   ...}

ecx_SDOwrite函数

功能：写入SDO数据
定义在ethercatcoe.h文件，实现方法如下

/** CoE SDO write, blocking. Single subindex or Complete Access.
 *
 * A "normal" download request is issued, unless we have
 * small data, then a "expedited" transfer is used. If the parameter is larger than
 * the mailbox size then the download is segmented. The function will split the
 * parameter data in segments and send them to the slave one by one.
 *
 * @param[in]  context    = context struct
 * @param[in]  Slave      = Slave number
 * @param[in]  Index      = Index to write
 * @param[in]  SubIndex   = Subindex to write, must be 0 or 1 if CA is used.
 * @param[in]  CA         = FALSE = single subindex. TRUE = Complete Access, all subindexes written.
 * @param[in]  psize      = Size in bytes of parameter buffer.
 * @param[out] p          = Pointer to parameter buffer
 * @param[in]  Timeout    = Timeout in us, standard is EC_TIMEOUTRXM
 * @return Workcounter from last slave response
 */
int ecx_SDOwrite(ecx_contextt *context, uint16 Slave, uint16 Index, uint8 SubIndex,
                boolean CA, int psize, void *p, int Timeout)
{
   ...}

ecx_SDOread函数

功能：读取SDO数据
定义在ethercatcoe.h文件，实现方法如下

/** CoE SDO read, blocking. Single subindex or Complete Access.
 *
 * Only a "normal" upload request is issued. If the requested parameter is <= 4bytes
 * then a "expedited" response is returned, otherwise a "normal" response. If a "normal"
 * response is larger than the mailbox size then the response is segmented. The function
 * will combine all segments and copy them to the parameter buffer.
 *
 * @param[in]  context    = context struct
 * @param[in]  slave      = Slave number
 * @param[in]  index      = Index to read
 * @param[in]  subindex   = Subindex to read, must be 0 or 1 if CA is used.
 * @param[in]  CA         = FALSE = single subindex. TRUE = Complete Access, all subindexes read.
 * @param[in,out] psize   = Size in bytes of parameter buffer, returns bytes read from SDO.
 * @param[out] p          = Pointer to parameter buffer
 * @param[in]  timeout    = Timeout in us, standard is EC_TIMEOUTRXM
 * @return Workcounter from last slave response
 */
int ecx_SDOread(ecx_contextt *context, uint16 slave, uint16 index