【EtherCAT】FMMU和SM简介

最新推荐文章于 2024-06-18 17:21:28 发布
最新推荐文章于 2024-06-18 17:21:28 发布
阅读量1.7k 收藏 30
点赞数 16
分类专栏： 工业总线 文章标签： 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46211259/article/details/137949627
版权

目录

一、简介

       1、 FMMU

       2、SM

        (1) 缓冲模式

        (2)邮箱模式

 3、FMMU将物理存储器映射到逻辑过程数据映射的配置原理

二、FMMU和SM在EtherCAT从站控制器的存储空间分配

三、FMMU和SM部分寄存器描述(LAN9253)

1、FMMU

2、SM

四、FMMU和SM的数据结构（soem主站）

 (1)  FMMU数据结构

 (2) SM数据结构

 五、FMMU和SM映射关系代码参考（soem）

六、其他相关链接

一、简介

       1、 FMMU

                Fieldbus Memory Management Unit，现场总线存储器管理单元， 通过内部地址映射将逻辑地址转换为物理地址。

                FMMU允许跨越多个从设备的数据段使用逻辑地址；一个数据报寻址几个任意分布的EtherCAT从站控制器内的数据。

                每个FMMU通道将一个连续的逻辑地址空间映射到从站的一个连续物理地址空间。

                EtherCAT从站控制器的FMMU支持逐位映射，支持的FMMU数量取决于EtherCAT从站控制器。

                FMMU支持的访问类型可配置为读、写或读/写。   

       2、SM

                Sync Manager, 同步管理；

                直接用EtherCAT从站控制器的存储器实现EtherCAT主站和本地应用程序之间交换数据，没有任何限制，这种直接通过内存通信存在缺点。所以需要SM来同步管理。SM可在EtherCAT主站和本地应用程序之间实现一致且安全的数据交换，并生成中断来通知双方发生数据更改。

        SM管理DPRAM，保证了应用数据的一致性和安全性。

        SM由EtherCAT主站配置。

        SM支持两种通信模式。

        (1) 缓冲模式

                缓冲模式允许EtherCAT主站和本地应用程序随时访问通信缓冲区。

                缓冲模式通常应用与循环过程数据。

        (2)邮箱模式

                邮箱模式以握手机制实现数据交换，不会丢数据。

                邮箱模式通常用于应用程序层协议。

 3、FMMU将物理存储器映射到逻辑过程数据映射的配置原理

              

二、FMMU和SM在EtherCAT从站控制器的存储空间分配

      

三、FMMU和SM部分寄存器描述(LAN9253)

1、FMMU

        

2、SM

        

四、FMMU和SM的数据结构（soem主站）

 (1)  FMMU数据结构

/** record for FMMU */
typedef __packed struct
{
    uint32 LogStart;
    uint16 LogLength;
    uint8 LogStartbit;
    uint8 LogEndbit;
    uint16 PhysStart;
    uint8 PhysStartBit;
    uint8 FMMUtype;
    uint8 FMMUactive;
    uint8 unused1;
    uint16 unused2;
    
} ec_fmmut;

   (2) SM数据结构

/** record for sync manager */
typedef __packed struct
{
    uint16 StartAddr;
    uint16 SMlength;
    uint32 SMflag;
} ec_smt;

五、FMMU和SM映射关系代码参考（soem）

/** Map all PDOs in one group of slaves to IOmap.
*
* @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)
{
   uint16 slave, configadr;
   int Isize, Osize, BitCount, ByteCount, FMMUsize, FMMUdone;
   uint16 SMlength, EndAddr;
   uint8 BitPos;
   uint8 SMc, FMMUc;
   uint32 LogAddr = 0;
   uint32 oLogAddr = 0;
   uint32 diff;
   int nSM, rval;
   ec_eepromPDOt eepPDO;
   uint16 currentsegment = 0;
   uint32 segmentsize = 0;

   if ((*(context->slavecount) > 0) && (group < context->maxgroup))
   {  
      EC_PRINT("ec_config_map_group IOmap:%p group:%d\n \r", 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;

      /* find output mapping of slave and program FMMU */
      for (slave = 1; slave <= *(context->slavecount); slave++)
      {
         configadr = context->slavelist[slave].configadr;

         ecx_statecheck(context, slave, EC_STATE_PRE_OP, EC_TIMEOUTSTATE); /* check state change pre-op */

         EC_PRINT(" >Slave %d, configadr %x, state %2.2x\n \r",
                  slave, context->slavelist[slave].configadr, context->slavelist[slave].state);

         /* execute special slave configuration hook Pre-Op to Safe-OP */
         if(context->slavelist[slave].PO2SOconfig) /* only if registered */
         {
            context->slavelist[slave].PO2SOconfig(slave);        
         }
if(context->slavelist[slave].proc_init) /* only if registered */
{
    context->slavelist[slave].proc_init(context,slave);        
}
         if (!group || (group == context->slavelist[slave].group))
         {  
        
            /* if slave not found in configlist find IO mapping in slave self */
            if (!context->slavelist[slave].configindex)
            {
               Isize = 0;
               Osize = 0;
               if (context->slavelist[slave].mbx_proto & ECT_MBXPROT_COE) /* has CoE */
               {
                  rval = 0;
                  if (context->slavelist[slave].CoEdetails & ECT_COEDET_SDOCA) /* has Complete Access */
                     /* read PDO mapping via CoE and use Complete Access */
                  {
                     rval = ecx_readPDOmapCA(context, slave, &Osize, &Isize);
                  }
                  if (!rval) /* CA not available or not succeeded */
                  {
                     /* read PDO mapping via CoE */
                     rval = ecx_readPDOmap(context, slave, &Osize, &Isize);
                  }
                  EC_PRINT("  CoE Osize:%d Isize:%d\n \r", Osize, Isize);
               }
               if ((!Isize && !Osize) && (context->slavelist[slave].mbx_proto & ECT_MBXPROT_SOE)) /* has SoE */
               {
                  /* read AT / MDT mapping via SoE */
                  rval = ecx_readIDNmap(context, slave, &Osize, &Isize);
                  context->slavelist[slave].SM[2].SMlength = htoes((Osize + 7) / 8);
                  context->slavelist[slave].SM[3].SMlength = htoes((Isize + 7) / 8);
                  EC_PRINT("  SoE Osize:%d Isize:%d\n \r", Osize, Isize);
               }
               if (!Isize && !Osize) /* find PDO mapping by SII */
               {
                  memset(&eepPDO, 0, sizeof(eepPDO));
                  Isize = (int)ecx_siiPDO(context, slave, &eepPDO, 0);
                  EC_PRINT("  SII Isize:%d\n \r", 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 length %d\n \r", nSM, eepPDO.SMbitsize[nSM]);
                     }  
                  }  
                  Osize = (int)ecx_siiPDO(context, slave, &eepPDO, 1);
                  EC_PRINT("  SII Osize:%d\n \r", 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 length %d\n \r", nSM, eepPDO.SMbitsize[nSM]);
                     }  
                  }  
               }
               context->slavelist[slave].Obits = Osize;
               context->slavelist[slave].Ibits = Isize;
               EC_PRINT("     ISIZE:%d %d OSIZE:%d\n \r",
                  context->slavelist[slave].Ibits, Isize,context->slavelist[slave].Obits);   
            }

            EC_PRINT("  SM programming\n \r"); 
            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 Type:%d StartAddr:%4.4x Flags:%8.8x\n \r",
                   context->slavelist[slave].SMtype[0],
                   context->slavelist[slave].SM[0].StartAddr,
                   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 Type:%d StartAddr:%4.4x Flags:%8.8x\n \r",
                   context->slavelist[slave].SMtype[1],
                   context->slavelist[slave].SM[1].StartAddr,
                   context->slavelist[slave].SM[1].SMflags);  
            }
            /* program SM2 to SMx */
            for( nSM = 2 ; nSM < EC_MAXSM ; nSM++ )
            {  
               if (context->slavelist[slave].SM[nSM].StartAddr)
               {
                  /* check if SM length is zero -> clear enable flag */
                  if( context->slavelist[slave].SM[nSM].SMlength == 0)
                  {
                     context->slavelist[slave].SM[nSM].SMflags =
                        htoel( etohl(context->slavelist[slave].SM[nSM].SMflags) & EC_SMENABLEMASK);
                  }
                  ecx_FPWR(context->port, configadr, ECT_REG_SM0 + (nSM * sizeof(ec_smt)),
                     sizeof(ec_smt), &context->slavelist[slave].SM[nSM], EC_TIMEOUTRET3);
                  EC_PRINT("    SM%d Type:%d StartAddr:%4.4x Flags:%8.8x\n \r", nSM,
                      context->slavelist[slave].SMtype[nSM],
                      context->slavelist[slave].SM[nSM].StartAddr,
                      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;
            }
            FMMUc = context->slavelist[slave].FMMUunused;
            SMc = 0;
            BitCount = 0;
            ByteCount = 0;
            EndAddr = 0;
            FMMUsize = 0;
            FMMUdone = 0;
            /* create output mapping */
            if (context->slavelist[slave].Obits)
            {
               EC_PRINT("  OUTPUT MAPPING\n \r");
               /* search for SM that contribute to the output mapping */
               while ( (SMc < (EC_MAXSM - 1)) && (FMMUdone < ((context->slavelist[slave].Obits + 7) / 8)))
               {  
                  EC_PRINT("    FMMU %d\n \r", FMMUc);
                  while ( (SMc < (EC_MAXSM - 1)) && (context->slavelist[slave].SMtype[SMc] != 3)) SMc++;
                  EC_PRINT("      SM%d\n \r", 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)) ) /* more SM for output */
                  {
                     SMc++;
                     while ( (SMc < (EC_MAXSM - 1)) && (context->slavelist[slave].SMtype[SMc] != 3)) SMc++;
                     /* if addresses from more SM connect use one FMMU otherwise break up in mutiple FMMU */
                     if ( etohs(context->slavelist[slave].SM[SMc].StartAddr) > EndAddr )
                     {
                        break;
                     }
                     EC_PRINT("      SM%d\n \r", SMc);
                     SMlength = etohs(context->slavelist[slave].SM[SMc].SMlength);
                     ByteCount += SMlength;
                     BitCount += SMlength * 8;
                     EndAddr = etohs(context->slavelist[slave].SM[SMc].StartAddr) + SMlength;              
                  }  

                  /* bit oriented slave */
                  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++;
                        BitPos -= 8;
                     }  
                     FMMUsize = 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 ++;
                     if (BitPos > 7)
                     {
                        LogAddr++;
                        BitPos -= 8;
                     }  
                  }
                  /* byte oriented slave */
                  else
                  {
                     if (BitPos)
                     {
                        LogAddr++;
                        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 = 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;
                  context->slavelist[slave].FMMU[FMMUc].PhysStartBit = 0;
                  context->slavelist[slave].FMMU[FMMUc].FMMUtype = 2;
                  context->slavelist[slave].FMMU[FMMUc].FMMUactive = 1;
                  /* program FMMU for output */
                  ecx_FPWR(context->port, configadr, ECT_REG_FMMU0 + (sizeof(ec_fmmut) * FMMUc),
                     sizeof(ec_fmmut), &(context->slavelist[slave].FMMU[FMMUc]), EC_TIMEOUTRET3);
                  context->grouplist[group].outputsWKC++;
                  if (!context->slavelist[slave].outputs)
                  {  
                     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("    slave %d Outputs %p startbit %d\n \r",
                        slave,
                        context->slavelist[slave].outputs,
                        context->slavelist[slave].Ostartbit);
                  }
                  FMMUc++;
               }  
               context->slavelist[slave].FMMUunused = FMMUc;
               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].nsegments = currentsegment + 1;
      context->grouplist[group].Isegment = currentsegment;
      context->grouplist[group].Ioffset = segmentsize;
      if (!group)
      {  
         context->slavelist[0].outputs = pIOmap;
         context->slavelist[0].Obytes = LogAddr; /* store output bytes in master record */
      }  
     
      /* do input mapping of slave and program FMMUs */
      for (slave = 1; slave <= *(context->slavecount); slave++)
      {
         configadr = context->slavelist[slave].configadr;
         FMMUc = context->slavelist[slave].FMMUunused;
         if (context->slavelist[slave].Obits) /* find free FMMU */
         {
            while ( context->slavelist[slave].FMMU[FMMUc].LogStart ) FMMUc++;
         }
         SMc = 0;
         BitCount = 0;
         ByteCount = 0;
         EndAddr = 0;
         FMMUsize = 0;
         FMMUdone = 0;
         /* create input mapping */
         if (context->slavelist[slave].Ibits)
         {
            EC_PRINT(" =Slave %d, INPUT MAPPING\n \r", slave);
            /* search for SM that contribute to the input mapping */
            while ( (SMc < (EC_MAXSM - 1)) && (FMMUdone < ((context->slavelist[slave].Ibits + 7) / 8)))
            {  
               EC_PRINT("    FMMU %d\n \r", FMMUc);
               while ( (SMc < (EC_MAXSM - 1)) && (context->slavelist[slave].SMtype[SMc] != 4)) SMc++;
               EC_PRINT("      SM%d\n \r", 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)) ) /* more SM for input */
               {
                  SMc++;
                  while ( (SMc < (EC_MAXSM - 1)) && (context->slavelist[slave].SMtype[SMc] != 4)) SMc++;
                  /* if addresses from more SM connect use one FMMU otherwise break up in mutiple FMMU */
                  if ( etohs(context->slavelist[slave].SM[SMc].StartAddr) > EndAddr )
                  {
                     break;
                  }
                  EC_PRINT("      SM%d\n \r", SMc);
                  SMlength = etohs(context->slavelist[slave].SM[SMc].SMlength);
                  ByteCount += SMlength;
                  BitCount += SMlength * 8;
                  EndAddr = etohs(context->slavelist[slave].SM[SMc].StartAddr) + SMlength;              
               }  

               /* bit oriented slave */
               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++;
                     BitPos -= 8;
                  }  
                  FMMUsize = 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 ++;
                  if (BitPos > 7)
                  {
                     LogAddr++;
                     BitPos -= 8;
                  }  
               }
               /* byte oriented slave */
               else
               {
                  if (BitPos)
                  {
                     LogAddr++;
                     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 = 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;
                  /* program FMMU for input */
                  ecx_FPWR(context->port, configadr, ECT_REG_FMMU0 + (sizeof(ec_fmmut) * FMMUc),
                     sizeof(ec_fmmut), &(context->slavelist[slave].FMMU[FMMUc]), EC_TIMEOUTRET3);
                  /* add one for an input FMMU */
                  context->grouplist[group].inputsWKC++;
               }  
               if (!context->slavelist[slave].inputs)
               {  
                  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 \r",
                     context->slavelist[slave].inputs,
                     context->slavelist[slave].Istartbit);
               }
               FMMUc++;
            }  
            context->slavelist[slave].FMMUunused = FMMUc;
            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); /* set Eeprom control to PDI */        
         ecx_FPWRw(context->port, configadr, ECT_REG_ALCTL, htoes(EC_STATE_SAFE_OP) , EC_TIMEOUTRET3); /* set safeop status */
                 
         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].Obytes;
      if (!group)
      {  
         context->slavelist[0].inputs = (uint8 *)(pIOmap) + context->slavelist[0].Obytes;
         context->slavelist[0].Ibytes = LogAddr - context->slavelist[0].Obytes; /* store input bytes in master record */
      }  

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

六、其他相关链接

EtherCAT从站开发要点-CSDN博客

【EtherCAT】ＣＯＥ对象字典与PDO映射简介-CSDN博客

小可嵌入式
关注
  • 16
    点赞
  • 踩
  • 30
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
EtherCAT从站EEPROM分类附加信息详解：SM（同步管理器）
kevin1499的博客
11-16 670
以实际的从站EEPROM数据为例，参照EtherCAT的SII规范，详细分析了从站EEPROM分类附加信息中SM（同步管理器）的结构。
EtherCAT学习笔记之FMMU寻址的理解
weixin_38933763的博客
05-29 7770
FMMU：现场总线内存管理单元； FMMU的作用非常关键，通俗的讲，它将报文逻辑数据地址和从站的物理地址相互转化、映射，这样的话，一包报文就可以装载多个从站、多种格式的数据； 以下是学习时的截图，讲的是数据地址0x00010011偏移3位 至 0x00010013第0位映射0x0F01第一位至0x0F02第六位，想更好的理解FMMU，这两张图的对应关系需要好好看明白。 FMMU操作请注意以下几...
Ethercat FMMU寻址，Working Counter
02-26
该文档描述了Ethercat的寻址，Working Counter的工作原理。
EtherCat：打通EtherCat奇经八脉（一）
Mr.Sugarcane
05-15 4799
EtherCat 基础知识
EtherCAT主站SOEM源码解析----同步管理器SM配置
weixin_43956732的博客
06-04 3274
本文介绍SOEM(Simple Open Source Master)如何配置从站的SM(SyncManager)寄存器。 基于SOEM-1.3.1。 1、SM寄存器 SM配置寄存器从0x800开始，每个通道使用8个字节，如下图所示： 其中，物理起始地址和控制寄存器使用从站EEPROM中的值，长度根据PDO中映射的数据长度计算。 2、寄存器初始化 初始化过程中，SOEM会通过SII接口读取从站EEPROM中SM信息(分类信息类型为41)，并赋给相应的结构体， 具体代码在/soem/Etherc
EtherCAT增加PDO读写寄存器
11-23
EtherCAT增加PDO读写寄存器
Ethercat - SM
飞翔的猪 的博客
05-13 4636
Syncmanagers(同步管理器)    同步管理器简称SM用来协调应用程序和主机的数据交互，同步管理器同步的是数据而非时间，同步管理器确保了应用程序和主机能够正确的写入或读取数据。同时同步管理器可以以中断的形式通知主机和应用程序发生的数据更新事件。    从站的ESC中包含多个同步管理器，每一个同步管理器都可以单独的配置，同步管理器的配置中包括告知同步管理器其需要管理的内存地址的范围，管理内...
EtherCAT从站EEPROM分类附加信息详解：FMMU（现场总线内存管理单元）
kevin1499的博客
11-17 1100
以实际的从站EEPROM数据为例，参照EtherCAT的SII规范，详细分析了从站EEPROM分类附加信息中FMMU（现场总线内存管理单元）的结构。
Ethercat - FMMU
飞翔的猪 的博客
04-29 5612
Ethercat FMMU        总线内存管理单元是从站数据链路层的中的功能模块，用户只需要知道其作用即可，其配置完全由主站执行。       FMMU  - Fieldbus Memory Management Units.总线内存管理单元。  FMMU的功能是将主站分配的逻辑地址转换为本地地址，每一个FMMU通道将一段连续的物理地址映射到一段连续的逻辑地址中。这样就实现了主站的逻辑寻址...
页、块、程序间的关系
qq_43634879的博客
11-23 2276
页式存储 注意页和块的对象的不同 对程序进行分页存储 对内存进行分块存储 文章最后会给出我总结的页和块的关系 逻辑地址和物理地址 a)逻辑地址：由两部分组成，即页号 + 页内地址 设逻辑地址由总长度为m的二进制数表示，页内地址为n位，则页号为m-n位。 注意: 块内地址=页内地址=2n,同理最大的程序可允许有 > >2m-n个页面。 计算公式： 页号 = 逻辑地址/页长（商） 页内地址 = 逻辑地址%页长（余数） ...
Field Memory Management Unit(FMMU)
Terrys0518的专栏
12-04 2025
一. FMMU把从站分散的数据内容映射到主站连续的内存，减少子报文数量，便于主站应用层的编写。 FMMU由主站配置，主站包含一个2^32大小的逻辑地址空间，每一个从站的FMMU分别映射对应的地址空间。 二. 主站从站连接方式 如上图第从站1001 的FMMU0配置所示，将从站ESC内存地址起始 0x1800映射到FMMU地址10000，长度2字节，属性为写，即主站只需操作对逻辑地址10000写入两个字节，实际是对从站的内存0x1800地址写入两个字节。 同理，从站1001的FMMU1配.
EtherCAT 网络规划、安装和调试指南
05-08
- **商标和专利**：EtherCAT® 和 Safety over EtherCAT® 是德国Beckhoff Automation公司的注册商标和技术专利。 - **免责声明**：尽管文档内容经过精心撰写，但由于技术不断发展变化，文档中可能存在一定的误差或...
基于FPGA的EtherCAT从站控制器FMMU模块设计
10-15
EtherCAT技术的核心包括飞读飞写(processing on the fly)、FMMU (Fieldbus Memory Management Unit)和分布式时钟(DC)。 【FMMU模块设计】 FMMU（Fieldbus Memory Management Unit）是EtherCAT从站控制器ESC...
工业以太网EtherCAT的技术和应用.doc
12-21
分析了实时以太网技术的发展现状和发展趋势，并比较了当前主流的五种以太网标准的技术特点。针对EtherCAT实时以太网技术进行了细致的介绍和分析，并介绍了一种基于EtherCAT技术构建的多轴运动控制卡的实现。
EtherCAT笔记（一） —— 为什么是EtherCAT?
最新发布
m0_37763336的博客
06-18 104
EtherCAT学习笔记
EtherCAT总线通信Freerun、SM、DC三种同步模式分析
qq_37659294的博客
04-16 2290
总体的DC分布式时钟模式汇总如下流程所示：EtherCAT总线通信Freerun、SM、DC三种同步模式分析_ethercat dc同步_~晓广~的博客-CSDN博客。
尝试一文说明EtherCAT
weixin_45682319的博客
07-17 2168
学习EtherCAT的过程中从参考文章中提取出的内容，认为是比较关键的部分，希望能对你有所帮助，若理解有误也请指正。
ethercat fmmu
11-15
EtherCAT Fieldbus Memory Management Unit（FMMU）是一种用于EtherCAT网络的关键组件。它是用于管理数据在EtherCAT网络中传输的工具，可以同时处理输入和输出数据。 EtherCAT FMMU充当着EtherCAT网络中的数据交换站，它负责将从控制器发送的数据传输给从设备并接收从设备的响应数据。它将网络中的输入和输出数据进行有序的管理，并根据预先设置的实时要求对数据进行处理。 EtherCAT FMMU具有多个配置寄存器，可以根据网络的实际要求进行配置。这些配置寄存器可以用于设置数据的读取和写入策略，包括数据的访问权限、数据的传输顺序、数据的处理优先级等。通过对这些配置寄存器的设置，可以优化数据在网络中的传输和处理效率。 EtherCAT FMMU还可以实施数据的保护措施，例如，通过使用位掩码功能，可以定义某个特定的数据位的保护属性，以确保数据的安全性和保密性。此外，EtherCAT FMMU还可以实现数据的过滤和筛选功能，从而只传输和处理特定的数据，减少网络的负荷。 总之，EtherCAT FMMU是一个重要的组件，它能够有效管理和处理EtherCAT网络中的数据。通过合理配置和调整，可以优化数据的传输效率，并提高系统的实时性能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值