SDO处理过程（一）

最新推荐文章于 2024-05-26 14:17:32 发布
最新推荐文章于 2024-05-26 14:17:32 发布
阅读量2.9k 收藏 5
点赞数
分类专栏： EtherCAT协议
  1.         /* the last SDO is still in work */  
  2.         return MBXERR_SERVICEINWORK;  
  3.     }  
  4. #endif  
  5. /*根据SDO的不同的服务类型，选择想对应的SDO服务*/  
  6.     switch (command)  
  7.     {  
  8.     case SDOSERVICE_INITIATEDOWNLOADREQ:  
  9.     case SDOSERVICE_INITIATEUPLOADREQ:  
  10.         /* the variable index contains the requested index of the SDO service */  
[cpp]  view plain  copy
  1. /*这个变量索引包含需要的SDO服务的索引*/  
  2. index = pSdoInd->SdoHeader.Sdo[SDOHEADER_INDEXHIOFFSET] & SDOHEADER_INDEXHIMASK;  
  3. index <<= 8;  
  4. index += pSdoInd->SdoHeader.Sdo[SDOHEADER_INDEXLOOFFSET] >> SDOHEADER_INDEXLOSHIFT;  
  5. /* the variable subindex contains the requested subindex of the SDO service */  
[cpp]  view plain  copy
  1. <span style="white-space:pre">  </span>/*子索引的变量包含需要的SDO服务需要的子索引*/  
  2.         subindex    = pSdoInd->SdoHeader.Sdo[SDOHEADER_SUBINDEXOFFSET] >> SDOHEADER_SUBINDEXSHIFT;  
  3.   
  4.         /* OBJ_GetObjectHandle checks if the requested index is defined in the object dictionary */  
[cpp]  view plain  copy
  1. <span style="white-space:pre">  </span>/*OBJ_GetObjectHandle检查是否需要的index是否在对象字典里面定义，并获得它的句柄*/  
  2.         pObjEntry = OBJ_GetObjectHandle( index );  
  3.   
  4.         if ( pObjEntry )  
  5.         {  
[cpp]  view plain  copy
  1. <span style="white-space:pre">  </span>    /*如果在搜寻所有的对象字典之后，得到所需要索引的句柄*/  
  2.             /* transferType contains the information if the SDO Download Request or the SDO Upload Response 
  3.                can be an expedited service (SDO data length <= 4, that means the data is stored in the 
  4.                 SDO-Header completely */  
[cpp]  view plain  copy
  1. <span style="white-space:pre">  </span>    /*transferType包含那些信息，是否SDO 下载请求和SDO 上传响应可以是快速服务类型（SDO数据长度小于等于4个字节，数据可以完全放在SDO-Header里面）*/  
  2.             UINT8 bTransferType = 0;  
  3.             /* pData is the pointer to the received (SDO-Download) or sent (SDO-Upload) SDO data in the mailbox */  
[cpp]  view plain  copy
  1. <span style="white-space:pre">  </span>    /*pData是一个指针指向在邮箱里面，SDO下载和SDO上传的对象字典的数据*/  
  2.             UINT16 MBXMEM * pData = NULL;  
  3. #if SEGMENTED_SDO_SUPPORTED  
  4.             UINT8 segTransfer = 0;  
  5. #endif  
  6.   
  7.             {  
  8.                 dataSize = objLength = OBJ_GetObjectLength( index, subindex, pObjEntry, (UINT8) (sdoHeader & SDOHEADER_COMPLETEACCESS) );  
  9.   
  10.                 if ( command == SDOSERVICE_INITIATEUPLOADREQ )//如果SDO里面的命令是SDO上传请求的话  
  11.                 {  
[cpp]  view plain  copy
  1. <span style="white-space:pre">      </span>/*如果SDO里面的对象字典的长度小于等于MAX_EXPEDITED_DATA和不等于零的时候，则是快速类型的上传模式*/  
  2.                     /* SDO Upload */  
  3.                     if ( mbxSize != EXPEDITED_FRAME_SIZE )  
  4.                         /* a SDO Upload request has always a fixed size (2 Byte CoE-Header plus 8 Byte SDO-Header) */  
  5.                         return MBXERR_INVALIDSIZE;  
  6.                     /* distinguish between expedited and normal upload response within the length of the response data */  
  7.                     if ( (objLength <= MAX_EXPEDITED_DATA) && objLength != 0 )  
  8.                     {  
  9.                         /* Expedited Upload */  
  10.                         bTransferType = 1;  
  11.                         /* pData is the pointer where the object data has to be copied for the response */  
[cpp]  view plain  copy
  1. <span style="white-space:pre">          </span>/*pData是一个指针，它指向的对象字典数据被复制对应的数据作为响应*/  
[cpp]  view plain  copy
  1. pData = ((TINITSDOUPLOADEXPRESMBX MBXMEM *) pSdoInd)->Data;  
  2. /* initialize the 4 data bytes of the SDO upload response because the requested object data 
  3.    could be less than 4 */  
[cpp]  view plain  copy
  1. <span style="white-space:pre">          </span>/*因为请求的对象数据是小于4个字节，初始化4个字节数据给SDO上传响应*/  
  2.                         pData[0] = 0;  
  3.                         pData[1] = 0;  
  4.                     }  
  5.                     else<span style="white-space:pre">  </span>//这个else是对应上面的（(objLength<=MAX_EXPEDITED_DATA)&& objLength !=0） 如果对象字典的长度大于MAX_EXPEDITED_DATA也就是4个字节的时候。则说明上传是分段上传模式或者是正常上传模式。  
  6.                     {  
  7.   
  8.                     dataSize = u16SendMbxSize - MBX_HEADER_SIZE - UPLOAD_NORM_RES_SIZE;  
  9. <span style="white-space:pre">          </span>/*如果对象字典的长度比邮箱对象数据区的长度还要打的时候，说明是要采用分段类型的形式上传数据*/  
  10.                         if ( dataSize < objLength )  
  11.                             /* Segmented Upload */  
  12.                             segTransfer = 1;  
[cpp]  view plain  copy
  1. else  
  2. :pre">          </span>/*否则采用正常上传模式*/  
[cpp]  view plain  copy
  1. /* Normal Upload */  
  2. pData = ((TINITSDOUPLOADNORMRESMBX MBXMEM *) pSdoInd)->Data;  
[cpp]  view plain  copy
  1. <span style="white-space:pre">          </span>    /*pData指向对象字典的数据区地址*/  
  2. #else/*如果从站本身不支持分段上传模式的话，则不需要上面的判断*/  
  3.                         /* Normal Upload */  
  4.                         /* pData is the pointer where the object data has to be copied for the response */  
[cpp]  view plain  copy
  1. <span style="white-space:pre">          </span>/*pData是一个指针，作为响应，指向的地方对象字典的数据应该被拷贝*/  
  2.                         pData = ((TINITSDOUPLOADNORMRESMBX MBXMEM *) pSdoInd)->Data;  
  3. #endif  
  4.                     }  
  5.                 }  
  6.                 else//如果对象字典的命令，不是SDO上传命令的话  
  7.                 {  
  8.                     /* SDO-Download: store if the request is a expedited or normal request 判断是否为快速还是普通请求 */  
  9.                     bTransferType = sdoHeader & SDOHEADER_TRANSFERTYPE;  
  10.                 }  
  11.             }  
  12.   
  13.             if ( command == SDOSERVICE_INITIATEDOWNLOADREQ )//如果SDO的命令是下载请求  
  14.             {  
  15.                 /* SDO Download */  
  16.                 if ( bTransferType )//根据前面判断是否为快速下载请求  
  17.                 {  
  18.                     /* Expedited Download */  
  19.                     if ( mbxSize != EXPEDITED_FRAME_SIZE )  
  20.                         /* an Expedited SDO Download request has always a fixed size (2 Byte CoE-Header plus 8 Byte SDO-Header) */  
  21.                         return MBXERR_INVALIDSIZE;  
  22.                     /* dataSize gets the real size of the downloaded object data (1,2,3 or 4) */  
  23.                     dataSize = MAX_EXPEDITED_DATA - ((sdoHeader & SDOHEADER_DATASETSIZE) >> SDOHEADERSHIFT_DATASETSIZE);  
  24.                     /* pData is the pointer to the downloaded object data */  
[cpp]  view plain  copy
  1. <span style="white-space:pre">      </span>   //pData是一个指针指向SDO的数据区  
  2.                     pData = (UINT16 MBXMEM *) &pSdoInd[1];  
  3.                 }  
  4.                 else//如果不是快速下载请求  
  5.                 {  
  6.                     /* Normal Download */  
  7.                     /* downloadSize gets the real size of the downloaded data */  
  8.                     /* '&' operator was too much */  
  9.   
  10.                     UINT32 downloadSize = ((UINT32)(SWAPWORD(((TINITSDODOWNLOADNORMREQMBX MBXMEM *) pSdoInd)->CompleteSize[1]))<<16) + (SWAPWORD(((TINITSDODOWNLOADNORMREQMBX MBXMEM *) pSdoInd)->CompleteSize[0]));  
  11.   
  12.                     /* HBu 29.03.06: if it is a segmented download the mbxSize has to be the complete mailbox size */  
  13.                     if ( (MBX_HEADER_SIZE+EXPEDITED_FRAME_SIZE+downloadSize) > u16ReceiveMbxSize )//如果它是一个分段下载类型，mbxSize毕业是一个完整的邮箱长度  
  14.                     {  
  15.                         if ( mbxSize != (u16ReceiveMbxSize-MBX_HEADER_SIZE) )  
  16.                             return MBXERR_INVALIDSIZE;  
  17.                     }  
  18.                     else  
  19.                     {  
  20.                         if ( mbxSize != (EXPEDITED_FRAME_SIZE+downloadSize) )  
  21.                             /* the mbxSize and the downloadSize are not consistent (mbxSize = downloadSize + 2 byte CoE-Header + 8 byte SDO Header */  
  22.                             return MBXERR_INVALIDSIZE;  
  23.                     }  
  24.   
  25.                     /* pData is the pointer to the downloaded object data */  
  26.                     pData = (UINT16 MBXMEM *) ((TINITSDODOWNLOADNORMREQMBX MBXMEM *) pSdoInd)->Data;//pData是一个指针指向下载对象的数据区  
  27.                     /* the received dataSize will be checked in the object specific functions called from 
  28.                        OBJ_Write (in objdef.c) */  
  29.                     dataSize = downloadSize;接受的dataSize多大将会被检查在对象特殊的函数，在OBJ_Write（在object.c文件里调用）  
[cpp]  view plain  copy
  1.                     if ( dataSize > (UINT32)(mbxSize - DOWNLOAD_NORM_REQ_SIZE) )//对象字典的长度大于mbxSize-DOWNLOAD_NORM_REQ_SIZE的时候  
  2. #if SEGMENTED_SDO_SUPPORTED  
  3.                         /* Segmented Download */  
  4.                         segTransfer = 1;//采用分段下载的形式  
  5. #else /* SEGMENTED_SDO_SUPPORTED */  
  6.                         abort = ABORTIDX_PARAM_LENGTH_ERROR;  
  7. #endif /* SEGMENTED_SDO_SUPPORTED */  
  8.                 }  
  9.             }  
  10.   
  11.             if ( sdoHeader & SDOHEADER_COMPLETEACCESS )//接下来对sdoHeader的是否完全操作进行判断  
  12. #if COMPLETE_ACCESS_SUPPORTED  
  13.             {  
  14.                 bCompleteAccess = 1;//可以完全操作  
  15.                 // HBu 02.05.06: Complete Access is only supported with subindex 0 and 1  
  16.                 if (subindex > 1)  
  17.                     abort = ABORTIDX_UNSUPPORTED_ACCESS;  
  18.             }  
  19. #else  
  20.                 abort = ABORTIDX_UNSUPPORTED_ACCESS;  
  21. #endif  
  22.   
  23.             if ( abort == 0 )//abort ==0,说明是可以完全操作子索引是0或者1  
  24.             {  
  25. #if SEGMENTED_SDO_SUPPORTED  
  26.                 if ( segTransfer )//如果可以分段传输  
  27.                 {  
  28.                     bSdoSegFollows         = TRUE;  
  29.                     bSdoSegLastToggle     = 1;  
  30. #if COMPLETE_ACCESS_SUPPORTED  
  31.                     bSdoSegAccess             = bCompleteAccess;  
  32. #endif  
  33.                     nSdoSegIndex             = index;  
  34.                     nSdoSegSubindex         = subindex;  
  35.                     pSdoSegObjEntry        = pObjEntry;  
  36.                     if ( command == SDOSERVICE_INITIATEUPLOADREQ )  
  37.                         nSdoSegCompleteSize    = objLength;  
  38.                     else  
  39.                         nSdoSegCompleteSize    = dataSize;  
  40.   
  41.                     if (pSdoSegData != NULL)  
  42.                     {  
  43.                         FREEMEM( (UINT16 VARMEM *) pSdoSegData);  
  44.                         pSdoSegData = NULL;  
  45.                     }  
  46. /*ECATCHANGE_START(V5.01) MBX1*/  
  47.                     pSdoSegData = (UINT16 VARMEM *) ALLOCMEM( ROUNDUPBYTE2WORD(nSdoSegCompleteSize) );  
  48. /*ECATCHANGE_END(V5.01) MBX1*/  
  49.   
  50.                     if ( pSdoSegData == NULL )  
  51.                         abort = ABORTIDX_OUT_OF_MEMORY;  
  52.                     else  
  53.                     {  
  54.                         if ( command == SDOSERVICE_INITIATEUPLOADREQ )  
  55.                         {  
  56.                             /* Segmented Upload */  
  57.                             abort = OBJ_Read( index, subindex, objLength, pObjEntry, (UINT16 MBXMEM *) pSdoSegData, bCompleteAccess );  
[cpp]  view plain  copy
  1. <span style="white-space:pre">          </span>//如果读操作成功的话，则返回0；如果读操作失败的话，则返回0xFF  
  2.                             if ( abort == 0 )  
  3.                             {  
  4.                                 MBXMEMCPY( ((TINITSDOUPLOADNORMRESMBX MBXMEM *) pSdoInd)->Data, pSdoSegData, dataSize );//将读到的pSdoSegData数据拷贝到pSdoInd的数据区。  
  5.                                 nSdoSegService    = SDOSERVICE_UPLOADSEGMENTREQ;  
  6.                             }  
  7. #if SDO_RES_INTERFACE  
  8.                             else if ( abort == ABORTIDX_WORKING )  
  9.                             {  
  10. /* ECATCHANGE_START(V5.01) SDO6*/  
  11.                                 /* the application generates the SDO-Response later on by calling SDOS_SdoRes (only possible if object access function pointer is defined) */  
[cpp]  view plain  copy
  1. //在这种情况应用程序产生一个SDO-Response通过调用函数SDOS_SdoRes（）就是SDO响应程序，当数据对象接入函数已经被定义  
  2.                                 u8PendingSdo = SDO_PENDING_SEG_READ;  
  3.                                 bStoreCompleteAccess = bCompleteAccess;  
  4.                                 u8StoreSubindex = subindex;  
  5.                                 u16StoreIndex = index;  
  6.                                 u32StoreDataSize = objLength;  
  7.                                 pStoreData = pSdoSegData;  
  8.                                 pSdoPendFunc = pObjEntry->Read;//采用虚函数的形式定义数据对象的函数  
  9.   
  10.                                 bSdoInWork = TRUE;  
  11.                                 /* we have to store the buffer and the response header */  
  12.                                 pSdoResStored = pSdoInd;  
  13.   
  14.                                 /*update command field*/  
  15.                                 pSdoResStored->SdoHeader.Sdo[SDOHEADER_COMMANDOFFSET]   &= ~SDOHEADER_COMMANDMASK;  
  16.                                 pSdoResStored->SdoHeader.Sdo[SDOHEADER_COMMANDOFFSET]   |= (sdoHeader & (SDOHEADER_COMPLETEACCESS | SDOHEADER_COMMAND));  
  17.                                 nSdoSegService    = SDOSERVICE_UPLOADSEGMENTREQ;  
  18.                                 return 0;//返回去函数，并且，通过SDOS_SdoRes()来操作数据对象  
  19. /* ECATCHANGE_END(V5.01) SDO6*/  
  20.                             }  
  21. #endif  
  22.                         }  
  23.                         else//如果命令是SDO下载命令，则将pSdoInd->Data里面的数据拷贝到pSdoSegData里面，并且，付对应的SdoSegService和对应的数据长度  
  24.                         {  
  25.                             /* Segmented Download */  
  26.                             MBXMEMCPY( pSdoSegData, ((TINITSDODOWNLOADNORMREQMBX MBXMEM *) pSdoInd)->Data, mbxSize-DOWNLOAD_NORM_REQ_SIZE );  
  27.                             nSdoSegService    = SDOSERVICE_DOWNLOADSEGMENTREQ;  
  28.                             dataSize = (mbxSize-DOWNLOAD_NORM_REQ_SIZE);  
  29.                         }  
  30.   
  31.                         nSdoSegBytesToHandle = dataSize;  
  32.                     }  
  33.                 }  
  34.                 else//接下来的这种情况，考虑不是分段传输的情况  
  35. #endif // SEGMENTED_SDO_SUPPORTED  
  36.                 {  
  37. #if SEGMENTED_SDO_SUPPORTED  
  38. #if SDO_RES_INTERFACE  
  39.                     if ( objLength == 0 )  
  40.                     {  
  41.                         /* the objLength is not known, therefore the variables for a possible segmented transfer 
  42.                             should be initialized */  
  43.                         nSdoSegIndex             = index;  
  44.                         nSdoSegSubindex         = subindex;  
  45.                         pSdoSegObjEntry        = pObjEntry;  
  46.                     }  
  47. #endif // SDO_RES_INTERFACE  
  48. #endif // SEGMENTED_SDO_SUPPORTED  
  49.                     if ( command == SDOSERVICE_INITIATEUPLOADREQ )//如果SDO服务是上传服务  
  50.                     {  
  51.                         /* Expedited or Normal Upload *///已经排除了分段上传，就剩下快速上传和普通上传模式  
  52.                         abort = OBJ_Read( index, subindex, objLength, pObjEntry, pData, bCompleteAccess );  
  53. #if SDO_RES_INTERFACE  
  54.                         if ( abort == ABORTIDX_WORKING )  
  55.                         {  
  56. /* ECATCHANGE_START(V5.01) SDO6*/  
  57.                             /* the application generates the SDO-Response later on by calling SDOS_SdoRes (only possible if object access function pointer is defined) *///同上的分段上传的情况  
  58.                             u8PendingSdo = SDO_PENDING_READ;  
  59.                             bStoreCompleteAccess = bCompleteAccess;  
  60.                             u8StoreSubindex = subindex;  
  61.                             u16StoreIndex = index;  
  62.                             u32StoreDataSize = objLength;  
  63.                             pStoreData = pData;  
  64.                             pSdoPendFunc = pObjEntry->Read;  
  65.   
  66.                             bSdoInWork = TRUE;  
  67.                             /* we have to store the buffer and the response header */  
  68.                             pSdoResStored = pSdoInd;  
  69.                               
  70.                             /*update command field*/  
  71.                             pSdoResStored->SdoHeader.Sdo[SDOHEADER_COMMANDOFFSET] &= ~SDOHEADER_COMMANDMASK;  
  72.                             pSdoResStored->SdoHeader.Sdo[SDOHEADER_COMMANDOFFSET]    |= (sdoHeader & (SDOHEADER_COMPLETEACCESS | SDOHEADER_COMMAND));  
  73.                             return 0;  
  74. /* ECATCHANGE_END(V5.01) SDO6*/  
  75.                         }  
  76. #endif // SDO_RES_INTERFACE  
  77.                     }  
  78.                     else  
  79.                     {  
  80.                         /* Expedited or Normal Download *///快速和普通下载模式  
  81.                         abort = OBJ_Write( index, subindex, dataSize, pObjEntry, pData, bCompleteAccess );  
  82. #if SDO_RES_INTERFACE  
  83.                         if ( abort == ABORTIDX_WORKING )  
  84.                         {  
  85. /* ECATCHANGE_START(V5.01) SDO6*/  
  86.                             /* the application generates the SDO-Response later on by calling SDOS_SdoRes (only possible if object access function pointer is defined) */  
  87.                             u8PendingSdo = SDO_PENDING_WRITE;  
  88.                             bStoreCompleteAccess = bCompleteAccess;  
  89.                             u8StoreSubindex = subindex;  
  90.                             u16StoreIndex = index;  
  91.                             u32StoreDataSize = dataSize;  
  92.                             pStoreData = pData;  
  93.                             pSdoPendFunc = pObjEntry->Write;  
  94.   
  95.                             bSdoInWork = TRUE;  
  96.                             /* we have to store the buffer and the response header */  
  97.                             pSdoResStored = pSdoInd;  
  98.   
  99.                             /*update command field*/  
  100.                             pSdoResStored->SdoHeader.Sdo[SDOHEADER_COMMANDOFFSET] &= ~SDOHEADER_COMMANDMASK;  
  101.                             pSdoResStored->SdoHeader.Sdo[SDOHEADER_COMMANDOFFSET]    |= (sdoHeader & (SDOHEADER_COMPLETEACCESS | SDOHEADER_COMMAND));  
  102.                             return 0;  
  103. /* ECATCHANGE_END(V5.01) SDO6*/  
  104.                         }  
  105. #endif // SDO_RES_INTERFACE  
  106.                     }  
  107.                 } /* else if ( objLength == 0 ) */  
  108.             } /* if ( abort == 0 ) */  
  109.   
  110.         }//endif 获得不到对应的对象字典的句柄  
  111.         else  
  112.         {  
  113.             abort = ABORTIDX_OBJECT_NOT_EXISTING;  
  114.         }  
  115.         break;  
  116.   
  117. #if SEGMENTED_SDO_SUPPORTED  
  118.     case SDOSERVICE_DOWNLOADSEGMENTREQ://当SDOSERVICE_DOWNLOADSEGMENTREQ和SDOSERVICE_UPLOADSEGMENTREQ产生时候一并在下面处理  
  119.     case SDOSERVICE_UPLOADSEGMENTREQ:  
  120.         if ( command == nSdoSegService )  
  121.         {  
  122.             if ( command == SDOSERVICE_DOWNLOADSEGMENTREQ )  
  123.                 abort = SdoDownloadSegmentInd( (TDOWNLOADSDOSEGREQMBX MBXMEM *) pSdoInd );  
[cpp]  view plain  copy
  1. <span style="white-space:pre">      </span>//这个函数将会被调用当下载SDO主站的分段请求服务，如果它是最后一个分段数据的话，将会被写入到对象字典，这个函数自身会做出对象响应  
  2.             else  
  3.                 abort = SdoUploadSegmentInd( (TUPLOADSDOSEGREQMBX MBXMEM *) pSdoInd );  
  4.         }  
  5.         else  
  6.             abort = ABORTIDX_COMMAND_SPECIFIER_UNKNOWN;  
  7.         break;  
  8.   
  9. #endif  
  10.     default:  
  11.         abort = ABORTIDX_COMMAND_SPECIFIER_UNKNOWN;  
  12.         break;  
  13.     }  
  14.   
  15. #if SDO_RES_INTERFACE  
  16. /* ECATCHANGE_START(V5.01) SDO6*/  
  17.     if(abort != ABORTIDX_WORKING)  
  18. /* ECATCHANGE_END(V5.01) SDO6*/  
  19. #endif  
  20.     {  
  21.         /*当SDO响应应该被发送的时候，这个函数将会被调用*/  
  22.         SdoRes(abort, command, (UINT8) (sdoHeader & SDOHEADER_COMPLETEACCESS), (UINT16) dataSize, objLength, pSdoInd);  
  23.     }  
  24.   
  25.     return 0;  
  26. }  
醉枫涟
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
EtherCAT SDO分段下载/上传说明
Terrys0518的专栏
06-10 2790
ETherCAT COE (CANOpen)的 SDO 属于应用层通讯协议，基于同步管理器（SM）的邮箱实现的，主站可以通过SDO实现一下功能。 对应邮箱消息数据格式如下 其中分段下载和分段上传请求和响应较为特殊，ETG1000-4手册上对整个通讯过程讲解不够清晰，下面是我个人的理解。 分段下载的过程 ①. 客户端发送“常规下载请求”，包含数据（写满SM设定缓存区）给服务器 --> 服务器接收到数据后，判断 Complete Size > Si...
SDO处理（二）
tangtang_yue的博客
06-23 1224
原文地址：http://blog.csdn.net/huangxianxinalice/article/details/9324611 [cpp] view plain copy \brief    当SDO响应需要被发送的时候，这个函数将会被调用   [cpp] view plain copy
Ethercat总线学习：CAN、CANopen、EtherCAT、PDO与SDO
最新发布
m0_49968063的博客
05-26 2144
EtherCAT的解决方法就是，所有的节点使用一个数据帧，主站发出数据帧后，所有的从站会在飞行中处理数据，读取自己需要的，塞入自己需要返回的数据，然后继续把数据帧继续向下传输，直到碰到最后一个节点，利用Ethernet的全双工特性再将数据返回给主站。按照官方的一个计算示例，最终的带宽利用率可能不到5%，并且，基于Ethernet的通信协议，例如TCP，会带来额外的带宽开销和延迟，大量的带宽都被无效的数据占用。并且，电机之间的同步不是靠数据帧的到达时间，而是靠分布式时钟的，可以实现纳秒级的同步。
A10调试笔记
wgembed的专栏
04-17 2059
gedit ~/androidCar/lichee/linux-3.0/Makefile ARCH        ?= $(SUBARCH) CROSS_COMPILE    ?= $(CONFIG_CROSS_COMPILE:"%"=%) 修改为： ARCH        ?= arm CROSS_COMPILE    ?= arm-none-linux-gnueabi-
Canopen协议 (2）：（SDO）
墨鸦
08-11 808
SDO的话，本宝宝这边用的是SDO的DOWNLOAD协议，把数据写入到设备中去。因为本宝宝的这个设备的一些数据希望用PDO定时发给我，所以这边需要用SDO把设备的PDO mapping 做掉，这样的话，后面就可以用PDO通信了。 SDO通信主要有2块，“UPLOAD” 和 “DOWNLOAD”协议 从官网资料来看,CIA 301 33页的文档，对这部分有更详细的介绍 1.DOWNLOAD SDO 2.UPLOAD SDO 有了上述的知识，就可以对can总线上的数据进行分析了..
往死里写——SDO处理2-2
烟酒僧的专栏
07-14 1819
\brief    当SDO响应需要被发送的时候，这个函数将会被调用void SdoRes(UINT8 abort, UINT8 command, UINT8 completeAccess, UINT16 dataSize, UINT32 objLength, TINITSDOMBX MBXMEM *pSdoRes) { /* 对于上传分段响应，这个转换位将会被设置 */ if (
COE_Main（）函数
tangtang_yue的博客
06-23 927
原文地址http://blog.csdn.net/huangxianxinalice/article/details/9936181 [cpp] view plain copy /////////////////////////////////////////////////////////////////////////////////////
regs-sdo.rar_sdo
09-21
2. **SDO传输层**：CANopen协议栈的这一层处理SDO的数据传输，包括建立连接、数据分片、错误处理等。regs-sdo.c可能包含了SDO传输过程中的相关函数。 3. **SDO服务器**：每个CANopen设备都包含一个SDO服务器，用于...
shp2sdo20211018.rar
10-18
总的来说，shp2sdo插件是GIS专业人士处理Shapefile数据和Oracle Spatial之间数据交换的重要工具。通过熟练掌握这个工具的使用，可以高效地管理、分析和分享空间数据，进一步提升GIS应用的效率和质量。在实际工作中，...
sdo_drv.rar_sdo
09-24
Samsung Standard Definition Output (SDO) 驱动程序是一个专为三星设备设计的关键组件，它主要负责处理标准清晰度视频输出。在本文中，我们将深入探讨SDO驱动的工作原理、重要性以及与其相关的编程知识。 一、SDO...
commonj.sdo.jar
11-04
**标题：“commonj.sdo.jar”** ...总的来说，"commonj.sdo.jar"是Java开发中的一个重要组件，尤其是对于那些需要处理大量数据和跨服务数据交换的项目。理解和熟练使用SDO能提升开发效率，降低维护成本。
shp2sdo三个版本
10-10
对于GIS（地理信息系统）开发者和分析师来说，shp2sdo是一个非常实用的工具，可以帮助他们快速地将Shapefile数据整合到Oracle数据库中，进而进行更复杂的空间分析任务。 标签中的"shp oracle shp2sdo oracle ...
学习CANopen --- [12] Abort报文
爱就是是恒久忍耐的专栏
01-21 653
使用例子来分析Abort报文
c语言 链表应用实例1
fleetwgx的专栏
07-07 1097
应用背景  canopen 协议栈中 ，对object dictionary 的回调函数， 通过指针函数数组的方式进行保存，但这种保存方式有一个问题 就可能会浪费空间 。所以这里采用链表方式存储回调函数 ，当然 必须额外空间存储链表操作的代码 。工程是在Eclipse IDE for C/C++ Developers平台上 用c语言编写的 ，对于理解c语言指针应用有一定的帮助 。原创文章，不得用于...
CANopen之SDO，PDO
GuoGuoABC
11-22 4043
i ：Index 1400 + n, subindex 01 ，COB_ID（通讯对象的标识符）对于RPDO来说，其通信参数的COB-ID是。
CANOpen服务数据对象报文
Jorry Zhao的专栏
04-19 2677
https://blog.csdn.net/lushoumin/article/details/79668443SDO是服务数据对象接口(ServiceData Object)的缩写，顾名思义提供服务数据的访问接口，所谓服务数据指一些实时性要求不高的数据，一般是指节点配置参数，因此，SDO一般用来配置和获得节点的配置参数，充当OD对外的接口。SDO基于CS模式，所有报文都需要确认。通常从节点作为...
SDO/DAS研究(1): SDO规范
Matt的技术专栏
03-18 2998
          数据对象是SDO框架的核心。数据对象是一个业务对象的一般表达，并且没有和特殊的持久化存储机制绑定。数据图是一个相关数据对象的集合。在SDO1.0里，一个数据图总是被一个DataGraph信封对象所包装，而在SDO.0里，数据对象图可以存在于DataGraph之外。（数据图）Data graph作为两个单词分开使用时，指任何一个数据对象集合；（数据图）DataGraph作为一
emcy协议_CANopen 总线协议报文分析
weixin_35337252的博客
02-23 847
CANPro 协议分析平台中的 CANopen 协议分析插件有两种，一是 Block_CANopen，用于分析支持块传输的 CANopen 协议报文，二是 CANopen，用于分析不支持块传输的CANopen 协议报文。更多CANopen 协议请看之所以作这样的区分，是因为 CANopen 协议中的块传输的报文是上下文相关的，要识别块传输报文需要知道之前传输的报文信息，但是 CANPro 协议分析...
Ethercat解析（九）之过程数据
absinjun的博客
08-12 9473
主站通过过程数据对象（ProcessData Objects (PDOs)）来获取从站的输入输出。 ① 读取：通过SII从eeprom（一般存放的固定的PDOs数据）中读取。 ② 写入：使用COE进行配置PDOs。 应用层可以在周期数据交换中注册一个PDOs条目，所有注册的PDOs条目之和通过逻辑寻址定义了过程数据映像（processdata image）。 通过创建域（Domains）可...
igh sdo 配置
11-05
3. 配置IGH协议和SDO协议的参数：包括通信速率、数据格式、错误处理等。需要根据具体的机器人和控制器型号，按照它们的规格手册进行配置。 4. 进行测试和调试：配置完成后，需要进行测试和调试，确保机器人和控制器...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值