EtherCAT主站SOEM -- 3 -- SOEM之ethercatconfig.h/c文件解析

一 ethercatconfig.h/c文件功能预览：
二 ethercatconfig.h/c 中主要函数的作用：
- 2.1.1 `ec_config_init(uint8 usetable)` 和 `ecx_config_init(ecx_contextt *context, uint8 usetable)`：
- 2.1.2 `ec_config_map(void *pIOmap)`：
- 2.1.3 `ec_config_overlap_map(void *pIOmap)` 和 `ecx_config_overlap_map_group(ecx_contextt *context, void *pIOmap, uint8 group)`：
- 2.1.4 `ec_config(uint8 usetable, void *pIOmap)` 和 `ecx_config_init(ecx_contextt *context, uint8 usetable)`：
- 2.1.5 `ec_recover_slave(uint16 slave, int timeout)` 和 `ecx_recover_slave(ecx_contextt *context, uint16 slave, int timeout)`：
- 2.1.6 `ec_reconfig_slave(uint16 slave, int timeout)` 和 `ecx_reconfig_slave(ecx_contextt *context, uint16 slave, int timeout)`：
三 ethercatconfig.c 原文件的中文注释
该文档修改记录：
总结

一 ethercatconfig.h/c文件功能预览：

函数	功能和用途	使用场景
`ec_config_init` (仅适用于`EC_VER1`)	初始化EtherCAT主站配置，用于主站初始化。	应用程序启动时进行EtherCAT主站的初始化。
`ecx_config_init`	初始化EtherCAT主站配置，用于主站初始化。	应用程序启动时进行EtherCAT主站的初始化。
`ec_config_map_group` (仅适用于`EC_VER1`)	映射EtherCAT从站数据到主站，配置数据映射到指定组。	初始化后，配置数据映射到指定的数据组。
`ecx_config_map_group`	映射EtherCAT从站数据到主站，配置数据映射到指定组。	初始化后，配置数据映射到指定的数据组。
`ec_config_overlap_map_group` (仅适用于`EC_VER1`)	映射EtherCAT从站数据到主站，处理重叠数据映射。	处理重叠数据映射配置时，将多个数据组映射到主站。
`ecx_config_overlap_map_group`	映射EtherCAT从站数据到主站，处理重叠数据映射。	处理重叠数据映射配置时，将多个数据组映射到主站。
`ec_recover_slave` (仅适用于`EC_VER1`)	尝试从站的恢复，用于从站恢复。	当从站失去连接或通信出现问题时，尝试从站的恢复。
`ecx_recover_slave`	尝试从站的恢复，用于从站恢复。	当从站失去连接或通信出现问题时，尝试从站的恢复。
`ec_reconfig_slave` (仅适用于`EC_VER1`)	重新配置从站，用于运行时更改从站配置。	应用程序需要在运行时更改从站配置时使用。
`ecx_reconfig_slave`	重新配置从站，用于运行时更改从站配置。	应用程序需要在运行时更改从站配置时使用。

二 ethercatconfig.h/c 中主要函数的作用：

ethercatconfig.h 文件通常包含了用户或开发者定义的配置参数和宏定义，用于指定 EtherCAT 网络的特性，如周期时间、数据对象的大小、网络拓扑结构等。开发者可以根据其应用程序的需求，在这个文件中进行定制。以下是一些可能包含在 ethercatconfig.h 文件中的配置选项：

通信周期：定义 EtherCAT 网络的通信周期，这对于实时性能至关重要。
从站数量：指定在网络中的 EtherCAT 从站数量。
从站配置：每个从站的配置参数，包括地址、数据对象大小等。
网络拓扑：定义网络中不同从站的连接方式和物理拓扑。
数据对象定义：定义 EtherCAT 数据对象（PDO）的结构和映射。

ethercatconfig.c 文件通常包含 SOEM 库的初始化代码，它使用 ethercatconfig.h 中的配置参数来初始化 EtherCAT 主站并设置网络。这个文件负责执行以下操作：

初始化 EtherCAT 主站：配置主站并初始化必要的数据结构。
从站配置：为每个从站设置相应的参数，以确保网络中的从站能够正常工作。
网络初始化：设置 EtherCAT 网络的物理连接、通信周期等参数。
启动 EtherCAT 通信：启动 EtherCAT 通信，使网络中的从站可以开始交换数据。

总之，ethercatconfig.h 和 ethercatconfig.c 文件是 SOEM 库中用于配置和初始化 EtherCAT 网络的关键文件。

2.1.1 `ec_config_init(uint8 usetable)` 和 `ecx_config_init(ecx_contextt *context, uint8 usetable)`：

这些函数用于初始化EtherCAT主站的配置。
参数 usetable 是一个标志，用于指示是否使用表格（table）来配置主站。如果设置为1，表示使用表格；如果设置为0，表示手动配置。
在初始化过程中，这些函数通常会设置网络接口、配置Slave设备的数量、数据映射表等。如果使用表格，则初始化会包括加载表格信息。

2.1.2 `ec_config_map(void *pIOmap)`：

此函数用于将Slave设备的输入和输出数据映射到主站的过程数据区域。
参数 pIOmap 是指向数据映射的指针，它包含了关于Slave设备数据映射的信息。
主站需要知道如何读取和写入每个Slave设备的数据，这是通过数据映射来实现的。这个函数负责确保正确的数据映射。

2.1.3 `ec_config_overlap_map(void pIOmap)` 和 `ecx_config_overlap_map_group(ecx_contextt context, void *pIOmap, uint8 group)`：

这些函数用于处理数据映射中的重叠问题，以确保数据传输不会发生冲突。
参数 pIOmap 是指向数据映射的指针。
参数 group 可用于指定数据映射到特定的数据组。在某些情况下，数据映射可能会重叠，这可能导致数据混淆。这些函数处理这些重叠，以确保数据正常传输。

2.1.4 `ec_config(uint8 usetable, void pIOmap)` 和 `ecx_config_init(ecx_contextt context, uint8 usetable)`：

这些函数将配置的初始化和数据映射组合在一起，以便主站的整体配置。
参数 usetable 指示是否使用表格（table）来配置主站。
参数 pIOmap 是指向数据映射的指针。
这些函数在主站应用程序中通常用于一次性配置整个EtherCAT主站，包括初始化和数据映射。

2.1.5 `ec_recover_slave(uint16 slave, int timeout)` 和 `ecx_recover_slave(ecx_contextt *context, uint16 slave, int timeout)`：

这些函数用于尝试从错误状态中恢复指定的Slave设备。
参数 slave 指定要恢复的Slave设备。
参数 timeout 指定恢复操作的超时时间。如果Slave设备发生错误状态，这些函数可以尝试将其恢复到正常状态。

2.1.6 `ec_reconfig_slave(uint16 slave, int timeout)` 和 `ecx_reconfig_slave(ecx_contextt *context, uint16 slave, int timeout)`：

这些函数用于重新配置指定的Slave设备，通常在网络配置发生更改时使用。
参数 slave 指定要重新配置的Slave设备。
参数 timeout 指定重新配置操作的超时时间。当需要更改Slave设备的配置时，这些函数可用于重新配置它们，确保网络正常运行。

三 ethercatconfig.c 原文件的中文注释

/*
 * 根据带有异常的GNU通用公共许可证第2版许可。详细的许可信息请参见项目根目录中的LICENSE文件
 */

/** \file
 * \brief
 * 用于EtherCAT主站的配置模块。
 *
 * 在成功使用ec_init()或ec_init_redundant()进行初始化后，可以使用此模块自动配置从站。
 */

#include 
#include 
#include "osal.h"
#include "oshw.h"
#include "ethercattype.h"
#include "ethercatbase.h"
#include "ethercatmain.h"
#include "ethercatcoe.h"
#include "ethercatsoe.h"
#include "ethercatconfig.h"

typedef struct
{
   int thread_n;
   int running;
   ecx_contextt *context;
   uint16 slave;
} ecx_mapt_t;

ecx_mapt_t ecx_mapt[EC_MAX_MAPT];
#if EC_MAX_MAPT > 1
OSAL_THREAD_HANDLE ecx_threadh[EC_MAX_MAPT];
#endif

#ifdef EC_VER1
/** 从站配置结构 */
typedef const struct
{
   /** 从站制造商代码 */
   uint32           man;
   /** 从站ID */
   uint32           id;
   /** 可读的名称 */
   char             name[EC_MAXNAME + 1];
   /** 数据类型 */
   uint8            Dtype;
   /** 输入位数 */
   uint16            Ibits;
   /** 输出位数 */
   uint16           Obits;
   /** SyncManager 2地址 */
   uint16           SM2a;
   /** SyncManager 2标志 */
   uint32           SM2f;
   /** SyncManager 3地址 */
   uint16           SM3a;
   /** SyncManager 3标志 */
   uint32           SM3f;
   /** FMMU 0激活 */
   uint8            FM0ac;
   /** FMMU 1激活 */
   uint8            FM1ac;
} ec_configlist_t;

#include "ethercatconfiglist.h"
#endif

/** 用于邮箱从站的标准SM0标志配置 */
#define EC_DEFAULTMBXSM0  0x00010026
/** 用于邮箱从站的标准SM1标志配置 */
#define EC_DEFAULTMBXSM1  0x00010022
/** 用于数字输出从站的标准SM0标志配置 */
#define EC_DEFAULTDOSM0   0x00010044

#ifdef EC_VER1
/** 在标准配置列表ec_configlist[]中查找从站
 *
 * @param[in] man      = 制造商
 * @param[in] id       = ID
 * @return 在ec_configlist[]中找到时的索引，否则返回0
 */
int ec_findconfig( uint32 man, uint32 id)
{
   int i = 0;

   do
   {
      i++;
   } while ( (ec_configlist[i].man != EC_CONFIGEND) &&
           ((ec_configlist[i].man != man) || (ec_configlist[i].id != id)) );
   if (ec_configlist[i].man == EC_CONFIGEND)
   {
      i = 0;
   }
   return i;
}
#endif

void ecx_init_context(ecx_contextt *context)
{
   int lp;
   *(context->slavecount) = 0;
   /* 清除ec_slave数组 */
   memset(context->slavelist, 0x00, sizeof(ec_slavet) * context->maxslave);
   memset(context->grouplist, 0x00, sizeof(ec_groupt) * context->maxgroup);
   /* 清除从站EEPROM缓存，实际上不会读取任何EEPROM */
   ecx_siigetbyte(context, 0, EC_MAXEEPBUF);
   for(lp = 0; lp < context->maxgroup; lp++)
   {
      /* 每个组条目的默认起始地址 */
      context->grouplist[lp].logstartaddr = lp << EC_LOGGROUPOFFSET;
   }
}

int ecx_detect_slaves(ecx_contextt *context)
{
   uint8  b;
   uint16 w;
   int    wkc;

   /* 进行特殊的预初始化寄存器写操作，以启用老netX100从站的MAC[1]本地管理位设置 */
   b = 0x00;
   ecx_BWR(context->port, 0x0000, ECT_REG_DLALIAS, sizeof(b), &b, EC_TIMEOUTRET3);     /* 忽略Alias寄存器 */
   b = EC_STATE_INIT | EC_STATE_ACK;
   ecx_BWR(context->port, 0x0000, ECT_REG_ALCTL, sizeof(b), &b, EC_TIMEOUTRET3);       /* 将所有从站重置为Init状态 */
   /* 现在netX100应该正常工作 */
   ecx_BWR(context->port, 0x0000, ECT_REG_ALCTL, sizeof(b), &b, EC_TIMEOUTRET3);       /* 将所有从站重置为Init状态 */
   wkc = ecx_BRD(context->port, 0x0000, ECT_REG_TYPE, sizeof(w), &w, EC_TIMEOUTSAFE);  /* 检测从站数量 */
   if (wkc > 0)
   {
      /* 这是严格的“小于”关系，因为主站是“从站0” */
      if (wkc < EC_MAXSLAVE)
      {
         *(context->slavecount) = wkc;
      }
      else
      {
         EC_PRINT("错误：网络上从站太多：num_slaves=%d，EC_MAXSLAVE=%d\n",
               wkc, EC_MAXSLAVE);
         return EC_SLAVECOUNTEXCEEDED;
      }
   }
   return wkc;
}


static void ecx_set_slaves_to_default(ecx_contextt *context)
{
   uint8 b;
   uint16 w;
   uint8 zbuf[64];
   memset(&zbuf, 0x00, sizeof(zbuf));
   b = 0x00;
   ecx_BWR(context->port, 0x0000, ECT_REG_DLPORT      , sizeof(b) , &b, EC_TIMEOUTRET3);     /* 停用循环手动 */
   w = htoes(0x0004);
   ecx_BWR(context->port, 0x0000, ECT_REG_IRQMASK     , sizeof(w) , &w, EC_TIMEOUTRET3);     /* 设置中断掩码 */
   ecx_BWR(context->port, 0x0000, ECT_REG_RXERR       , 8         , &zbuf, EC_TIMEOUTRET3);  /* 重置CRC计数器 */
   ecx_BWR(context->port, 0x0000, ECT_REG_FMMU0       , 16 * 3    , &zbuf, EC_TIMEOUTRET3);  /* 重置FMMU */
   ecx_BWR(context->port, 0x0000, ECT_REG_SM0         , 8 * 4     , &zbuf, EC_TIMEOUTRET3);  /* 重置SyncM */
   b = 0x00;
   ecx_BWR(context->port, 0x0000, ECT_REG_DCSYNCACT   , sizeof(b) , &b, EC_TIMEOUTRET3);     /* 重置激活寄存器 */
   ecx_BWR(context->port, 0x0000, ECT_REG_DCSYSTIME   , 4         , &zbuf, EC_TIMEOUTRET3);  /* 重置系统时间+偏移 */
   w = htoes(0x1000);
   ecx_BWR(context->port, 0x0000, ECT_REG_DCSPEEDCNT  , sizeof(w) , &w, EC_TIMEOUTRET3);     /* DC速度启动 */
   w = htoes(0x0c00);
   ecx_BWR(context->port, 0x0000, ECT_REG_DCTIMEFILT  , sizeof(w) , &w, EC_TIMEOUTRET3);     /* DC滤波表达式 */
   b = 0x00;
   ecx_BWR(context->port, 0x0000, ECT_REG_DLALIAS     , sizeof(b) , &b, EC_TIMEOUTRET3);     /* 忽略Alias寄存器 */
   b = EC_STATE_INIT | EC_STATE_ACK;
   ecx_BWR(context->port, 0x0000, ECT_REG_ALCTL       , sizeof(b) , &b, EC_TIMEOUTRET3);     /* 将所有从站重置为Init */
   b = 2;
   ecx_BWR(context->port, 0x0000, ECT_REG_EEPCFG      , sizeof(b) , &b, EC_TIMEOUTRET3);     /* 强制从PDI读取EEPROM */
   b = 0;
   ecx_BWR(context->port, 0x0000, ECT_REG_EEPCFG      , sizeof(b) , &b, EC_TIMEOUTRET3);     /* 将EEPROM设置为主站 */
}


#ifdef EC_VER1
static int ecx_config_from_table(ecx_contextt *context, uint16 slave)
{
   int cindex;
   ec_slavet *csl;

   csl = &(context->slavelist[slave]);
   cindex = ec_findconfig( csl->eep_man, csl->eep_id );
   csl->configindex= cindex;
   /* slave found in configuration table ? */
   if (cindex)
   {
      csl->Dtype = ec_configlist[cindex].Dtype;
      strcpy(csl->name ,ec_configlist[cindex].name);
      csl->Ibits = ec_configlist[cindex].Ibits;
      csl->Obits = ec_configlist[cindex].Obits;
      if (csl->Obits)
      {
         csl->FMMU0func = 1;
      }
      if (csl->Ibits)
      {
         csl->FMMU1func = 2;
      }
      csl->FMMU[0].FMMUactive = ec_configlist[cindex].FM0ac;
      csl->FMMU[1].FMMUactive = ec_configlist[cindex].FM1ac;
      csl->SM[2].StartAddr = htoes(ec_configlist[cindex].SM2a);
      csl->SM[2].SMflags = htoel(ec_configlist[cindex].SM2f);
      /* simple (no mailbox) output slave found ? */
      if (csl->Obits && !csl->SM[2].StartAddr)
      {
         csl->SM[0].StartAddr = htoes(0x0f00);
         csl->SM[0].SMlength = htoes((csl->Obits + 7) / 8);
         csl->SM[0].SMflags = htoel(EC_DEFAULTDOSM0);
         csl->FMMU[0].FMMUactive = 1;
         csl->FMMU[0].FMMUtype = 2;
         csl->SMtype[0] = 3;
      }
      /* complex output slave */
      else
      {
         csl->SM[2].SMlength = htoes((csl->Obits + 7) / 8);
         csl->SMtype[2] = 3;
      }
      csl->SM[3].StartAddr = htoes(ec_configlist[cindex].SM3a);
      csl->SM[3].SMflags = htoel(ec_configlist[cindex].SM3f);
      /* simple (no mailbox) input slave found ? */
      if (csl->Ibits && !csl->SM[3].StartAddr)
      {
         csl->SM[1].StartAddr = htoes(0x1000);
         csl->SM[1].SMlength = htoes((csl->Ibits + 7) / 8);
         csl->SM[1].SMflags = htoel(0x00000000);
         csl->FMMU[1].FMMUactive = 1;
         csl->FMMU[1].FMMUtype = 1;
         csl->SMtype[1] = 4;
      }
      /* complex input slave */
      else
      {
         csl->SM[3].SMlength = htoes((csl->Ibits + 7) / 8);
         csl->SMtype[3] = 4;
      }
   }
   return cindex;
}
#else
static int ecx_config_from_table(ecx_contextt *context, uint16 slave)
{
   (void)context;
   (void)slave;
   return 0;
}
#endif

/* If slave has SII and same slave ID done before, use previous data.
 * This is safe because SII is constant for same slave ID.
 */
static int ecx_lookup_prev_sii(ecx_contextt *context, uint16 slave)
{
   int i, nSM;
   if ((slave > 1) && (*(context->slavecount) > 0))
   {
      i = 1;
      while(((context->slavelist[i].eep_man != context->slavelist[slave].eep_man) ||
             (context->slavelist[i].eep_id  != context->slavelist[slave].eep_id ) ||
             (context->slavelist[i].eep_rev != context->slavelist[slave].eep_rev)) &&
            (i < slave))
      {
         i++;
      }
      if(i < slave)
      {
         context->slavelist[slave].CoEdetails = context->slavelist[i].CoEdetails;
         context->slavelist[slave].FoEdetails = context->slavelist[i].FoEdetails;
         context->slavelist[slave].EoEdetails = context->slavelist[i].EoEdetails;
         context->slavelist[slave].SoEdetails = context->slavelist[i].SoEdetails;
         if(context->slavelist[i].blockLRW > 0)
         {
            context->slavelist[slave].blockLRW = 1;
            context->slavelist[0].blockLRW++;
         }
         context->slavelist[slave].Ebuscurrent = context->slavelist[i].Ebuscurrent;
         context->slavelist[0].Ebuscurrent += context->slavelist[slave].Ebuscurrent;
         memcpy(context->slavelist[slave].name, context->slavelist[i].name, EC_MAXNAME + 1);
         for( nSM=0 ; nSM < EC_MAXSM ; nSM++ )
         {
            context->slavelist[slave].SM[nSM].StartAddr = context->slavelist[i].SM[nSM].StartAddr;
            context->slavelist[slave].SM[nSM].SMlength  = context->slavelist[i].SM[nSM].SMlength;
            context->slavelist[slave].SM[nSM].SMflags   = context->slavelist[i].SM[nSM].SMflags;
         }
         context->slavelist[slave].FMMU0func = context->slavelist[i].FMMU0func;
         context->slavelist[slave].FMMU1func = context->slavelist[i].FMMU1func;
         context->slavelist[slave].FMMU2func = context->slavelist[i].FMMU2func;
         context->slavelist[slave].FMMU3func = context->slavelist[i].FMMU3func;
         EC_PRINT("Copy SII slave %d from %d.\n", slave, i);
         return 1;
      }
   }
   return 0;
}

/** 枚举和初始化所有从站。
 *
 * @param[in] context      = 上下文结构
 * @param[in] usetable     = 使用配置表来初始化从站时为TRUE，否则为FALSE
 * @return 从站发现数据报的工作计数 = 找到的从站数量
 */
int ecx_config_init(ecx_contextt *context, uint8 usetable)
{
   uint16 slave, ADPh, configadr, ssigen;
   uint16 topology, estat;
   int16 topoc, slavec, aliasadr;
   uint8 b, h;
   uint8 SMc;
   uint32 eedat;
   int wkc, cindex, nSM;
   uint16 val16;

   EC_PRINT("ec_config_init %d\n", usetable);
   ecx_init_context(context);
   wkc = ecx_detect_slaves(context);
   if (wkc > 0)
   {
      ecx_set_slaves_to_default(context);
      for (slave = 1; slave <= *(context->slavecount); slave++)
      {
         ADPh = (uint16)(1 - slave);
         val16 = ecx_APRDw(context->port, ADPh, ECT_REG_PDICTL, EC_TIMEOUTRET3); /* 读取从站的接口类型 */
         context->slavelist[slave].Itype = etohs(val16);
         /* 为了提高网络帧的可读性，使用节点偏移 */
         /* 这不会影响可寻址从站的数量（自动循环） */
         ecx_APWRw(context->port, ADPh, ECT_REG_STADR, htoes(slave + EC_NODEOFFSET), EC_TIMEOUTRET3); /* 设置从站的节点地址 */
         if (slave == 1)
         {
            b = 1; /* 对于第一个从站，禁用非EtherCAT帧 */
         }
         else
         {
            b = 0; /* 对于后续从站，允许所有帧通过 */
         }
         ecx_APWRw(context->port, ADPh, ECT_REG_DLCTL, htoes(b), EC_TIMEOUTRET3); /* 设置非EtherCAT帧的行为 */
         configadr = ecx_APRDw(context->port, ADPh, ECT_REG_STADR, EC_TIMEOUTRET3);
         configadr = etohs(configadr);
         context->slavelist[slave].configadr = configadr;
         ecx_FPRD(context->port, configadr, ECT_REG_ALIAS, sizeof(aliasadr), &aliasadr, EC_TIMEOUTRET3);
         context->slavelist[slave].aliasadr = etohs(aliasadr);
         ecx_FPRD(context->port, configadr, ECT_REG_EEPSTAT, sizeof(estat), &estat, EC_TIMEOUTRET3);
         estat = etohs(estat);
         if (estat & EC_ESTAT_R64) /* 检查从站是否支持读取8字节数据块 */
         {
            context->slavelist[slave].eep_8byte = 1;
         }
         ecx_readeeprom1(context, slave, ECT_SII_MANUF); /* Manuf */
      }
      for (slave = 1; slave <= *(context->slavecount); slave++)
      {
         eedat = ecx_readeeprom2(context, slave, EC_TIMEOUTEEP); /* Manuf */
         context->slavelist[slave].eep_man = etohl(eedat);
         ecx_readeeprom1(context, slave, ECT_SII_ID); /* ID */
      }
      for (slave = 1; slave <= *(context->slavecount); slave++)
      {
         eedat = ecx_readeeprom2(context, slave, EC_TIMEOUTEEP); /* ID */
         context->slavelist[slave].eep_id = etohl(eedat);
         ecx_readeeprom1(context, slave, ECT_SII_REV); /* revision */
      }
      for (slave = 1; slave <= *(context->slavecount); slave++)
      {
         eedat = ecx_readeeprom2(context, slave, EC_TIMEOUTEEP); /* revision */
         context->slavelist[slave].eep_rev = etohl(eedat);
         ecx_readeeprom1(context, slave, ECT_SII_RXMBXADR); /* write mailbox address + mailboxsize */
      }
      for (slave = 1; slave <= *(context->slavecount); slave++)
      {
         eedat = ecx_readeeprom2(context, slave, EC_TIMEOUTEEP); /* write mailbox address and mailboxsize */
         context->slavelist[slave].mbx_wo = (uint16)LO_WORD(etohl(eedat));
         context->slavelist[slave].mbx_l = (uint16)HI_WORD(etohl(eedat));
         if (context->slavelist[slave].mbx_l > 0)
         {
            ecx_readeeprom1(context, slave, ECT_SII_TXMBXADR); /* read mailbox offset */
         }
      }
      for (slave = 1; slave <= *(context->slavecount); slave++)
      {
         if (context->slavelist[slave].mbx_l > 0)
         {
            eedat = ecx_readeeprom2(context, slave, EC_TIMEOUTEEP); /* read mailbox offset */
            context->slavelist[slave].mbx_ro = (uint16)LO_WORD(etohl(eedat)); /* read mailbox offset */
            context->slavelist[slave].mbx_rl = (uint16)HI_WORD(etohl(eedat)); /* read mailbox length */
            if (context->slavelist[slave].mbx_rl == 0)
            {
               context->slavelist[slave].mbx_rl = context->slavelist[slave].mbx_l;
            }
            ecx_readeeprom1(context, slave, ECT_SII_MBXPROTO);
         }
         configadr = context->slavelist[slave].configadr;
         val16 = ecx_FPRDw(context->port, configadr, ECT_REG_ESCSUP, EC_TIMEOUTRET3);
         if ((etohs(val16) & 0x04) > 0)  /* 支持DC？ */
         {
            context->slavelist[slave].hasdc = TRUE;
         }
         else
         {
            context->slavelist[slave].hasdc = FALSE;
         }
         topology = ecx_FPRDw(context->port, configadr, ECT_REG_DLSTAT, EC_TIMEOUTRET3); /* 从DL状态中提取拓扑信息 */
         topology = etohs(topology);
         h = 0;
         b = 0;
         if ((topology & 0x0300) == 0x0200) /* 端口0打开并已建立通信 */
         {
            h++;
            b |= 0x01;
         }
         if ((topology & 0x0c00) == 0x0800) /* 端口1打开并已建立通信 */
         {
            h++;
            b |= 0x02;
         }
         if ((topology & 0x3000) == 0x2000) /* 端口2打

         {
            h++;
            b |= 0x04;
         }
         if ((topology & 0xc000) == 0x8000) /* 端口3打开并已建立通信 */
         {
            h++;
            b |= 0x08;
         }
         /* ptype = 物理类型 */
         val16 = ecx_FPRDw(context->port, configadr, ECT_REG_PORTDES, EC_TIMEOUTRET3);
         context->slavelist[slave].ptype = LO_BYTE(etohs(val16));
         context->slavelist[slave].topology = h;
         context->slavelist[slave].activeports = b;
         /* 0=没有链接，不可能             */
         /* 1=1个链接，线尾              */
         /* 2=2个链接，前后各一个         */
         /* 3=3个链接，分割点             */
         /* 4=4个链接，交叉点             */
         /* 搜索父节点 */
         context->slavelist[slave].parent = 0; /* 父节点是主站 */
         if (slave > 1)
         {
            topoc = 0;
            slavec = slave - 1;
            do
            {
               topology = context->slavelist[slavec].topology;
               if (topology == 1)
               {
                  topoc--; /* 找到终端 */
               }
               if (topology == 3)
               {
                  topoc++; /* 找到分割点 */
               }
               if (topology == 4)
               {
                  topoc += 2; /* 找到交叉点 */
               }
               if (((topoc >= 0) && (topology > 1)) ||
                   (slavec == 1)) /* 找到父节点 */
               {
                  context->slavelist[slave].parent = slavec;
                  slavec = 1;
               }
               slavec--;
            }
            while (slavec > 0);
         }
         (void)ecx_statecheck(context, slave, EC_STATE_INIT,  EC_TIMEOUTSTATE); /* 检查状态变化Init */

         /* 如果从站具有邮箱，设置默认邮箱配置 */
         if (context->slavelist[slave].mbx_l > 0)
         {
            context->slavelist[slave].SMtype[0] = 1;
            context->slavelist[slave].SMtype[1] = 2;
            context->slavelist[slave].SMtype[2] = 3;
            context->slavelist[slave].SMtype[3] = 4;
            context->slavelist[slave].SM[0].StartAddr = htoes(context->slavelist[slave].mbx_wo);
            context->slavelist[slave].SM[0].SMlength = htoes(context->slavelist[slave].mbx_l);
            context->slavelist[slave].SM[0].SMflags = htoel(EC_DEFAULTMBXSM0);
            context->slavelist[slave].SM[1].StartAddr = htoes(context->slavelist[slave].mbx_ro);
            context->slavelist[slave].SM[1].SMlength = htoes(context->slavelist[slave].mbx_rl);
            context->slavelist[slave].SM[1].SMflags = htoel(EC_DEFAULTMBXSM1);
            eedat = ecx_readeeprom2(context, slave, EC_TIMEOUTEEP);
            context->slavelist[slave].mbx_proto = (uint16)etohl(eedat);
         }
         cindex = 0;
         /* 使用配置表吗？ */
         if (usetable == 1)
         {
            cindex = ecx_config_from_table(context, slave);
         }
         /* 如果从站不在配置表中，则通过SII查找 */
         if (!cindex && !ecx_lookup_prev_sii(context, slave))
         {
            ssigen = ecx_siifind(context, slave, ECT_SII_GENERAL);
            /* SII通用部分 */
            if (ssigen)
            {
               context->slavelist[slave].CoEdetails = ecx_siigetbyte(context, slave, ssigen + 0x07);
               context->slavelist[slave].FoEdetails = ecx_siigetbyte(context, slave, ssigen + 0x08);
               context->slavelist[slave].EoEdetails = ecx_siigetbyte(context, slave, ssigen + 0x09);
               context->slavelist[slave].SoEdetails = ecx_siigetbyte(context, slave, ssigen + 0x0a);
               if ((ecx_siigetbyte(context, slave, ssigen + 0x0d) & 0x02) > 0)
               {
                  context->slavelist[slave].blockLRW = 1;
                  context->slavelist[0].blockLRW++;
               }
               context->slavelist[slave].Ebuscurrent = ecx_siigetbyte(context, slave, ssigen + 0x0e);
               context->slavelist[slave].Ebuscurrent += ecx_siigetbyte(context, slave, ssigen + 0x0f) << 8;
               context->slavelist[0].Ebuscurrent += context->slavelist[slave].Ebuscurrent;
            }
            /* SII字符串部分 */
            if (ecx_siifind(context, slave, ECT_SII_STRING) > 0)
            {
               ecx_siistring(context, context->slavelist[slave].name, slave, 1);
            }
            /* 没有找到从站的名称，使用构造的名称 */
            else
            {
               sprintf(context->slavelist[slave].name, "? M:%8.8x I:%8.8x",
                       (unsigned int)context->slavelist[slave].eep_man,
                       (unsigned int)context->slavelist[slave].eep_id);
            }
            /* SII SM部分 */
            nSM = ecx_siiSM(context, slave, context->eepSM);
            if (nSM > 0)
            {
               context->slavelist[slave].SM[0].StartAddr = htoes(context->eepSM->PhStart);
               context->slavelist[slave].SM[0].SMlength = htoes(context->eepSM->Plength);
               context->slavelist[slave].SM[0].SMflags =
                  htoel((context->eepSM->Creg) + (context->eepSM->Activate << 16));
               SMc = 1;
               while ((SMc < EC_MAXSM) &&  ecx_siiSMnext(context, slave, context->eepSM, SMc))
               {
                  context->slavelist[slave].SM[SMc].StartAddr = htoes(context->eepSM->PhStart);
                  context->slavelist[slave].SM[SMc].SMlength = htoes(context->eepSM->Plength);
                  context->slavelist[slave].SM[SMc].SMflags =
                     htoel((context->eepSM->Creg) + (context->eepSM->Activate << 16));
                  SMc++;
               }
            }
            /* SII FMMU部分 */
            if (ecx_siiFMMU(context, slave, context->eepFMMU))
            {
               if (context->eepFMMU->FMMU0 !=0xff)
               {
                  context->slavelist[slave].FMMU0func = context->eepFMMU->FMMU0;
               }
               if (context->eepFMMU->FMMU1 !=0xff)
               {
                  context->slavelist[slave].FMMU1func = context->eepFMMU->FMMU1;
               }
               if (context->eepFMMU->FMMU2 !=0xff)
               {
                  context->slavelist[slave].FMMU2func = context->eepFMMU->FMMU2;
               }
               if (context->eepFMMU->FMMU3 !=0xff)
               {
                  context->slavelist[slave].FMMU3func = context->eepFMMU->FMMU3;
               }
            }
         }

         if (context->slavelist[slave].mbx_l > 0)
         {
            if (context->slavelist[slave].SM[0].StartAddr == 0x0000) /* 这不应该发生 */
            {
               EC_PRINT("从站 %d 在配置中没有正确的邮箱，尝试默认值。\n", slave);
               context->slavelist[slave].SM[0].StartAddr = htoes(0x1000);
               context->slavelist[slave].SM[0].SMlength = htoes(0x0080);
               context->slavelist[slave].SM[0].SMflags = htoel(EC_DEFAULTMBXSM0);
               context->slavelist[slave].SMtype[0] = 1;
            }
            if (context->slavelist[slave].SM[1].StartAddr == 0x0000) /* 这不应该发生 */
            {
               EC_PRINT("从站 %d 在配置中没有正确的邮箱，尝试默认值。\n", slave);
               context->slavelist[slave].SM[1].StartAddr = htoes(0x1080);
               context->slavelist[slave].SM[1].SMlength = htoes(0x0080);
               context->slavelist[slave].SM[1].SMflags = htoel(EC_DEFAULTMBXSM1);
               context->slavelist[slave].SMtype[1] = 2;
            }
            /* 编程SM0邮箱接收和SM1邮箱发送 */
            /* 在一个数据报中同时写入两个SM可以解决旧NETX中的时序问题 */
            ecx_FPWR(context->port, configadr, ECT_REG_SM0, sizeof(ec_smt) * 2,
               &(context->slavelist[slave].SM[0]), EC_TIMEOUTRET3);
         }
         /* 一些从站需要在init->preop过渡中将eeprom可用于PDI */
         ecx_eeprom2pdi(context, slave);
         /* 用户可以覆盖自动状态更改 */
         if (context->manualstatechange == 0)
         {
            /* 请求从站的pre_op状态 */
            ecx_FPWRw(context->port,
               configadr,
               ECT_REG_ALCTL,
               htoes(EC_STATE_PRE_OP | EC_STATE_ACK),
               EC_TIMEOUTRET3); /* 设置preop状态 */
         }
      }
   }
   return wkc;
}

/* 如果从站具有SII映射并且以前执行相同从站ID，则使用先前的映射。
 * 这是安全的，因为对于相同的从站ID，SII映射是恒定的。
 */
static int ecx_lookup_mapping(ecx_contextt *context, uint16 slave, uint32 *Osize, uint32 *Isize)
{
   int i, nSM;
   if ((slave > 1) && (*(context->slavecount) > 0))
   {
      i = 1;
      while(((context->slavelist[i].eep_man != context->slavelist[slave].eep_man) ||
             (context->slavelist[i].eep_id  != context->slavelist[slave].eep_id ) ||
             (context->slavelist[i].eep_rev != context->slavelist[slave].eep_rev)) &&
            (i < slave))
      {
         i++;
      }
      if(i < slave)
      {
         for( nSM=0 ; nSM < EC_MAXSM ; nSM++ )
         {
            context->slavelist[slave].SM[nSM].SMlength = context->slavelist[i].SM[nSM].SMlength;
            context->slavelist[slave].SMtype[nSM] = context->slavelist[i].SMtype[nSM];
         }
         *Osize = context->slavelist[i].Obits;
         *Isize = context->slavelist[i].Ibits;
         context->slavelist[slave].Obits = (uint16)*Osize;
         context->slavelist[slave].Ibits = (uint16)*Isize;
         EC_PRINT("从站 %d 从 %d 复制映射。\n", slave, i);
         return 1;
      }
   }
   return 0;
}

static int ecx_map_coe_soe(ecx_contextt *context, uint16 slave, int thread_n)
{
   uint32 Isize, Osize;
   int rval;

   ecx_statecheck(context, slave, EC_STATE_PRE_OP, EC_TIMEOUTSTATE); /* 检查状态是否变为Pre-op */

   EC_PRINT(" >从站 %d, 配置地址 %x, 状态 %2.2x\n",
            slave, context->slavelist[slave].configadr, context->slavelist[slave].state);

   /* 执行特殊的从站配置挂接 Pre-Op 到 Safe-OP */
   if(context->slavelist[slave].PO2SOconfig) /* 仅在已注册时执行 */
   {
      context->slavelist[slave].PO2SOconfig(slave);
   }
   if (context->slavelist[slave].PO2SOconfigx) /* 仅在已注册时执行 */
   {
      context->slavelist[slave].PO2SOconfigx(context, slave);
   }
   /* 如果在配置列表中未找到从站，则在从站本身中查找IO映射 */
   if (!context->slavelist[slave].configindex)
   {
      Isize = 0;
      Osize = 0;
      if (context->slavelist[slave].mbx_proto & ECT_MBXPROT_COE) /* 具有CoE */
      {
         rval = 0;
         if (context->slavelist[slave].CoEdetails & ECT_COEDET_SDOCA) /* 具有Complete Access */
         {
            /* 通过CoE读取PDO映射并使用Complete Access */
            rval = ecx_readPDOmapCA(context, slave, thread_n, &Osize, &Isize);
         }
         if (!rval) /* CA不可用或未成功 */
         {
            /* 通过CoE读取PDO映射 */
            rval = ecx_readPDOmap(context, slave, &Osize, &Isize);
         }
         EC_PRINT("  CoE 输出大小:%u 输入大小:%u\n", Osize, Isize);
      }
      if ((!Isize && !Osize) && (context->slavelist[slave].mbx_proto & ECT_MBXPROT_SOE)) /* 具有SoE */
      {
         /* 通过SoE读取AT/MDT映射 */
         rval = ecx_readIDNmap(context, slave, &Osize, &Isize);
         context->slavelist[slave].SM[2].SMlength = htoes((uint16)((Osize + 7) / 8));
         context->slavelist[slave].SM[3].SMlength = htoes((uint16)((Isize + 7) / 8));
         EC_PRINT("  SoE 输出大小:%u 输入大小:%u\n", Osize, Isize);
      }
      context->slavelist[slave].Obits = (uint16)Osize;
      context->slavelist[slave].Ibits = (uint16)Isize;
   }

   return 1;
}

static int ecx_map_sii(ecx_contextt *context, uint16 slave)
{
   uint32 Isize, Osize;
   int nSM;
   ec_eepromPDOt eepPDO;

   Osize = context->slavelist[slave].Obits;
   Isize = context->slavelist[slave].Ibits;

   if (!Isize && !Osize) /* 在具有相同ID的先前从站中查找PDO */
   {
      (void)ecx_lookup_mapping(context, slave, &Osize, &Isize);
   }
   if (!Isize && !Osize) /* 通过SII查找PDO映射 */
   {
      memset(&eepPDO, 0, sizeof(eepPDO));
      Isize = ecx_siiPDO(context, slave, &eepPDO, 0);
      EC_PRINT("  SII Isize:%u\n", Isize);
      for( nSM=0 ; nSM < EC_MAXSM ; nSM++ )
      {
         if (eepPDO.SMbitsize[nSM] > 0)
         {
            context->slavelist[slave].SM[nSM].SMlength =  htoes((eepPDO.SMbitsize[nSM] + 7) / 8);
            context->slavelist[slave].SMtype[nSM] = 4;
            EC_PRINT("    SM%d 长度 %d\n", nSM, eepPDO.SMbitsize[nSM]);
         }
      }
      Osize = ecx_siiPDO(context, slave, &eepPDO, 1);
      EC_PRINT("  SII Osize:%u\n", Osize);
      for( nSM=0 ; nSM < EC_MAXSM ; nSM++ )
      {
         if (eepPDO.SMbitsize[nSM] > 0)
         {
            context->slavelist[slave].SM[nSM].SMlength =  htoes((eepPDO.SMbitsize[nSM] + 7) / 8);
            context->slavelist[slave].SMtype[nSM] = 3;
            EC_PRINT("    SM%d 长度 %d\n", nSM, eepPDO.SMbitsize[nSM]);
         }
      }
   }
   context->slavelist[slave].Obits = (uint16)Osize;
   context->slavelist[slave].Ibits = (uint16)Isize;
   EC_PRINT("     输入大小:%d %d 输出大小:%d\n",
      context->slavelist[slave].Ibits, Isize, context->slavelist[slave].Obits);

   return 1;
}

static int ecx_map_sm(ecx_contextt *context, uint16 slave)
{
   uint16 configadr;
   int nSM;

   configadr = context->slavelist[slave].configadr;

   EC_PRINT("  SM编程\n");
   if (!context->slavelist[slave].mbx_l && context->slavelist[slave].SM[0].StartAddr)
   {
      ecx_FPWR(context->port, configadr, ECT_REG_SM0,
         sizeof(ec_smt), &(context->slavelist[slave].SM[0]), EC_TIMEOUTRET3);
      EC_PRINT("    SM0 类型:%d 起始地址:%4.4x 标志:%8.8x\n",
          context->slavelist[slave].SMtype[0],
          etohs(context->slavelist[slave].SM[0].StartAddr),
          etohl(context->slavelist[slave].SM[0].SMflags));
   }
   if (!context->slavelist[slave].mbx_l && context->slavelist[slave].SM[1].StartAddr)
   {
      ecx_FPWR(context->port, configadr, ECT_REG_SM1,
         sizeof(ec_smt), &context->slavelist[slave].SM[1], EC_TIMEOUTRET3);
      EC_PRINT("    SM1 类型:%d 起始地址:%4.4x 标志:%8.8x\n",
          context->slavelist[slave].SMtype[1],
          etohs(context->slavelist[slave].SM[1].StartAddr),
          etohl(context->slavelist[slave].SM[1].SMflags));
   }
   /* 编程SM2到SMx */
   for( nSM = 2 ; nSM < EC_MAXSM ; nSM++ )
   {
      if (context->slavelist[slave].SM[nSM].StartAddr)
      {
         /* 检查SM长度是否为零 -> 清除启用标志 */
         if( context->slavelist[slave].SM[nSM].SMlength == 0)
         {
            context->slavelist[slave].SM[nSM].SMflags =
               htoel( etohl(context->slavelist[slave].SM[nSM].SMflags) & EC_SMENABLEMASK);
         }
         /* 如果SM长度为非零，始终设置启用标志 */
         else
         {
            context->slavelist[slave].SM[nSM].SMflags =
               htoel( etohl(context->slavelist[slave].SM[nSM].SMflags) | ~EC_SMENABLEMASK);
         }
         ecx_FPWR(context->port, configadr, (uint16)(ECT_REG_SM0 + (nSM * sizeof(ec_smt)),
            sizeof(ec_smt), &context->slavelist[slave].SM[nSM], EC_TIMEOUTRET3);
         EC_PRINT("    SM%d 类型:%d 起始地址:%4.4x 标志:%8.8x\n", nSM,
             context->slavelist[slave].SMtype[nSM],
             etohs(context->slavelist[slave].SM[nSM].StartAddr),
             etohl(context->slavelist[slave].SM[nSM].SMflags));
      }
   }
   if (context->slavelist[slave].Ibits > 7)
   {
      context->slavelist[slave].Ibytes = (context->slavelist[slave].Ibits + 7) / 8;
   }
   if (context->slavelist[slave].Obits > 7)
   {
      context->slavelist[slave].Obytes = (context->slavelist[slave].Obits + 7) / 8;
   }

   return 1;
}


#if EC_MAX_MAPT > 1
OSAL_THREAD_FUNC ecx_mapper_thread(void *param)
{
   ecx_mapt_t *maptp;
   maptp = param;
   ecx_map_coe_soe(maptp->context, maptp->slave, maptp->thread_n);
   maptp->running = 0;
}

static int ecx_find_mapt(void)
{
   int p;
   p = 0;
   while((p < EC_MAX_MAPT) && ecx_mapt[p].running)
   {
      p++;
   }
   if(p < EC_MAX_MAPT)
   {
      return p;
   }
   else
   {
      return -1;
   }
}
#endif

static int ecx_get_threadcount(void)
{
   int thrc, thrn;
   thrc = 0;
   for(thrn = 0 ; thrn < EC_MAX_MAPT ; thrn++)
   {
      thrc += ecx_mapt[thrn].running;
   }
   return thrc;
}


static void ecx_config_find_mappings(ecx_contextt *context, uint8 group)
{
   int thrn, thrc;
   uint16 slave;

   for (thrn = 0; thrn < EC_MAX_MAPT; thrn++)
   {
      ecx_mapt[thrn].running = 0;
   }
   /* 查找多线程中的从站的CoE和SoE映射 */
   for (slave = 1; slave <= *(context->slavecount); slave++)
   {
      if (!group || (group == context->slavelist[slave].group))
      {
#if EC_MAX_MAPT > 1
            /* 多线程版本 */
            while ((thrn = ecx_find_mapt()) < 0)
            {
               osal_usleep(1000);
            }
            ecx_mapt[thrn].context = context;
            ecx_mapt[thrn].slave = slave;
            ecx_mapt[thrn].thread_n = thrn;
            ecx_mapt[thrn].running = 1;
            osal_thread_create(&(ecx_threadh[thrn]), 128000,
               &ecx_mapper_thread, &(ecx_mapt[thrn]));
#else
            /* 串行版本 */
            ecx_map_coe_soe(context, slave, 0);
#endif
      }
   }
   /* 等待所有线程完成 */
   do
   {
      thrc = ecx_get_threadcount();
      if (thrc)
      {
         osal_usleep(1000);
      }
   } while (thrc);
   /* 查找从站的SII映射并编程SM */
   for (slave = 1; slave <= *(context->slavecount); slave++)
   {
      if (!group || (group == context->slavelist[slave].group))
      {
         ecx_map_sii(context, slave);
         ecx_map_sm(context, slave);
      }
   }
}
static void ecx_config_create_input_mappings(ecx_contextt *context, void *pIOmap, 
   uint8 group, int16 slave, uint32 * LogAddr, uint8 * BitPos)
{
   int BitCount = 0;
   int FMMUdone = 0;
   int AddToInputsWKC = 0;
   uint16 ByteCount = 0;
   uint16 FMMUsize = 0;
   uint8 SMc = 0;
   uint16 EndAddr;
   uint16 SMlength;
   uint16 configadr;
   uint8 FMMUc;

   EC_PRINT(" =Slave %d, INPUT MAPPING\n", slave);

   configadr = context->slavelist[slave].configadr;
   FMMUc = context->slavelist[slave].FMMUunused;
   if (context->slavelist[slave].Obits) /* 查找空闲的FMMU */
   {
      while (context->slavelist[slave].FMMU[FMMUc].LogStart)
      {
         FMMUc++;
      }
   }
   /* 搜索为输入映射做出贡献的SM */
   while ((SMc < (EC_MAXSM - 1)) && (FMMUdone < ((context->slavelist[slave].Ibits + 7) / 8)))
   {
      EC_PRINT("    FMMU %d\n", FMMUc);
      while ((SMc < (EC_MAXSM - 1)) && (context->slavelist[slave].SMtype[SMc] != 4))
      {
         SMc++;
      }
      EC_PRINT("      SM%d\n", SMc);
      context->slavelist[slave].FMMU[FMMUc].PhysStart =
         context->slavelist[slave].SM[SMc].StartAddr;
      SMlength = etohs(context->slavelist[slave].SM[SMc].SMlength);
      ByteCount += SMlength;
      BitCount += SMlength * 8;
      EndAddr = etohs(context->slavelist[slave].SM[SMc].StartAddr) + SMlength;
      while ((BitCount < context->slavelist[slave].Ibits) && (SMc < (EC_MAXSM - 1))) /* 更多的SM用于输入 */
      {
         SMc++;
         while ((SMc < (EC_MAXSM - 1)) && (context->slavelist[slave].SMtype[SMc] != 4))
         {
            SMc++;
         }
         /* 如果来自多个SM的地址连接在一起，使用一个FMMU，否则分成多个FMMU */
         if (etohs(context->slavelist[slave].SM[SMc].StartAddr) > EndAddr)
         {
            break;
         }
         EC_PRINT("      SM%d\n", SMc);
         SMlength = etohs(context->slavelist[slave].SM[SMc].SMlength);
         ByteCount += SMlength;
         BitCount += SMlength * 8;
         EndAddr = etohs(context->slavelist[slave].SM[SMc].StartAddr) + SMlength;
      }

      /* 位定向从站 */
      if (!context->slavelist[slave].Ibytes)
      {
         context->slavelist[slave].FMMU[FMMUc].LogStart = htoel(*LogAddr);
         context->slavelist[slave].FMMU[FMMUc].LogStartbit = *BitPos;
         *BitPos += context->slavelist[slave].Ibits - 1;
         if (*BitPos > 7)
         {
            *LogAddr += 1;
            *BitPos -= 8;
         }
         FMMUsize = (uint16)(*LogAddr - etohl(context->slavelist[slave].FMMU[FMMUc].LogStart) + 1);
         context->slavelist[slave].FMMU[FMMUc].LogLength = htoes(FMMUsize);
         context->slavelist[slave].FMMU[FMMUc].LogEndbit = *BitPos;
         *BitPos += 1;
         if (*BitPos > 7)
         {
            *LogAddr += 1;
            *BitPos -= 8;
         }
      }
      /* 字节定向从站 */
      else
      {
         if (*BitPos)
         {
            *LogAddr += 1;
            *BitPos = 0;
         }
         context->slavelist[slave].FMMU[FMMUc].LogStart = htoel(*LogAddr);
         context->slavelist[slave].FMMU[FMMUc].LogStartbit = *BitPos;
         *BitPos = 7;
         FMMUsize = ByteCount;
         if ((FMMUsize + FMMUdone) > (int)context->slavelist[slave].Ibytes)
         {
            FMMUsize = (uint16)(context->slavelist[slave].Ibytes - FMMUdone);
         }
         *LogAddr += FMMUsize;
         context->slavelist[slave].FMMU[FMMUc].LogLength = htoes(FMMUsize);
         context->slavelist[slave].FMMU[FMMUc].LogEndbit = *BitPos;
         *BitPos = 0;
      }
      FMMUdone += FMMUsize;
      if (context->slavelist[slave].FMMU[FMMUc].LogLength)
      {
         context->slavelist[slave].FMMU[FMMUc].PhysStartBit = 0;
         context->slavelist[slave].FMMU[FMMUc].FMMUtype = 1;
         context->slavelist[slave].FMMU[FMMUc].FMMUactive = 1;
         /* 为输入编程FMMU */
         ecx_FPWR(context->port, configadr, ECT_REG_FMMU0 + (sizeof(ec_fmmut) * FMMUc),
            sizeof(ec_fmmut), &(context->slavelist[slave].FMMU[FMMUc]), EC_TIMEOUTRET3);
         /* 设置标志以添加一个输入FMMU，单个ESC只能贡献一次 */
         AddToInputsWKC = 1;
      }
      if (!context->slavelist[slave].inputs)
      {
         if (group)
         {
            context->slavelist[slave].inputs =
               (uint8 *)(pIOmap) + 
               etohl(context->slavelist[slave].FMMU[FMMUc].LogStart) - 
               context->grouplist[group].logstartaddr;
         }
         else
         {
            context->slavelist[slave].inputs =
               (uint8 *)(pIOmap) +
               etohl(context->slavelist[slave].FMMU[FMMUc].LogStart);
         }
         context->slavelist[slave].Istartbit =
            context->slavelist[slave].FMMU[FMMUc].LogStartbit;
         EC_PRINT("    Inputs %p startbit %d\n",
            context->slavelist[slave].inputs,
            context->slavelist[slave].Istartbit);
      }
      FMMUc++;
   }
   context->slavelist[slave].FMMUunused = FMMUc;

   /* 如果标志为true，则添加一个WKC用于输入 */
   if (AddToInputsWKC)
      context->grouplist[group].inputsWKC++;
}



static void ecx_config_create_output_mappings(ecx_contextt *context, void *pIOmap,
   uint8 group, int16 slave, uint32 * LogAddr, uint8 * BitPos)
{
   int BitCount = 0;
   int FMMUdone = 0;
   int AddToOutputsWKC = 0;
   uint16 ByteCount = 0;
   uint16 FMMUsize = 0;
   uint8 SMc = 0;
   uint16 EndAddr;
   uint16 SMlength;
   uint16 configadr;
   uint8 FMMUc;

   EC_PRINT("  输出映射\n");

   FMMUc = context->slavelist[slave].FMMUunused;
   configadr = context->slavelist[slave].configadr;

   /* 搜索对输出映射有贡献的SM */
   while ((SMc < (EC_MAXSM - 1)) && (FMMUdone < ((context->slavelist[slave].Obits + 7) / 8)))
   {
      EC_PRINT("    FMMU %d\n", FMMUc);
      while ((SMc < (EC_MAXSM - 1)) && (context->slavelist[slave].SMtype[SMc] != 3))
      {
         SMc++;
      }
      EC_PRINT("      SM%d\n", SMc);
      context->slavelist[slave].FMMU[FMMUc].PhysStart =
         context->slavelist[slave].SM[SMc].StartAddr;
      SMlength = etohs(context->slavelist[slave].SM[SMc].SMlength);
      ByteCount += SMlength;
      BitCount += SMlength * 8;
      EndAddr = etohs(context->slavelist[slave].SM[SMc].StartAddr) + SMlength;
      while ((BitCount < context->slavelist[slave].Obits) && (SMc < (EC_MAXSM - 1))) /* 更多的SM用于输出 */
      {
         SMc++;
         while ((SMc < (EC_MAXSM - 1)) && (context->slavelist[slave].SMtype[SMc] != 3))
         {
            SMc++;
         }
         /* 如果来自多个SM的地址连接在一起，使用一个FMMU，否则分成多个FMMU */
         if (etohs(context->slavelist[slave].SM[SMc].StartAddr) > EndAddr)
         {
            break;
         }
         EC_PRINT("      SM%d\n", SMc);
         SMlength = etohs(context->slavelist[slave].SM[SMc].SMlength);
         ByteCount += SMlength;
         BitCount += SMlength * 8;
         EndAddr = etohs(context->slavelist[slave].SM[SMc].StartAddr) + SMlength;
      }

      /* 位定向从站 */
      if (!context->slavelist[slave].Obytes)
      {
         context->slavelist[slave].FMMU[FMMUc].LogStart = htoel(*LogAddr);
         context->slavelist[slave].FMMU[FMMUc].LogStartbit = *BitPos;
         *BitPos += context->slavelist[slave].Obits - 1;
         if (*BitPos > 7)
         {
            *LogAddr += 1;
            *BitPos -= 8;
         }
         FMMUsize = (uint16)(*LogAddr - etohl(context->slavelist[slave].FMMU[FMMUc].LogStart) + 1);
         context->slavelist[slave].FMMU[FMMUc].LogLength = htoes(FMMUsize);
         context->slavelist[slave].FMMU[FMMUc].LogEndbit = *BitPos;
         *BitPos += 1;
         if (*BitPos > 7)
         {
            *LogAddr += 1;
            *BitPos -= 8;
         }
      }
      /* 字节定向从站 */
      else
      {
         if (*BitPos)
         {
            *LogAddr += 1;
            *BitPos = 0;
         }
         context->slavelist[slave].FMMU[FMMUc].LogStart = htoel(*LogAddr);
         context->slavelist[slave].FMMU[FMMUc].LogStartbit = *BitPos;
         *BitPos = 7;
         FMMUsize = ByteCount;
         if ((FMMUsize + FMMUdone)> (int)context->slavelist[slave].Obytes)
         {
            FMMUsize = (uint16)(context->slavelist[slave].Obytes - FMMUdone);
         }
         *LogAddr += FMMUsize;
         context->slavelist[slave].FMMU[FMMUc].LogLength = htoes(FMMUsize);
         context->slavelist[slave].FMMU[FMMUc].LogEndbit = *BitPos;
         *BitPos = 0;
      }
      FMMUdone += FMMUsize;
      if (context->slavelist[slave].FMMU[FMMUc].LogLength)
      {
         context->slavelist[slave].FMMU[FMMUc].PhysStartBit = 0;
         context->slavelist[slave].FMMU[FMMUc].FMMUtype = 2;
         context->slavelist[slave].FMMU[FMMUc].FMMUactive = 1;
         /* 为输出程序FMMU */
         ecx_FPWR(context->port, configadr, ECT_REG_FMMU0 + (sizeof(ec_fmmut) * FMMUc),
            sizeof(ec_fmmut), &(context->slavelist[slave].FMMU[FMMUc]), EC_TIMEOUTRET3);
         /* 设置标志以添加一个输出FMMU，一个单独的ESC只能贡献一次 */
         AddToOutputsWKC = 1;
      }
      if (!context->slavelist[slave].outputs)
      {
         if (group)
         {
            context->slavelist[slave].outputs =
               (uint8 *)(pIOmap) +
               etohl(context->slavelist[slave].FMMU[FMMUc].LogStart) -
               context->grouplist[group].logstartaddr;
         }
         else
         {
            context->slavelist[slave].outputs =
               (uint8 *)(pIOmap) +
               etohl(context->slavelist[slave].FMMU[FMMUc].LogStart);
         }
         context->slavelist[slave].Ostartbit =
            context->slavelist[slave].FMMU[FMMUc].LogStartbit;
         EC_PRINT("    从站 %d 输出 %p 开始位 %d\n",
            slave,
            context->slavelist[slave].outputs,
            context->slavelist[slave].Ostartbit);
      }
      FMMUc++;
   }
   context->slavelist[slave].FMMUunused = FMMUc;
   /* 如果标志为真，则为输出添加一个WKC */
   if (AddToOutputsWKC)
      context->grouplist[group].outputsWKC++;
}

/** 将一组从站中的所有PDO映射到IOmap，按顺序排列（传统SOEM方式）。

 *
 * @param[in]  context    = 上下文结构
 * @param[out] pIOmap     = 指向IOmap的指针
 * @param[in]  group      = 要映射的组，0表示所有组
 * @return IOmap大小
 */
int ecx_config_map_group(ecx_contextt *context, void *pIOmap, uint8 group)
{
   uint16 slave, configadr;
   uint8 BitPos;
   uint32 LogAddr = 0;
   uint32 oLogAddr = 0;
   uint32 diff;
   uint16 currentsegment = 0;
   uint32 segmentsize = 0;

   if ((*(context->slavecount) > 0) && (group < context->maxgroup))
   {
      EC_PRINT("ec_config_map_group IOmap:%p group:%d\n", pIOmap, group);
      LogAddr = context->grouplist[group].logstartaddr;
      oLogAddr = LogAddr;
      BitPos = 0;
      context->grouplist[group].nsegments = 0;
      context->grouplist[group].outputsWKC = 0;
      context->grouplist[group].inputsWKC = 0;

      /* 查找映射并设置同步管理器 */
      ecx_config_find_mappings(context, group);

      /* 对从站进行输出映射并设置FMMUs */
      for (slave = 1; slave <= *(context->slavecount); slave++)
      {
         configadr = context->slavelist[slave].configadr;

         if (!group || (group == context->slavelist[slave].group))
         {
            /* 创建输出映射 */
            if (context->slavelist[slave].Obits)
            {
               ecx_config_create_output_mappings (context, pIOmap, group, slave, &LogAddr, &BitPos);
               diff = LogAddr - oLogAddr;
               oLogAddr = LogAddr;
               if ((segmentsize + diff) > (EC_MAXLRWDATA - EC_FIRSTDCDATAGRAM))
               {
                  context->grouplist[group].IOsegment[currentsegment] = segmentsize;
                  if (currentsegment < (EC_MAXIOSEGMENTS - 1))
                  {
                     currentsegment++;
                     segmentsize = diff;
                  }
               }
               else
               {
                  segmentsize += diff;
               }
            }
         }
      }
      if (BitPos)
      {
         LogAddr++;
         oLogAddr = LogAddr;
         BitPos = 0;
         if ((segmentsize + 1) > (EC_MAXLRWDATA - EC_FIRSTDCDATAGRAM))
         {
            context->grouplist[group].IOsegment[currentsegment] = segmentsize;
            if currentsegment < (EC_MAXIOSEGMENTS - 1))
            {
               currentsegment++;
               segmentsize = 1;
            }
         }
         else
         {
            segmentsize += 1;
         }
      }
      context->grouplist[group].outputs = pIOmap;
      context->grouplist[group].Obytes = LogAddr - context->grouplist[group].logstartaddr;
      context->grouplist[group].nsegments = currentsegment + 1;
      context->grouplist[group].Isegment = currentsegment;
      context->grouplist[group].Ioffset = (uint16)segmentsize;
      if (!group)
      {
         context->slavelist[0].outputs = pIOmap;
         context->slavelist[0].Obytes = LogAddr - 
            context->grouplist[group].logstartaddr; /* 在主记录中存储输出字节 */
      }

      /* 对从站进行输入映射并设置FMMUs */
      for (slave = 1; slave <= *(context->slavecount); slave++)
      {
         configadr = context->slavelist[slave].configadr;
         if (!group || (group == context->slavelist[slave].group))
         {
            /* 创建输入映射 */
            if (context->slavelist[slave].Ibits)
            {
               ecx_config_create_input_mappings(context, pIOmap, group, slave, &LogAddr, &BitPos);
               diff = LogAddr - oLogAddr;
               oLogAddr = LogAddr;
               if ((segmentsize + diff) > (EC_MAXLRWDATA - EC_FIRSTDCDATAGRAM))
               {
                  context->grouplist[group].IOsegment[currentsegment] = segmentsize;
                  if (currentsegment < (EC_MAXIOSEGMENTS - 1))
                  {
                     currentsegment++;
                     segmentsize = diff;
                  }
               }
               else
               {
                  segmentsize += diff;
               }
            }

            ecx_eeprom2pdi(context, slave); /* 将EEPROM控制设置为PDI */
            /* 用户可以覆盖自动状态更改 */
            if (context->manualstatechange == 0)
            {
               /* 请求从站进入安全操作状态 */
               ecx_FPWRw(context->port,
                  configadr,
                  ECT_REG_ALCTL,
                  htoes(EC_STATE_SAFE_OP),
                  EC_TIMEOUTRET3); /* 设置安全操作状态 */
            }
            if (context->slavelist[slave].blockLRW)
            {
               context->grouplist[group].blockLRW++;
            }
            context->grouplist[group].Ebuscurrent += context->slavelist[slave].Ebuscurrent;
         }
      }
      if (BitPos)
      {
         LogAddr++;
         oLogAddr = LogAddr;
         BitPos = 0;
         if ((segmentsize + 1) > (EC_MAXLRWDATA - EC_FIRSTDCDATAGRAM))
         {
            context->grouplist[group].IOsegment[currentsegment] = segmentsize;
            if (currentsegment < (EC_MAXIOSEGMENTS - 1))
            {
               currentsegment++;
               segmentsize = 1;
            }
         }
         else
         {
            segmentsize += 1;
         }
      }
      context->grouplist[group].IOsegment[currentsegment] = segmentsize;
      context->grouplist[group].nsegments = currentsegment + 1;
      context->grouplist[group].inputs = (uint8 *)(pIOmap) + context->grouplist[group].Obytes;
      context->grouplist[group].Ibytes = LogAddr - 
         context->grouplist[group].logstartaddr - 
         context->grouplist[group].Obytes;
      if (!group)
      {
         context->slavelist[0].inputs = (uint8 *)(pIOmap) + context->slavelist[0].Obytes;
         context->slavelist[0].Ibytes = LogAddr - 
            context->grouplist[group].logstartaddr - 
            context->slavelist[0].Obytes; /* 在主记录中存储输入字节 */
      }

      EC_PRINT("IOmapSize %d\n", LogAddr - context->grouplist[group].logstartaddr);

      return (LogAddr - context->grouplist[group].logstartaddr);
   }

   return 0;
}

/** 将一组从站中的所有PDO映射到IOmap，包括输出和输入，具有重叠。注意：在使用LRW时必须使用这个功能。

 *
 * @param[in]  context    = 上下文结构
 * @param[out] pIOmap     = 指向IOmap的指针
 * @param[in]  group      = 要映射的组，0表示所有组
 * @return IOmap大小
 */
int ecx_config_overlap_map_group(ecx_contextt *context, void *pIOmap, uint8 group)
{
   uint16 slave, configadr;
   uint8 BitPos;
   uint32 mLogAddr = 0;
   uint32 siLogAddr = 0;
   uint32 soLogAddr = 0;
   uint32 tempLogAddr;
   uint32 diff;
   uint16 currentsegment = 0;
   uint32 segmentsize = 0;

   if ((*(context->slavecount) > 0) && (group < context->maxgroup))
   {
      EC_PRINT("ec_config_map_group IOmap:%p group:%d\n", pIOmap, group);
      mLogAddr = context->grouplist[group].logstartaddr;
      siLogAddr = mLogAddr;
      soLogAddr = mLogAddr;
      BitPos = 0;
      context->grouplist[group].nsegments = 0;
      context->grouplist[group].outputsWKC = 0;
      context->grouplist[group].inputsWKC = 0;

      /* 查找映射并设置同步管理器 */
      ecx_config_find_mappings(context, group);
      
      /* 对从站进行IO映射并设置FMMUs */
      for (slave = 1; slave <= *(context->slavecount); slave++)
      {
         configadr = context->slavelist[slave].configadr;
         siLogAddr = soLogAddr = mLogAddr;

         if (!group || (group == context->slavelist[slave].group))
         {
            /* 创建输出映射 */
            if (context->slavelist[slave].Obits)
            {
               ecx_config_create_output_mappings(context, pIOmap, group, 
                  slave, &soLogAddr, &BitPos);
               if (BitPos)
               {
                  soLogAddr++;
                  BitPos = 0;
               }
            }

            /* 创建输入映射 */
            if (context->slavelist[slave].Ibits)
            {
               ecx_config_create_input_mappings(context, pIOmap, group, 
                  slave, &siLogAddr, &BitPos);
               if (BitPos)
               {
                  siLogAddr++;
                  BitPos = 0;
               }
            }

            tempLogAddr = (siLogAddr > soLogAddr) ?  siLogAddr : soLogAddr;
            diff = tempLogAddr - mLogAddr;
            mLogAddr = tempLogAddr;

            if ((segmentsize + diff) > (EC_MAXLRWDATA - EC_FIRSTDCDATAGRAM))
            {
               context->grouplist[group].IOsegment[currentsegment] = segmentsize;
               if (currentsegment < (EC_MAXIOSEGMENTS - 1))
               {
                  currentsegment++;
                  segmentsize = diff;
               }
            }
            else
            {
               segmentsize += diff;
            }

            ecx_eeprom2pdi(context, slave); /* 将EEPROM控制设置为PDI */
            /* 用户可以覆盖自动状态更改 */
            if (context->manualstatechange == 0)
            {
               /* 请求从站进入安全操作状态 */
               ecx_FPWRw(context->port,
                  configadr,
                  ECT_REG_ALCTL,
                  htoes(EC_STATE_SAFE_OP),
                  EC_TIMEOUTRET3);
            }
            if (context->slavelist[slave].blockLRW)
            {
               context->grouplist[group].blockLRW++;
            }
            context->grouplist[group].Ebuscurrent += context->slavelist[slave].Ebuscurrent;
         }
      }

      context->grouplist[group].IOsegment[currentsegment] = segmentsize;
      context->grouplist[group].nsegments = currentsegment + 1;
      context->grouplist[group].Isegment = 0;
      context->grouplist[group].Ioffset = 0;

      context->grouplist[group].Obytes = soLogAddr - context->grouplist[group].logstartaddr;
      context->grouplist[group].Ibytes = siLogAddr - context->grouplist[group].logstartaddr;
      context->grouplist[group].outputs = pIOmap;
      context->grouplist[group].inputs = (uint8 *)pIOmap + context->grouplist[group].Obytes;

      /* 将计算的输入数据移动到带有OBytes偏移的位置 */
      for (slave = 1; slave <= *(context->slavecount); slave++)
      {
         if (!group || (group == context->slavelist[slave].group))
         {
            if(context->slavelist[slave].Ibits > 0)
            {
               context->slavelist[slave].inputs += context->grouplist[group].Obytes;
            }
         }
      }

      if (!group)
      {
         /* 在主记录中存储输出字节 */
         context->slavelist[0].outputs = pIOmap;
         context->slavelist[0].Obytes = soLogAddr - context->grouplist[group].logstartaddr; 
         context->slavelist[0].inputs = (uint8 *)pIOmap + context->slavelist[0].Obytes;
         context->slavelist[0].Ibytes = siLogAddr - context->grouplist[group].logstartaddr;
      }

      EC_PRINT("IOmapSize %d\n", context->grouplist[group].Obytes + context->grouplist[group].Ibytes);

      return (context->grouplist[group].Obytes + context->grouplist[group].Ibytes);
   }

   return 0;
}

/** 恢复从站。
 *
 * @param[in] context = 上下文结构
 * @param[in] slave   = 要恢复的从站
 * @param[in] timeout = 本地超时，例如EC_TIMEOUTRET3
 * @return >0 表示成功
 */
int ecx_recover_slave(ecx_contextt *context, uint16 slave, int timeout)
{
   int rval;
   int wkc;
   uint16 ADPh, configadr, readadr;

   rval = 0;
   configadr = context->slavelist[slave].configadr;
   ADPh = (uint16)(1 - slave);
   /* 检查是否找到了与请求的从站不同的从站 */
   readadr = 0xfffe;
   wkc = ecx_APRD(context->port, ADPh, ECT_REG_STADR, sizeof(readadr), &readadr, timeout);
   /* 找到正确的从站，完成 */
   if(readadr == configadr)
   {
       return 1;
   }
   /* 仅在没有配置地址时尝试 */
   if( (wkc > 0) && (readadr == 0))
   {
      /* 清除可能的从站地址EC_TEMPNODE */
      ecx_FPWRw(context->port, EC_TEMPNODE, ECT_REG_STADR, htoes(0) , 0);
      /* 设置从站的临时节点地址 */
      if(ecx_APWRw(context->port, ADPh, ECT_REG_STADR, htoes(EC_TEMPNODE) , timeout) <= 0)
      {
         ecx_FPWRw(context->port, EC_TEMPNODE, ECT_REG_STADR, htoes(0) , 0);
         return 0; /* 从站未响应 */
      }

      context->slavelist[slave].configadr = EC_TEMPNODE; /* 临时配置地址 */
      ecx_eeprom2master(context, slave); /* 设置EEPROM控制为主站 */

      /* 检查从站是否与之前配置的相同 */
      if ((ecx_FPRDw(context->port, EC_TEMPNODE, ECT_REG_ALIAS, timeout) ==
             htoes(context->slavelist[slave].aliasadr)) &&
          (ecx_readeeprom(context, slave, ECT_SII_ID, EC_TIMEOUTEEP) ==
             htoel(context->slavelist[slave].eep_id)) &&
          (ecx_readeeprom(context, slave, ECT_SII_MANUF, EC_TIMEOUTEEP) ==
             htoel(context->slavelist[slave].eep_man)) &&
          (ecx_readeeprom(context, slave, ECT_SII_REV, EC_TIMEOUTEEP) ==
             htoel(context->slavelist[slave].eep_rev)))
      {
         rval = ecx_FPWRw(context->port, EC_TEMPNODE, ECT_REG_STADR, htoes(configadr) , timeout);
         context->slavelist[slave].configadr = configadr;
      }
      else
      {
         /* 从站与预期的不同，移除配置地址 */
         ecx_FPWRw(context->port, EC_TEMPNODE, ECT_REG_STADR, htoes(0) , timeout);
         context->slavelist[slave].configadr = configadr;
      }
   }

   return rval;
}

/** 重新配置从站。
 *
 * @param[in] context = 上下文结构
 * @param[in] slave   = 要重新配置的从站
 * @param[in] timeout = 本地超时，例如EC_TIMEOUTRET3
 * @return 从站状态
 */
int ecx_reconfig_slave(ecx_contextt *context, uint16 slave, int timeout)
{
   int state, nSM, FMMUc;
   uint16 configadr;

   configadr = context->slavelist[slave].configadr;
   if (ecx_FPWRw(context->port, configadr, ECT_REG_ALCTL, htoes(EC_STATE_INIT) , timeout) <= 0)
   {
      return 0;
   }
   state = 0;
   ecx_eeprom2pdi(context, slave); /* 设置EEPROM控制为PDI */
   /* 检查状态变化是否初始化 */
   state = ecx_statecheck(context, slave, EC_STATE_INIT, EC_TIMEOUTSTATE);
   if(state == EC_STATE_INIT)
   {
      /* 程序所有已启用的SM */
      for( nSM = 0 ; nSM < EC_MAXSM ; nSM++ )
      {
         if (context->slavelist[slave].SM[nSM].StartAddr)
         {
            ecx_FPWR(context->port, configadr, (uint16)(ECT_REG_SM0 + (nSM * sizeof(ec_smt)),
               sizeof(ec_smt), &context->slavelist[slave].SM[nSM], timeout);
         }
      }
      ecx_FPWRw(context->port, configadr, ECT_REG_ALCTL, htoes(EC_STATE_PRE_OP) , timeout);
      state = ecx_statecheck(context, slave, EC_STATE_PRE_OP, EC_TIMEOUTSTATE); /* 检查状态变化到Pre-op */
      if( state == EC_STATE_PRE_OP)
      {
         /* 执行特殊的从站配置钩子，从Pre-Op到Safe-Op */
         if(context->slavelist[slave].PO2SOconfig) /* 仅在注册时执行 */
         {
            context->slavelist[slave].PO2SOconfig(slave);
         }
         if (context->slavelist[slave].PO2SOconfigx) /* 仅在注册时执行 */
         {
            context->slavelist[slave].PO2SOconfigx(context, slave);
         }         
         ecx_FPWRw(context->port, configadr, ECT_REG_ALCTL, htoes(EC_STATE_SAFE_OP) , timeout); /* 设置Safe-Op状态 */
         state = ecx_statecheck(context, slave, EC_STATE_SAFE_OP, EC_TIMEOUTSTATE); /* 检查状态变化到Safe-Op */
         /* 程序已配置的FMMU */
         for( FMMUc = 0 ; FMMUc < context->slavelist[slave].FMMUunused ; FMMUc++ )
         {
            ecx_FPWR(context->port, configadr, (uint16)(ECT_REG_FMMU0 + (sizeof(ec_fmmut) * FMMUc),
               sizeof(ec_fmmut), &context->slavelist[slave].FMMU[FMMUc], timeout);
         }
      }
   }

   return state;
}

#ifdef EC_VER1
/** 枚举并初始化所有从站。
 *
 * @param[in] usetable     = TRUE表示使用配置表来初始化从站，FALSE表示不使用配置表
 * @return 所发现的从站数据报的工作计数 = 找到的从站数量
 * @see ecx_config_init
 */
int ec_config_init(uint8 usetable)
{
   return ecx_config_init(&ecx_context, usetable);
}

/** 将一个组中的所有从站的所有PDOs按照顺序映射到IOmap中，遵循传统SOEM方式。
 *
 * @param[out] pIOmap     = 指向IOmap的指针
 * @param[in]  group      = 要映射的组，0表示所有组
 * @return IOmap的大小
 * @see ecx_config_map_group
 */
int ec_config_map_group(void *pIOmap, uint8 group)
{
   return ecx_config_map_group(&ecx_context, pIOmap, group);
}

/** 将一个组中的所有从站的所有PDOs映射到IOmap中，允许输出和输入重叠。注意：使用LRW时必须使用此方式，适用于TI ESC。
 *
 * @param[out] pIOmap     = 指向IOmap的指针
 * @param[in]  group      = 要映射的组，0表示所有组
 * @return IOmap的大小
 * @see ecx_config_overlap_map_group
 */
int ec_config_overlap_map_group(void *pIOmap, uint8 group)
{
   return ecx_config_overlap_map_group(&ecx_context, pIOmap, group);
}

/** 将所有从站的所有PDOs按照顺序映射到IOmap中，遵循传统SOEM方式。
 *
 * @param[out] pIOmap     = 指向IOmap的指针
 * @return IOmap的大小
 */
int ec_config_map(void *pIOmap)
{
   return ec_config_map_group(pIOmap, 0);
}

/** 将所有从站的所有PDOs映射到IOmap中，允许输出和输入重叠。注意：使用LRW时必须使用此方式，适用于TI ESC。
 *
 * @param[out] pIOmap     = 指向IOmap的指针
 * @return IOmap的大小
 */
int ec_config_overlap_map(void *pIOmap)
{
   return ec_config_overlap_map_group(pIOmap, 0);
}

/** 枚举、映射并初始化所有从站。
 *
 * @param[in] usetable    = TRUE表示使用配置表来初始化从站，FALSE表示不使用配置表
 * @param[out] pIOmap     = 指向IOmap的指针
 * @return 所发现的从站数据报的工作计数 = 找到的从站数量
 */
int ec_config(uint8 usetable, void *pIOmap)
{
   int wkc;
   wkc = ec_config_init(usetable);
   if (wkc)
   {
      ec_config_map(pIOmap);
   }
   return wkc;
}

/** 枚举、映射并初始化所有从站。
 *
 * @param[in] usetable    = TRUE表示使用配置表来初始化从站，FALSE表示不使用配置表
 * @param[out] pIOmap     = 指向IOmap的指针
 * @return 所发现的从站数据报的工作计数 = 找到的从站数量
 */
int ec_config_overlap(uint8 usetable, void *pIOmap)
{
   int wkc;
   wkc = ec_config_init(usetable);
   if (wkc)
   {
      ec_config_overlap_map(pIOmap);
   }
   return wkc;
}

/** 恢复从站。
 *
 * @param[in] slave   = 要恢复的从站
 * @param[in] timeout = 本地超时，例如EC_TIMEOUTRET3
 * @return 如果成功则返回大于0
 * @see ecx_recover_slave
 */
int ec_recover_slave(uint16 slave, int timeout)
{
   return ecx_recover_slave(&ecx_context, slave, timeout);
}

/** 重新配置从站。
 *
 * @param[in] slave   = 要重新配置的从站
 * @param[in] timeout = 本地超时，例如EC_TIMEOUTRET3
 * @return 从站状态
 * @see ecx_reconfig_slave
 */
int ec_reconfig_slave(uint16 slave, int timeout)
{
   return ecx_reconfig_slave(&ecx_context, slave, timeout);
}
#endif

该文档修改记录：

修改时间	修改说明
2023年11月4日	EtherCAT主站SOEM – 3 – SOEM之ethercatconfig.h/c文件解析

总结

以上就是EtherCAT主站SOEM – 3 --SOEM之ethercatconfig.h/c文件解析的内容。
有不明白的地方欢迎留言；有建议欢迎留言，我后面编写文档好改进。
创作不容，如果文档对您有帮助，记得给个赞。

你可能感兴趣的:(EtherCAT主站-SOEM,c语言,SOEM,EtherCAT,ethercatconfig,工业总线,经验分享,EtherCAT主站)

2022年河南省高等职业教育技能大赛云计算赛项竞赛赛卷（样卷）忘川_ydy 云计算云计算 openstack kubernetes docker python k8s ansible
#需要资源（软件包及镜像）或有问题的，可私博主！！！#需要资源（软件包及镜像）或有问题的，可私博主！！！#需要资源（软件包及镜像）或有问题的，可私博主！！！第一部分：私有云任务1私有云服务搭建(10分)使用提供的用户名密码，登录竞赛用的云计算平台，按要求自行使用镜像创建两台云主机，创建完云主机后确保网络正常通信，然后按要求配置服务器。根据提供安装脚本框架，补充脚本完成OpenStack平台的安装搭
打印出1-100的奇数。（C语言）王多鱼001 C语言 c语言算法数据结构
代码：#includeintmain(){for(inti=1;i<101;i++){if(i%2==1){printf("%d,",i);}}return0;}
5月8日盘前提示：维持短期可以操作到下周二左右的判断，重个股轻指数九命_猫妖
大盘：消息面。取消境外投资者额度限制，这个长线利好股市，短期影响不大，因为3000亿额度只用了1/3。额度本来就够用。走势看，昨天缩量横盘，走的还算中规中矩，近期一直弱势的次新股走势较强，前期强势股京威股份、光大嘉宝等跌停，由此判断市场还是存量博弈的市场，震荡是市场的主基调。维持短期可以操作到下周二左右的判断。下周后半段震荡回调的概率较高。思路：短期重个股轻指数行业和个股：物联网行业有利好，关注下
美团自动配送车2024春季招聘 | 社招专场美团技术团队
关于美团自动配送团队美团自动配送以自研L4级自动驾驶软硬件技术为核心，与美团即时零售业务结合，形成满足公开道路、校园、社区、工业园区等室外全场景下的自动配送整体解决方案。美团自动配送团队成立于2016年，团队成员来自于Waymo、Cruise、Pony.ai、泛亚等自动驾驶行业头部公司，自动驾驶技术团队博士占比高达30%，依靠视觉、激光等传感器，实时感知预测周围环境，通过高精地图定位和智能决策规划
《对我而言危险的他》：“假千金”归来，携手神秘霸总共破迷局入骨影评
由樊治欣李墨之主演的都市悬疑爱情剧《对我而言危险的他》在网上平台一次性播出全集。虽然是个小成本网剧，呈现出来的效果却十分有诚意。剧中从车祸到坠海、再到徒手灭火等惊险场面都是实景拍摄和主演们的无替身上场。说起樊治欣这个名字可能大家都不熟悉，但提起他演过的剧，大家都不陌生。饰演过《暗格里的秘密》中的学长苏柏从的樊治欣在这部剧中饰演霸总严星呈，即便同样戴着眼镜，却给人不一样的观感。该剧主要讲述了女主沈漫
llama.cpp 编译安装@Ubuntu skywalk8163 项目实践人工智能 llama ubuntu linux 人工智能
在Kylin和Ubuntu编译llama.cpp，具体参考：llama模型c语言推理@FreeBSD-CSDN博客现在代码并编译：gitclonehttps://github.com/ggerganov/llama.cppcdllama.cppmkdirbuildcdbuildcmake..cmake--build.--configRelease#可选安装makeinstall#或可选添加路径ex
图论记录之最短路迪杰斯特拉 Just right 算法图论 java 开发语言
简述思想这个思想能用一句话来概括，精简到的极致:每次找到一个最短距离的点并更新起点到各个点的最短距离如果要可视化的话，B站搜索Dijksra算法，有视频讲解伪代码写到这里，其实是想整一个动画的，这样效果更好点，但由于种种原因所以就拖一下intdijkstr(){dist[1]=0;其余的点的距离全部初始化为真无穷，不要写成int的最大值迭代n次将不在s中的，且距离最近的点给tsj即先到t，再加上t
关于举办第十五届蓝桥杯全国软件和信息技术专业人才大赛项目实战赛的通知 QSNKJJSW 蓝桥杯职场和发展青少年编程无人机机器人科技人工智能
各高等院校及相关单位：为贯彻落实《中国教育现代化2035》和《国务院关于印发新时期促进集成电路产业和软件产业高质量发展若干政策的通知》有关精神，为我国制造强国和网络强国战略提供人才支持，提高学生自主创新意识和工程实践能力，工业和信息化部人才交流中心决定举办第十五届蓝桥杯全国软件和信息技术专业人才大赛——项目实战赛。大赛连续四年入围中国高等教育学会“全国普通高校大学生竞赛排行榜”竞赛项目榜单。现将项
【译】kube-router-8 操作指南 niufw_qb docker 云原生 k8s 运维
kube-router的健康检查kube-router目前的基本健康检查方式是，每次主循环成功完成后，每个控制器都会向healthcontroller发送心跳。健康端口默认为20244，但可通过启动选项进行更改。健康检查路径为/healthz.--health-port=如果端口设置为0（零），HTTP端点将不可用，但健康控制器仍将运行，并将错过的心跳打印到kube-router的STDERR中。
物联网边缘网关有哪些优势？-天拓四方北京天拓四方科技股份有限公司物联网其他边缘计算
随着物联网技术的快速发展，越来越多的设备接入网络，数据交互日益频繁，对数据处理和传输的要求也越来越高。在这样的背景下，物联网边缘网关应运而生，以其低延迟、减少带宽消耗、提高数据质量和安全性等优势，为物联网应用提供了强大的支持。物联网边缘网关的应用场景广泛，几乎涵盖了所有需要实时数据处理和传输的领域。在工业场景中，边缘计算网关可以实时处理海量传感器和设备的数据，实现对运行、制造过程的全环节实时监控、
职场人员学习时间管理的重大意义时间管理v8
时间管理是指通过事先规划和运用一定的技巧、方法与工具实现对时间的灵活以及有效运用，从而实现个人或组织的既定目标。职场人员能否在自己的事业生涯中取得成功，秘诀就在于搞好时间管理。世界上最重要的东西是"时间"，不能管理时间，便什么也不能管理。时间是世界上最短缺的资源，除非严加管理，否则就会一事无成。职场人员学习时间管理的重大意义职场中时间陷阱为什么职场人员总是觉得时间不够，经常会导致加班加点的工作？主
虚境朝拾：懂王参加节目秀 2021/07/20 -5 群星璀璨十二时
虚境朝拾：2021/07/20场景5：懂王参加节目秀梦见懂王访华，带着两个手下。他们准备在杭州的即将开始的娱乐节目前秀一把实力。他们是其中一支参赛队。做足了准备。节目开始前，他们显得有些傲慢。比如懂王举着大瓶矿泉水吨吨吨在喝，喝的面红耳赤。其助手之一名校毕业，笔才惊人，然而因仕其主，而被台下观众们感到惋惜。另一个助手也是懂王的忠实的打手，尽管看上去平平无奇。
外卖大额优惠券领取方式!你知道在哪可以方便快捷的领取大额外卖氧惠爱高省
你是否厌倦了日常生活中的琐事，渴望享受一顿简单而美味的外卖？那么，今天我要为你揭秘一个秘密，让你在享受美食的同时，也能省下一些钱。氧惠APP（带货领导者）——是与以往完全不同的抖客+淘客app！2023全新模式，我的直推也会放到你下面。主打：带货高补贴，深受各位带货团队长喜爱（每天出单带货几十万单）。注册即可享受高补贴+0撸+捡漏等带货新体验。送万元推广大礼包，教你如何1年做到百万团队。你知道吗？
拼多多旗下返利app是什么,拼多多自己的返利软件用哪个? 氧惠爱高省
在电商领域，拼多多以其独特的团购模式和低价优惠吸引了大量消费者。为了进一步满足用户对于省钱购物的需求，拼多多也推出了自己的返利APP，为用户带来更多的实惠。氧惠APP是与以往完全不同的抖客+淘客app！2024全新模式，我的直推也会放到你下面。主打：带货高补贴，深受各位带货团队长喜爱（训练营导师每天出单带货几万单）。注册即可享受高补贴+0撸+捡漏等带货新体验。送万元推广大礼包，教你如何1年做到百万
项目管理工具最佳实践水岩
各个公司的最佳实践去哪儿jira自定义使用1.jira编号对应git分支命名，后台增加监控程序，新增一个分支，自动解析分支中的jira编号，自动落地到数据库，完成映射2.各个发布系统间信息同步，消息中心（IC）+数据中心（DC）,广播消息加一站式查询，持续集成，推进代码检查质量，分钟级反馈质量检查反思：1.项目管好：针对一线研发人员，简单易用，而不是满足管理层的“统计度量”（...）简化分类字段，
高阶SQL语句（二） www.mcb.com 数据库 mysql
一子查询也被称作内查询或者嵌套查询，是指在一个查询语句里面还嵌套着另一个查询语句。子查询语句是先于主查询语句被执行的，其结果作为外层的条件返回给主查询进行下一步的查询过滤。①子语句可以与主语句所查询的表相同，也可以是不同表②子语句中的sql语句是为了，最后过滤出一个结果集，用于主语句的判断条件③in:将主表和子表关联/连接的语法环境准备：mysql>usekgc_ky35;Readingtable
C语言pthread互斥锁(mutex)和可重入锁(递归锁recursive)的演示嫦娥妹妹等等我开发语言 c语言
实验理论参考:1一旦共享资源被互斥锁锁定,则其余线程想访问共享资源必须等待，直到锁被释放2使用normal属性的互斥锁,一旦发生重入逻辑,则阻塞,成为死锁需要将属性改为recursive成为可重入的,递归的代码功能:1命令行传参1model=1演示异步未上锁之乱序演示count在数据竞态（RaceCondition）下的错误值2命令行传参2model=2演示使用互斥锁后线程的执行顺序演示count
C语言演示多线程编程条件下自旋锁和屏障的使用嫦娥妹妹等等我开发语言 c语言开源
主线故事:有4个人玩游戏输了,惩罚:1分别使用4台不同的ATM机给我存钱2必须一块一块的存3存完还得在ATM上看一下我的余额设计模式:1每个人使用一条单独的线程,再准备一个计时线程用来输出时间2存钱涉及到对共享资源的读写,是原子操作需要用锁保护这里使用自旋锁3都存完钱后需要等待在各自的ATM上回显余额这里使用屏障技术4如果在主线程中回显对应他们给我打电话告诉我存完了我自己看一下则不需要使用屏障因为
生日蜡烛（C语言） blue and ACM c语言 java 算法
某君从某年开始每年都举办一次生日party，每次吹与年龄相同的蜡烛。现在他共吹了236根蜡烛。请问，他从多少岁开始过生日party的？答案：26#includeintmain(){intage=0;inttotal=0;for(inti=10;i<100;i++){for(intj=i;j<100;j++){total+=j;if(total==236){age=i;break;}}total=0
pdu电源线_pdu电源插座与普通电源插座的区别夹心酱紫 pdu电源线
描述pdu电源插座与普通电源插座的区别1、两者的功能不同普通插座只具备供电过载保护和总控开关的功能，而PDU不仅有供电过载保护和总控开关，还具备防雷抗冲电压、防静电防火等功能。2、两者的材料不同普通插座采用的是塑料材质，而PDU电源插座采用的是金属材质，具有防静电的作用。3、两者的应用领域不同普通插座一般应用于家庭或办公室，为计算机等电器提供电源，而PDU插座电源一般应用于数据中心、网络系统和工业
git删除之前所有的commit信息 fightingwy git github
拉取代码gitclone-bmasterurlgitcheckout--orphanorphan创建一个无父节点的branchgitmerge合并主分支的目前在孤儿分支上接着gitadd.gitcommit-m“xxx”gitswitchmastergitreset--hardorphan将masterreset到跟new一样的位置gitpush--force-with-leaseoriginma
【1.1 编程基础之输入输出】09. 字符菱形青少年编程小助手_Python Openjudge题目解析算法青少年编程电子学会等级考试 gesp
09:字符菱形总时间限制:1000ms内存限制:65536kB描述给定一个字符，用它构造一个对角线长5个字符，倾斜放置的菱形。输入输入只有一行，包含一个字符。输出该字符构成的菱形。样例输入*样例输出*************参考程序（1）C语言#includeintmain(){charc;scanf("%c",&c);printf("%c\n",c);printf("%c%c%c\n",c,c,
十大返利app排行-购物返利平台哪个比较好高省爱氧惠
嘿，小伙伴们，你们是不是经常在各大购物返利平台上跳来跳去，不知道哪个更好？别担心，我来给你们揭秘一下十大返利app排行，告诉你们哪个购物返利平台比较好！氧惠APP（带货领导者）——是与以往完全不同的抖客+淘客app！2024全新模式，我的直推也会放到你下面。主打：带货高补贴，深受各位带货团队长喜爱（每天出单带货几十万单）。注册即可享受高补贴+0撸+捡漏等带货新体验。送万元推广大礼包，教你如何1年做
C语言-数据在内存存储白榆maple c语言开发语言
目录一、整数在内存中存储1.整数在内存中的存储2.大小端字节序2.为什么有大小端3.大小端判断二、浮点数在内存中的存储1.V=(−1)^s∗M*2^EIEEE754规定：2.浮点数存的过程3.浮点数取的过程E不全为0或不全为1E全为0E全为1题⽬解析一、整数在内存中存储1.整数在内存中的存储在内存中存储的数据是二进制，整数的2进制表示方法有三种，即原码、反码和补码有符号的整数，三种表示方法均有符号
《单向度的人》——从单向度的人到碎片化的时代 18级陈心如
《单向度的人》封面刚刚读完了法兰克福学派的代表人物，赫伯特·马尔库塞的代表作《单向度的人》。正如此书的副标题：“发达工业社会意识形态研究”，这是一本对完善化的资本主义社会进行批判的著作。这本书诞生于60年代，因其深刻的洞察力与批判性一经付梓便风靡了欧美，甚至成为了上个世纪西欧社会主义思潮运动的理论来源的教科书。如现代西方众多的哲学出版物一样，本书的思路非常清晰同时也力求清晰。大致可分为三个部分:“
Qt中对主窗口的一些基本操作徐kun按门铃 Qt学习 css c++
一，给主窗口添加背景我们在做Qt项目的时候，难免需要在主场口上面添加背景图片，一般有两种方法来实现这一功能，可以在主窗口上面粘贴一个很大的QLabel然后在QLabel上面绘制图片，一般不会这样做，另外一种放法我们就需要重写绘制事件函数。paintEvent事件是在窗口状态改变之后处罚的，窗口的状态改变，可以是大小改变，也可以是别的。如下：头文件：protected://只要窗口状态改变自动调用此
C/C++中的Static关键字 SuhyOvO C语言 C++c语言 c++
Static关键字在C和C++编程中是不可或缺的一部分，它用于定义具有持久存储期的变量和函数，以及类的静态成员。虽然它的使用相对直接，但不恰当的使用可能会导致难以调试的错误和混淆。本文将探讨static关键字的概念、作用以及在C和C++中的具体应用。文章目录第一部分：深入理解Static关键字定义和基本概念在C和C++中static的基本作用第二部分：Static在C语言中的使用静态全局变量静态局
《天道》：真正厉害的人，都做对了这三点唐夕
去年偶然有一次在书店读到豆豆的小说《遥远的救世主》，读完大受震撼，有很多启发。随后一次性买全了豆豆三部曲，这部小说也一直放在书架上，又看了几遍。根据这本书改编的电视剧《天道》，豆瓣评分9.2分，相信你们也一定在短视频平台上刷到过相关的小视频。短视频以及知乎很多博主，都在解读丁元英和芮小丹。但我在几次的阅读过程中，反而觉得欧阳雪更值得我们学习。欧阳雪没有芮小丹那样的出身，没有肖雅文那样的高学历。因家
赚钱app哪个最可靠？真实有效且靠谱的赚钱app有哪些? 氧惠评测
赚钱app哪个最可靠的问题没有固定答案，因为每个赚钱app都有其特点和优缺点，需要根据个人的需求和实际情况进行选择。以下是一些常见的赚钱app，供您参考：领购物大额优惠券、赚返利佣金用氧惠~氧惠APP（带货领导者）——是与以往完全不同的抖客+淘客app！2023全新模式，我的直推也会放到你下面。主打：带货高补贴，深受各位带货团队长喜爱（每天出单带货几十万单）氧惠是公认的返利最好用的软件。注册即可享
发芽日记-2021.4.7 月昔春
遵医嘱，今日大早来医院抽血。抽完血开始漫无边际的等待。中间吃了早饭，午饭。处理了一下工作。吃完午饭便到6楼手术室护士台等待。中午血值结果出来，雌二醇已经涨到1500多，虽然高了几百，但还没有网友分享的好几万那么夸张，按照300一个卵泡的量，是否预示又长了一两颗呢，现在已经不敢妄想了。下午2.30终于开始手术前的宣告，护士站姐姐卖力的宣读了注意事项，我担心记不住，又进行了录音。轮到我时，已经快3点了
用MiddleGenIDE工具生成hibernate的POJO（根据数据表生成POJO类） AdyZhang POJO eclipse Hibernate MiddleGenIDE
推荐:MiddlegenIDE插件, 是一个Eclipse 插件. 用它可以直接连接到数据库, 根据表按照一定的HIBERNATE规则作出BEAN和对应的XML ，用完后你可以手动删除它加载的JAR包和XML文件! 今天开始试着使用
.9.png Cb123456 android
“点九”是andriod平台的应用软件开发里的一种特殊的图片形式，文件扩展名为：.9.png 　　智能手机中有自动横屏的功能,同一幅界面会在随着手机(或平板电脑)中的方向传感器的参数不同而改变显示的方向,在界面改变方向后,界面上的图形会因为长宽的变化而产生拉伸,造成图形的失真变形。　　我们都知道android平台有多种不同的分辨率，很多控件的切图文件在被放大拉伸后，边
算法的效率天子之骄算法效率复杂度最坏情况运行时间大O阶平均情况运行时间
算法的效率效率是速度和空间消耗的度量。集中考虑程序的速度，也称运行时间或执行时间，用复杂度的阶(O)这一标准来衡量。空间的消耗或需求也可以用大O表示，而且它总是小于或等于时间需求。以下是我的学习笔记： 1.求值与霍纳法则，即为秦九韶公式。 2.测定运行时间的最可靠方法是计数对运行时间有贡献的基本操作的执行次数。运行时间与这个计数成正比。
java数据结构何必如此 java 数据结构
Java 数据结构 Java工具包提供了强大的数据结构。在Java中的数据结构主要包括以下几种接口和类：枚举（Enumeration）位集合（BitSet）向量（Vector）栈（Stack）字典（Dictionary）哈希表（Hashtable）属性（Properties）以上这些类是传统遗留的，在Java2中引入了一种新的框架-集合框架(Collect
MybatisHelloWorld 3213213333332132
//测试入口TestMyBatis package com.base.helloworld.test; import java.io.IOException; import org.apache.ibatis.io.Resources; import org.apache.ibatis.session.SqlSession; import org.apache.ibat
Java|urlrewrite|URL重写|多个参数 7454103 java xml Web 工作
个人工作经验！如有不当之处，敬请指点 1.0 web -info 目录下建立 urlrewrite.xml 文件类似如下： <?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE u
达梦数据库+ibatis darkranger sql mysql ibatis SQL Server
--插入数据方面如果您需要数据库自增... 那么在插入的时候不需要指定自增列. 如果想自己指定ID列的值, 那么要设置 set identity_insert 数据库名.模式名.表名; ----然后插入数据; example: create table zhabei.test( id bigint identity(1,1) primary key, nam
XML 解析四种方式 aijuans android
XML现在已经成为一种通用的数据交换格式,平台的无关性使得很多场合都需要用到XML。本文将详细介绍用Java解析XML的四种方法。 XML现在已经成为一种通用的数据交换格式,它的平台无关性,语言无关性,系统无关性,给数据集成与交互带来了极大的方便。对于XML本身的语法知识与技术细节,需要阅读相关的技术文献,这里面包括的内容有DOM(Document Object
spring中配置文件占位符的使用 avords
1.类 <?xml version="1.0" encoding="UTF-8"?><!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.o
前端工程化-公共模块的依赖和常用的工作流 bee1314 webpack
题记：一个人的项目，还有工程化的问题嘛？我们在推进模块化和组件化的过程中，肯定会不断的沉淀出我们项目的模块和组件。对于这些沉淀出的模块和组件怎么管理？另外怎么依赖也是个问题？你真的想这样嘛？ var BreadCrumb = require(‘../../../../uikit/breadcrumb’); //真心ugly。
上司说「看你每天准时下班就知道你工作量不饱和」，该如何回应？ bijian1013 项目管理沟通 IT职业规划
问题：上司说「看你每天准时下班就知道你工作量不饱和」，如何回应正常下班时间6点，只要是6点半前下班的，上司都认为没有加班。 Eno-Bea回答，注重感受，不一定是别人的虽然我不知道你具体从事什么工作与职业，但是我大概猜测，你是从事一项不太容易出现阶段性成果的工作
TortoiseSVN，过滤文件征客丶 SVN
环境： TortoiseSVN 1.8 配置：在文件夹空白处右键选择 TortoiseSVN -> Settings 在 Global ignote pattern 中添加要过滤的文件：多类型用英文空格分开 *name ：过滤所有名称为 name 的文件或文件夹 *.name ：过滤所有后缀为 name 的文件或文件夹 --------
【Flume二】HDFS sink细说 bit1129 Flume
1. Flume配置 a1.sources=r1 a1.channels=c1 a1.sinks=k1 ###Flume负责启动44444端口 a1.sources.r1.type=avro a1.sources.r1.bind=0.0.0.0 a1.sources.r1.port=44444 a1.sources.r1.chan
The Eight Myths of Erlang Performance bookjovi erlang
erlang有一篇guide很有意思： http://www.erlang.org/doc/efficiency_guide 里面有个The Eight Myths of Erlang Performance： http://www.erlang.org/doc/efficiency_guide/myths.html Myth: Funs are sl
java多线程网络传输文件(非同步)-2008-08-17 ljy325 java 多线程 socket
利用 Socket 套接字进行面向连接通信的编程。客户端读取本地文件并发送；服务器接收文件并保存到本地文件系统中。使用说明:请将TransferClient, TransferServer, TempFile三个类编译，他们的类包是FileServer. 客户端: 修改TransferClient: serPort, serIP, filePath, blockNum,的值来符合您机器的系
读《研磨设计模式》-代码笔记-模板方法模式 bylijinnan java 设计模式
声明：本文只为方便我个人查阅和理解，详细的分析以及源代码请移步原作者的博客http://chjavach.iteye.com/ import java.sql.Connection; import java.sql.DriverManager; import java.sql.PreparedStatement; import java.sql.ResultSet;
配置心得 chenyu19891124 配置
时间就这样不知不觉的走过了一个春夏秋冬，转眼间来公司已经一年了，感觉时间过的很快，时间老人总是这样不停走，从来没停歇过。作为一名新手的配置管理员，刚开始真的是对配置管理是一点不懂，就只听说咱们公司配置主要是负责升级，而具体该怎么做却一点都不了解。经过老员工的一点点讲解，慢慢的对配置有了初步了解，对自己所在的岗位也慢慢的了解。做了一年的配置管理给自总结下： 1.改变从一个以前对配置毫无
对“带条件选择的并行汇聚路由问题”的再思考 comsci 算法工作软件测试嵌入式领域模型
2008年上半年，我在设计并开发基于”JWFD流程系统“的商业化改进型引擎的时候，由于采用了新的嵌入式公式模块而导致出现“带条件选择的并行汇聚路由问题”(请参考2009-02-27博文)，当时对这个问题的解决办法是采用基于拓扑结构的处理思想，对汇聚点的实际前驱分支节点通过算法预测出来，然后进行处理，简单的说就是找到造成这个汇聚模型的分支起点，对这个起始分支节点实际走的路径数进行计算，然后把这个实际
Oracle 10g 的clusterware 32位下载地址 daizj oracle
Oracle 10g 的clusterware 32位下载地址 http://pan.baidu.com/share/link?shareid=531580&uk=421021908 http://pan.baidu.com/share/link?shareid=137223&uk=321552738 http://pan.baidu.com/share/l
非常好的介绍：Linux定时执行工具cron dongwei_6688 linux
Linux经过十多年的发展，很多用户都很了解Linux了，这里介绍一下Linux下cron的理解，和大家讨论讨论。cron是一个Linux 定时执行工具，可以在无需人工干预的情况下运行作业，本文档不讲cron实现原理，主要讲一下Linux定时执行工具cron的具体使用及简单介绍。新增调度任务推荐使用crontab -e命令添加自定义的任务（编辑的是/var/spool/cron下对应用户的cr
Yii assets目录生成及修改 dcj3sjt126com yii
assets的作用是方便模块化，插件化的，一般来说出于安全原因不允许通过url访问protected下面的文件，但是我们又希望将module单独出来，所以需要使用发布，即将一个目录下的文件复制一份到assets下面方便通过url访问。 assets设置对应的方法位置 \framework\web\CAssetManager.php assets配置方法在m
mac工作软件推荐 dcj3sjt126com mac
mac上的Terminal + bash ＋ screen组合现在已经非常好用了，但是还是经不起iterm＋zsh＋tmux的冲击。在同事的强烈推荐下，趁着升级mac系统的机会，顺便也切换到iterm＋zsh＋tmux的环境下了。我为什么要要iterm2 切换过来也是脑袋一热的冲动，我也调查过一些资料，看了下iterm的一些优点： * 兼容性好，远程服务器 vi 什么的低版本能很好兼
Memcached(三)、封装Memcached和Ehcache frank1234 memcached ehcache spring ioc
本文对Ehcache和Memcached进行了简单的封装，这样对于客户端程序无需了解ehcache和memcached的差异，仅需要配置缓存的Provider类就可以在二者之间进行切换，Provider实现类通过Spring IoC注入。 cache.xml <?xml version="1.0" encoding="UTF-8"?>
Remove Duplicates from Sorted List II hcx2013 remove
Given a sorted linked list, delete all nodes that have duplicate numbers, leaving only distinct numbers from the original list. For example,Given 1->2->3->3->4->4->5,
Spring4新特性——注解、脚本、任务、MVC等其他特性改进 jinnianshilongnian spring4
Spring4新特性——泛型限定式依赖注入 Spring4新特性——核心容器的其他改进 Spring4新特性——Web开发的增强 Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC Spring4新特性——Groovy Bean定义DSL Spring4新特性——更好的Java泛型操作API Spring4新
MySQL安装文档 liyong0802 mysql
工作中用到的MySQL可能安装在两种操作系统中，即Windows系统和Linux系统。以Linux系统中情况居多。安装在Windows系统时与其它Windows应用程序相同按照安装向导一直下一步就即，这里就不具体介绍，本文档只介绍Linux系统下MySQL的安装步骤。 Linux系统下安装MySQL分为三种：RPM包安装、二进制包安装和源码包安装。二
使用VS2010构建HotSpot工程 p2p2500 HotSpot OpenJDK VS2010
1. 下载OpenJDK7的源码： http://download.java.net/openjdk/jdk7 http://download.java.net/openjdk/ 2. 环境配置 ▶
Oracle实用功能之分组后列合并 seandeng888 oracle 分组实用功能合并
1 实例解析由于业务需求需要对表中的数据进行分组后进行合并的处理，鉴于Oracle10g没有现成的函数实现该功能，且该功能如若用JAVA代码实现会比较复杂，因此，特将SQL语言的实现方式分享出来，希望对大家有所帮助。如下：表test 数据如下： ID,SUBJECTCODE,DIMCODE,VALUE 1&nbs
Java定时任务注解方式实现 tuoni java spring jvm xml jni
Spring 注解的定时任务，有如下两种方式：第一种： <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http
11大Java开源中文分词器的使用方法和分词效果对比 yangshangchuan word分词器 ansj分词器 Stanford分词器 FudanNLP分词器 HanLP分词器
本文的目标有两个： 1、学会使用11大Java开源中文分词器 2、对比分析11大Java开源中文分词器的分词效果本文给出了11大Java开源中文分词的使用方法以及分词结果对比代码，至于效果哪个好，那要用的人结合自己的应用场景自己来判断。 11大Java开源中文分词器，不同的分词器有不同的用法，定义的接口也不一样，我们先定义一个统一的接口： /** * 获取文本的所有分词结果, 对比

EtherCAT主站SOEM -- 3 -- SOEM之ethercatconfig.h/c文件解析

EtherCAT主站SOEM -- 3 -- SOEM之ethercatconfig.h/c文件解析

一 ethercatconfig.h/c文件功能预览：

二 ethercatconfig.h/c 中主要函数的作用：

2.1.1 ec_config_init(uint8 usetable) 和 ecx_config_init(ecx_contextt *context, uint8 usetable)：

2.1.2 ec_config_map(void *pIOmap)：

2.1.3 ec_config_overlap_map(void *pIOmap) 和 ecx_config_overlap_map_group(ecx_contextt *context, void *pIOmap, uint8 group)：

2.1.4 ec_config(uint8 usetable, void *pIOmap) 和 ecx_config_init(ecx_contextt *context, uint8 usetable)：

2.1.5 ec_recover_slave(uint16 slave, int timeout) 和 ecx_recover_slave(ecx_contextt *context, uint16 slave, int timeout)：

2.1.6 ec_reconfig_slave(uint16 slave, int timeout) 和 ecx_reconfig_slave(ecx_contextt *context, uint16 slave, int timeout)：

三 ethercatconfig.c 原文件的中文注释

该文档修改记录：

总结

你可能感兴趣的:(EtherCAT主站-SOEM,c语言,SOEM,EtherCAT,ethercatconfig,工业总线,经验分享,EtherCAT主站)

2.1.1 `ec_config_init(uint8 usetable)` 和 `ecx_config_init(ecx_contextt *context, uint8 usetable)`：

2.1.2 `ec_config_map(void *pIOmap)`：

2.1.3 `ec_config_overlap_map(void pIOmap)` 和 `ecx_config_overlap_map_group(ecx_contextt context, void *pIOmap, uint8 group)`：

2.1.4 `ec_config(uint8 usetable, void pIOmap)` 和 `ecx_config_init(ecx_contextt context, uint8 usetable)`：

2.1.5 `ec_recover_slave(uint16 slave, int timeout)` 和 `ecx_recover_slave(ecx_contextt *context, uint16 slave, int timeout)`：

2.1.6 `ec_reconfig_slave(uint16 slave, int timeout)` 和 `ecx_reconfig_slave(ecx_contextt *context, uint16 slave, int timeout)`：