往死里写——SDO处理过程2-1

最新推荐文章于 2023-11-20 15:27:34 发布
最新推荐文章于 2023-11-20 15:27:34 发布
阅读量3.1k 收藏 6
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/huangxianxinalice/article/details/9318957
版权 
UINT8 SDOS_SdoInd(TINITSDOMBX MBXMEM *pSdoInd)
{
    UINT8 abort = 0;
    UINT8 sdoHeader = pSdoInd->SdoHeader.Sdo[SDOHEADER_COMMANDOFFSET] & SDOHEADER_COMMANDMASK;
    /* the SDO-command is in bit 5-7 of the first SDO-Byte */
    UINT8 command = (sdoHeader & SDOHEADER_COMMAND);
    /* mbxSize contains the size of the mailbox (CoE-Header (2 Bytes) + SDO-Header (8 Bytes) + SDO-Data (if the data length is greater than 4)) */
    UINT16 mbxSize = pSdoInd->MbxHeader.Length;
    UINT16 index;
    UINT8 subindex;
    OBJCONST TOBJECT OBJMEM * pObjEntry;
    /* this variable contains the information, if all entries of an object will be read (bCompleteAccess > 0) or a single entry */
    UINT8 bCompleteAccess = 0;
    UINT32 objLength = 0;
    UINT32 dataSize = 0;

#if SDO_RES_INTERFACE
    if ( bSdoInWork )
    {
        /* the last SDO is still in work */
        return MBXERR_SERVICEINWORK;
    }
#endif
/*根据SDO的不同的服务类型，选择想对应的SDO服务*/
    switch (command)
    {
    case SDOSERVICE_INITIATEDOWNLOADREQ:
    case SDOSERVICE_INITIATEUPLOADREQ:
        /* the variable index contains the requested index of the SDO service */
        /*这个变量索引包含需要的SDO服务的索引*/
        index = pSdoInd->SdoHeader.Sdo[SDOHEADER_INDEXHIOFFSET] & SDOHEADER_INDEXHIMASK;
        index <<= 8;
        index += pSdoInd->SdoHeader.Sdo[SDOHEADER_INDEXLOOFFSET] >> SDOHEADER_INDEXLOSHIFT;
        /* the variable subindex contains the requested subindex of the SDO service */
	/*子索引的变量包含需要的SDO服务需要的子索引*/
        subindex    = pSdoInd->SdoHeader.Sdo[SDOHEADER_SUBINDEXOFFSET] >> SDOHEADER_SUBINDEXSHIFT;

        /* OBJ_GetObjectHandle checks if the requested index is defined in the object dictionary */
	/*OBJ_GetObjectHandle检查是否需要的index是否在对象字典里面定义，并获得它的句柄*/
        pObjEntry = OBJ_GetObjectHandle( index );

        if ( pObjEntry )
        {
	    /*如果在搜寻所有的对象字典之后，得到所需要索引的句柄*/
            /* transferType contains the information if the SDO Download Request or the SDO Upload Response
               can be an expedited service (SDO data length <= 4, that means the data is stored in the
                SDO-Header completely */
	    /*transferType包含那些信息，是否SDO 下载请求和SDO 上传响应可以是快速服务类型（SDO数据长度小于等于4个字节，数据可以完全放在SDO-Header里面）*/
            UINT8 bTransferType = 0;
            /* pData is the pointer to the received (SDO-Download) or sent (SDO-Upload) SDO data in the mailbox */
	    /*pData是一个指针指向在邮箱里面，SDO下载和SDO上传的对象字典的数据*/
            UINT16 MBXMEM * pData = NULL;
#if SEGMENTED_SDO_SUPPORTED
            UINT8 segTransfer = 0;
#endif

            {
                dataSize = objLength = OBJ_GetObjectLength( index, subindex, pObjEntry, (UINT8) (sdoHeader & SDOHEADER_COMPLETEACCESS) );

                if ( command == SDOSERVICE_INITIATEUPLOADREQ )//如果SDO里面的命令是SDO上传请求的话
                {
		/*如果SDO里面的对象字典的长度小于等于MAX_EXPEDITED_DATA和不等于零的时候，则是快速类型的上传模式*/
                    /* SDO Upload */
                    if ( mbxSize != EXPEDITED_FRAME_SIZE )
                        /* a SDO Upload request has always a fixed size (2 Byte CoE-Header plus 8 Byte SDO-Header) */
                        return MBXERR_INVALIDSIZE;
                    /* distinguish between expedited and normal upload response within the length of the response data */
                    if ( (objLength <= MAX_EXPEDITED_DATA) && objLength != 0 )
                    {
                        /* Expedited Upload */
                        bTransferType = 1;
                        /* pData is the pointer where the object data has to be copied for the response */
			/*pData是一个指针，它指向的对象字典数据被复制对应的数据作为响应*/
                        pData = ((TINITSDOUPLOADEXPRESMBX MBXMEM *) pSdoInd)->Data;
                        /* initialize the 4 data bytes of the SDO upload response because the requested object data
                           could be less than 4 */
			/*因为请求的对象数据是小于4个字节，初始化4个字节数据给SDO上传响应*/
                        pData[0] = 0;
                        pData[1] = 0;
                    }
                    else	//这个else是对应上面的（(objLength<=MAX_EXPEDITED_DATA)&& objLength !=0） 如果对象字典的长度大于MAX_EXPEDITED_DATA也就是4个字节的时候。则说明上传是分段上传模式或者是正常上传模式。
                    {

                    dataSize = u16SendMbxSize - MBX_HEADER_SIZE - UPLOAD_NORM_RES_SIZE;
			/*如果对象字典的长度比邮箱对象数据区的长度还要打的时候，说明是要采用分段类型的形式上传数据*/
                        if ( dataSize < objLength )
                            /* Segmented Upload */
                            segTransfer = 1;
                        else
			/*否则采用正常上传模式*/
                            /* Normal Upload */
                            pData = ((TINITSDOUPLOADNORMRESMBX MBXMEM *) pSdoInd)->Data;
			    /*pData指向对象字典的数据区地址*/
#else/*如果从站本身不支持分段上传模式的话，则不需要上面的判断*/
                        /* Normal Upload */
                        /* pData is the pointer where the object data has to be copied for the response */
			/*pData是一个指针，作为响应，指向的地方对象字典的数据应该被拷贝*/
                        pData = ((TINITSDOUPLOADNORMRESMBX MBXMEM *) pSdoInd)->Data;
#endif
                    }
                }
                else//如果对象字典的命令，不是SDO上传命令的话
                {
                    /* SDO-Download: store if the request is a expedited or normal request 判断是否为快速还是普通请求 */
                    bTransferType = sdoHeader & SDOHEADER_TRANSFERTYPE;
                }
            }

            if ( command == SDOSERVICE_INITIATEDOWNLOADREQ )//如果SDO的命令是下载请求
            {
                /* SDO Download */
                if ( bTransferType )//根据前面判断是否为快速下载请求
                {
                    /* Expedited Download */
                    if ( mbxSize != EXPEDITED_FRAME_SIZE )
                        /* an Expedited SDO Download request has always a fixed size (2 Byte CoE-Header plus 8 Byte SDO-Header) */
                        return MBXERR_INVALIDSIZE;
                    /* dataSize gets the real size of the downloaded object data (1,2,3 or 4) */
                    dataSize = MAX_EXPEDITED_DATA - ((sdoHeader & SDOHEADER_DATASETSIZE) >> SDOHEADERSHIFT_DATASETSIZE);
                    /* pData is the pointer to the downloaded object data */
		   //pData是一个指针指向SDO的数据区
                    pData = (UINT16 MBXMEM *) &pSdoInd[1];
                }
                else//如果不是快速下载请求
                {
                    /* Normal Download */
                    /* downloadSize gets the real size of the downloaded data */
                    /* '&' operator was too much */

                    UINT32 downloadSize = ((UINT32)(SWAPWORD(((TINITSDODOWNLOADNORMREQMBX MBXMEM *) pSdoInd)->CompleteSize[1]))<<16) + (SWAPWORD(((TINITSDODOWNLOADNORMREQMBX MBXMEM *) pSdoInd)->CompleteSize[0]));

                    /* HBu 29.03.06: if it is a segmented download the mbxSize has to be the complete mailbox size */
                    if ( (MBX_HEADER_SIZE+EXPEDITED_FRAME_SIZE+downloadSize) > u16ReceiveMbxSize )//如果它是一个分段下载类型，mbxSize毕业是一个完整的邮箱长度
                    {
                        if ( mbxSize != (u16ReceiveMbxSize-MBX_HEADER_SIZE) )
                            return MBXERR_INVALIDSIZE;
                    }
                    else
                    {
                        if ( mbxSize != (EXPEDITED_FRAME_SIZE+downloadSize) )
                            /* the mbxSize and the downloadSize are not consistent (mbxSize = downloadSize + 2 byte CoE-Header + 8 byte SDO Header */
                            return MBXERR_INVALIDSIZE;
                    }

                    /* pData is the pointer to the downloaded object data */
                    pData = (UINT16 MBXMEM *) ((TINITSDODOWNLOADNORMREQMBX MBXMEM *) pSdoInd)->Data;//pData是一个指针指向下载对象的数据区
                    /* the received dataSize will be checked in the object specific functions called from
                       OBJ_Write (in objdef.c) */
                    dataSize = downloadSize;接受的dataSize多大将会被检查在对象特殊的函数，在OBJ_Write（在object.c文件里调用）
                    if ( dataSize > (UINT32)(mbxSize - DOWNLOAD_NORM_REQ_SIZE) )//对象字典的长度大于mbxSize-DOWNLOAD_NORM_REQ_SIZE的时候
#if SEGMENTED_SDO_SUPPORTED
                        /* Segmented Download */
                        segTransfer = 1;//采用分段下载的形式
#else /* SEGMENTED_SDO_SUPPORTED */
                        abort = ABORTIDX_PARAM_LENGTH_ERROR;
#endif /* SEGMENTED_SDO_SUPPORTED */
                }
            }

            if ( sdoHeader & SDOHEADER_COMPLETEACCESS )//接下来对sdoHeader的是否完全操作进行判断
#if COMPLETE_ACCESS_SUPPORTED
            {
                bCompleteAccess = 1;//可以完全操作
                // HBu 02.05.06: Complete Access is only supported with subindex 0 and 1
                if (subindex > 1)
                    abort = ABORTIDX_UNSUPPORTED_ACCESS;
            }
#else
                abort = ABORTIDX_UNSUPPORTED_ACCESS;
#endif

            if ( abort == 0 )//abort ==0,说明是可以完全操作子索引是0或者1
            {
#if SEGMENTED_SDO_SUPPORTED
                if ( segTransfer )//如果可以分段传输
                {
                    bSdoSegFollows         = TRUE;
                    bSdoSegLastToggle     = 1;
#if COMPLETE_ACCESS_SUPPORTED
                    bSdoSegAccess             = bCompleteAccess;
#endif
                    nSdoSegIndex             = index;
                    nSdoSegSubindex         = subindex;
                    pSdoSegObjEntry        = pObjEntry;
                    if ( command == SDOSERVICE_INITIATEUPLOADREQ )
                        nSdoSegCompleteSize    = objLength;
                    else
                        nSdoSegCompleteSize    = dataSize;

                    if (pSdoSegData != NULL)
                    {
                        FREEMEM( (UINT16 VARMEM *) pSdoSegData);
                        pSdoSegData = NULL;
                    }
/*ECATCHANGE_START(V5.01) MBX1*/
                    pSdoSegData = (UINT16 VARMEM *) ALLOCMEM( ROUNDUPBYTE2WORD(nSdoSegCompleteSize) );
/*ECATCHANGE_END(V5.01) MBX1*/

                    if ( pSdoSegData == NULL )
                        abort = ABORTIDX_OUT_OF_MEMORY;
                    else
                    {
                        if ( command == SDOSERVICE_INITIATEUPLOADREQ )
                        {
                            /* Segmented Upload */
                            abort = OBJ_Read( index, subindex, objLength, pObjEntry, (UINT16 MBXMEM *) pSdoSegData, bCompleteAccess );
			//如果读操作成功的话，则返回0；如果读操作失败的话，则返回0xFF
                            if ( abort == 0 )
                            {
                                MBXMEMCPY( ((TINITSDOUPLOADNORMRESMBX MBXMEM *) pSdoInd)->Data, pSdoSegData, dataSize );//将读到的pSdoSegData数据拷贝到pSdoInd的数据区。
                                nSdoSegService    = SDOSERVICE_UPLOADSEGMENTREQ;
                            }
#if SDO_RES_INTERFACE
                            else if ( abort == ABORTIDX_WORKING )
                            {
/* ECATCHANGE_START(V5.01) SDO6*/
                                /* the application generates the SDO-Response later on by calling SDOS_SdoRes (only possible if object access function pointer is defined) */
//在这种情况应用程序产生一个SDO-Response通过调用函数SDOS_SdoRes（）就是SDO响应程序，当数据对象接入函数已经被定义
                                u8PendingSdo = SDO_PENDING_SEG_READ;
                                bStoreCompleteAccess = bCompleteAccess;
                                u8StoreSubindex = subindex;
                                u16StoreIndex = index;
                                u32StoreDataSize = objLength;
                                pStoreData = pSdoSegData;
                                pSdoPendFunc = pObjEntry->Read;//采用虚函数的形式定义数据对象的函数

                                bSdoInWork = TRUE;
                                /* we have to store the buffer and the response header */
                                pSdoResStored = pSdoInd;

                                /*update command field*/
                                pSdoResStored->SdoHeader.Sdo[SDOHEADER_COMMANDOFFSET]   &= ~SDOHEADER_COMMANDMASK;
                                pSdoResStored->SdoHeader.Sdo[SDOHEADER_COMMANDOFFSET]   |= (sdoHeader & (SDOHEADER_COMPLETEACCESS | SDOHEADER_COMMAND));
                                nSdoSegService    = SDOSERVICE_UPLOADSEGMENTREQ;
                                return 0;//返回去函数，并且，通过SDOS_SdoRes()来操作数据对象
/* ECATCHANGE_END(V5.01) SDO6*/
                            }
#endif
                        }
                        else//如果命令是SDO下载命令，则将pSdoInd->Data里面的数据拷贝到pSdoSegData里面，并且，付对应的SdoSegService和对应的数据长度
                        {
                            /* Segmented Download */
                            MBXMEMCPY( pSdoSegData, ((TINITSDODOWNLOADNORMREQMBX MBXMEM *) pSdoInd)->Data, mbxSize-DOWNLOAD_NORM_REQ_SIZE );
                            nSdoSegService    = SDOSERVICE_DOWNLOADSEGMENTREQ;
                            dataSize = (mbxSize-DOWNLOAD_NORM_REQ_SIZE);
                        }

                        nSdoSegBytesToHandle = dataSize;
                    }
                }
                else//接下来的这种情况，考虑不是分段传输的情况
#endif // SEGMENTED_SDO_SUPPORTED
                {
#if SEGMENTED_SDO_SUPPORTED
#if SDO_RES_INTERFACE
                    if ( objLength == 0 )
                    {
                        /* the objLength is not known, therefore the variables for a possible segmented transfer
                            should be initialized */
                        nSdoSegIndex             = index;
                        nSdoSegSubindex         = subindex;
                        pSdoSegObjEntry        = pObjEntry;
                    }
#endif // SDO_RES_INTERFACE
#endif // SEGMENTED_SDO_SUPPORTED
                    if ( command == SDOSERVICE_INITIATEUPLOADREQ )//如果SDO服务是上传服务
                    {
                        /* Expedited or Normal Upload *///已经排除了分段上传，就剩下快速上传和普通上传模式
                        abort = OBJ_Read( index, subindex, objLength, pObjEntry, pData, bCompleteAccess );
#if SDO_RES_INTERFACE
                        if ( abort == ABORTIDX_WORKING )
                        {
/* ECATCHANGE_START(V5.01) SDO6*/
                            /* the application generates the SDO-Response later on by calling SDOS_SdoRes (only possible if object access function pointer is defined) *///同上的分段上传的情况
                            u8PendingSdo = SDO_PENDING_READ;
                            bStoreCompleteAccess = bCompleteAccess;
                            u8StoreSubindex = subindex;
                            u16StoreIndex = index;
                            u32StoreDataSize = objLength;
                            pStoreData = pData;
                            pSdoPendFunc = pObjEntry->Read;

                            bSdoInWork = TRUE;
                            /* we have to store the buffer and the response header */
                            pSdoResStored = pSdoInd;
                            
                            /*update command field*/
                            pSdoResStored->SdoHeader.Sdo[SDOHEADER_COMMANDOFFSET] &= ~SDOHEADER_COMMANDMASK;
                            pSdoResStored->SdoHeader.Sdo[SDOHEADER_COMMANDOFFSET]    |= (sdoHeader & (SDOHEADER_COMPLETEACCESS | SDOHEADER_COMMAND));
                            return 0;
/* ECATCHANGE_END(V5.01) SDO6*/
                        }
#endif // SDO_RES_INTERFACE
                    }
                    else
                    {
                        /* Expedited or Normal Download *///快速和普通下载模式
                        abort = OBJ_Write( index, subindex, dataSize, pObjEntry, pData, bCompleteAccess );
#if SDO_RES_INTERFACE
                        if ( abort == ABORTIDX_WORKING )
                        {
/* ECATCHANGE_START(V5.01) SDO6*/
                            /* the application generates the SDO-Response later on by calling SDOS_SdoRes (only possible if object access function pointer is defined) */
                            u8PendingSdo = SDO_PENDING_WRITE;
                            bStoreCompleteAccess = bCompleteAccess;
                            u8StoreSubindex = subindex;
                            u16StoreIndex = index;
                            u32StoreDataSize = dataSize;
                            pStoreData = pData;
                            pSdoPendFunc = pObjEntry->Write;

                            bSdoInWork = TRUE;
                            /* we have to store the buffer and the response header */
                            pSdoResStored = pSdoInd;

                            /*update command field*/
                            pSdoResStored->SdoHeader.Sdo[SDOHEADER_COMMANDOFFSET] &= ~SDOHEADER_COMMANDMASK;
                            pSdoResStored->SdoHeader.Sdo[SDOHEADER_COMMANDOFFSET]    |= (sdoHeader & (SDOHEADER_COMPLETEACCESS | SDOHEADER_COMMAND));
                            return 0;
/* ECATCHANGE_END(V5.01) SDO6*/
                        }
#endif // SDO_RES_INTERFACE
                    }
                } /* else if ( objLength == 0 ) */
            } /* if ( abort == 0 ) */

        }//endif 获得不到对应的对象字典的句柄
        else
        {
            abort = ABORTIDX_OBJECT_NOT_EXISTING;
        }
        break;

#if SEGMENTED_SDO_SUPPORTED
    case SDOSERVICE_DOWNLOADSEGMENTREQ://当SDOSERVICE_DOWNLOADSEGMENTREQ和SDOSERVICE_UPLOADSEGMENTREQ产生时候一并在下面处理
    case SDOSERVICE_UPLOADSEGMENTREQ:
        if ( command == nSdoSegService )
        {
            if ( command == SDOSERVICE_DOWNLOADSEGMENTREQ )
                abort = SdoDownloadSegmentInd( (TDOWNLOADSDOSEGREQMBX MBXMEM *) pSdoInd );
		//这个函数将会被调用当下载SDO主站的分段请求服务，如果它是最后一个分段数据的话，将会被写入到对象字典，这个函数自身会做出对象响应
            else
                abort = SdoUploadSegmentInd( (TUPLOADSDOSEGREQMBX MBXMEM *) pSdoInd );
        }
        else
            abort = ABORTIDX_COMMAND_SPECIFIER_UNKNOWN;
        break;

#endif
    default:
        abort = ABORTIDX_COMMAND_SPECIFIER_UNKNOWN;
        break;
    }

#if SDO_RES_INTERFACE
/* ECATCHANGE_START(V5.01) SDO6*/
    if(abort != ABORTIDX_WORKING)
/* ECATCHANGE_END(V5.01) SDO6*/
#endif
    {
        /*当SDO响应应该被发送的时候，这个函数将会被调用*/
        SdoRes(abort, command, (UINT8) (sdoHeader & SDOHEADER_COMPLETEACCESS), (UINT16) dataSize, objLength, pSdoInd);
    }

    return 0;
}

Huang_X_X
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
c语言 链表应用实例1
fleetwgx的专栏
07-07 1084
应用背景  canopen 协议栈中 ，对object dictionary 的回调函数， 通过指针函数数组的方式进行保存，但这种保存方式有一个问题 就可能会浪费空间 。所以这里采用链表方式存储回调函数 ，当然 必须额外空间存储链表操作的代码 。工程是在Eclipse IDE for C/C++ Developers平台上 用c语言编写的 ，对于理解c语言指针应用有一定的帮助 。原创文章，不得用于...
SDO-7072WT-db
04-02
SDO-7072WT-db.rar 介绍了关于SDO-7072WT-db的详细说明，提供其它知识的技术资料的下载。
往死里写——SDOS_SdoInfoInd
烟酒僧的专栏
07-21 1753
///////////////////////////////////////////////////////////////////////////////////////// /** \param pSdoInfoInd 指向接收邮箱的数据，数据从主站读到的. \return 指示，如果一个当操作的时候，一个错误发生 ( good = 0 ). \brief
倍福提供的EtherCAT从站代码包解析
Studying……
12-26 4496
用倍福的从站配置工具得到的源代码有以下 1 主要代码  ecatappl.c  ecatappl.h    Ecatappl:  EtherCAT从站应用层接口，整个协议栈运行的核心模块， EtherCAT从站状态机和过程数据接口。Main()函数的定义，输入输出程数据 对象的映射处理，ESC与处理器本地内存的输入输出过程数据的交换等;  ecatslv.c  ecatslv.h
Ethercat解析（十一）之分布时钟
absinjun的博客
08-14 1万+
驱动代码中，同步时钟涉及到如下几个概念： ⑴ 本地时钟：每一个支持DC的从站都有一个纳秒级分辨率的本地时钟寄存器。 每次从机上电，则寄存器从0开始计时，这就意味着不同的从机因为上电开机的时间不同而本地时钟也会有差异，所以需要对从机的本地时钟对比参考时钟进行偏移补偿。再者，从机的时钟一般由时钟单元为参考，所以每个从机的时钟频率也会有极小的误差，但是由于这种极小的误差在长时间的工作中会累积，所...
SDO处理过程（一）
tangtang_yue的博客
06-23 2928
/* the last SDO is still in work */           return MBXERR_SERVICEINWORK;       }   #endif   /*根据SDO的不同的服务类型，选择想对应的SDO服务*/       switch (command)       {       case SDOSERVICE_INITIATEDOWNLOAD
基于canfestival协议栈的canopen程序。 包含主从机，主站实现pdo收发、sdo收发、状态管理、心跳，从站实现pdo收发、sdo收
m0_74196786的博客
10-10 831
包含主从机，主站实现pdo收发、sdo收发、状态管理、心跳，从站实现pdo收发、sdo收发、紧急报文发送，只提供代码，基于canfestival协议栈的canopen程序。常用于一主多从控制、控制伺服电机。
SDO处理（二）
tangtang_yue的博客
06-23 1209
原文地址：http://blog.csdn.net/huangxianxinalice/article/details/9324611 [cpp] view plain copy \brief    当SDO响应需要被发送的时候，这个函数将会被调用   [cpp] view plain copy
mailbox 编程_往死里写——从站mailbox实现 | 学步园
weixin_39861920的博客
02-01 526
void ECAT_Main(void)函数里面首先检查是否有服务储存在mailbox里面。调用MBX_Main()；(This function is called cyclically to check if a received Mailbox service was stored？)在MBX_Main(void)里面获得mailbox的接受队列里面的邮箱赋予pMbx。通过函数Mailbox...
COE_Main（）函数
tangtang_yue的博客
06-23 888
原文地址http://blog.csdn.net/huangxianxinalice/article/details/9936181 [cpp] view plain copy /////////////////////////////////////////////////////////////////////////////////////
获取Object对象的length
weixin_30827565的博客
11-10 408
所有JS程序猿（甚至不止JS）都知道，数组（Array）是有length的，通过length属性，可以很方便的获取数组的长度。可以说，只要使用到了数组，就必会使用到其length属性。 而Object对象是没有length属性或方法的，它确实没有存在的必要，因为人们只会在乎该对象能提供什么样的方法，而没有必要知道它到底有多少方法。的确，这确实不是一个普遍性的需求， 因此ECMAScript中也...
shp2sdo-158114.txt
02-23
下载地址详见txt(点击立即下载)
shp2sdo-shp文件转oracle完整版本。
10-25
这个转换可以使用oracle提供的一个现成的工具shp2sdo（很小），可以到官方网站去找（不过可能不是很好找，需要的可以留下邮箱），下载后把此文件复制到PATH变量包含的目录下，如我的oracle客户端安装后自动注册的...
shp2sdo最完整-绝对完美运行 .zip
05-09
这个转换可以使用oracle提供的一个现成的工具shp2sdo（很小），下载后把此文件复制到PATH变量包含的目录下，如我的oracle客户端安装后自动注册的环境变量是 path C:\Oracle\product\10.1.0\Client_1\bin;，我们可以...
SDO2SHP-开源
04-27
该程序用于在Oracle数据库和ESRI shape文件之间下载和上传空间和/或字母数字数据。
EtherCAT从站状态机分析：PREOP to SAFEOP过程
热门推荐
JavanChen的博客
11-15 1万+
///////////////////////////////////////////////////////////////////////////////////////// /** \return AL Status Code (see ecatslv.h ALSTATUSCODE_....) \brief This function is called in case o...
ehtercat sdo服务
老鹰不捉小鸡
01-15 365
https://www.cnblogs.com/salvare/p/11163657.html
canopenkeil工程，包括主站，从站。入门用，带jiaocheng。sdo 、各种pdo、nmt
最新发布
DegOWZQ的博客
11-20 181
在操作教程中，我们将从资料筛选、代码修改、实验操作和报文分析等角度来讲解CanOpen主从站的开发过程，包括SDO、PDO、NMT、心跳等多个方面。本文通过介绍Keil工程的应用和提供详细的操作教程，旨在帮助初学者更好地理解CanOpen的概念和协议，从而顺利进行程序开发和调试。同时，我们也希望通过本文的分享，能够为CanOpen技术的应用和推广做出一定的贡献。canopen概念多，抽象，初学者只看资料，很容易被劝退，本人从资料筛选，代码修改，实验操作，报文分析解释等角度，写了详细的操作教程，帮助初学者。
SOEM 源码解析 ecx_SDOread
qq_25047389的博客
10-08 482
【代码】SOEM 源码解析 ecx_SDOread。
EtherCAT——PDO/SDO
10-07
PDO（过程数据对象）是用来传输周期性的数据的，它由三个数据缓冲区组成，类似于一个FIFO。从站写入第一个缓冲区，主站从第三个缓冲区读取数据。需要注意的是，第二个缓冲区是不可操作的。从站发送PDO和接收PDO分别采用两个独立的数据缓冲区。同步管理器负责控制缓冲区，每个同步管理器只负责一种功能，例如同步管理器2负责发送PDO，同步管理器3负责接收PDO。 SDO（服务数据对象）是用来发送非周期性的数据的，它只有一个数据缓冲区。邮箱通信方式采用握手机制，确保主从之间的数据交互不丢失。与PDO不同，SDO由于采用FIFO机制，可能会出现新值覆盖旧值或旧值被多次读取的情况。SDO也由同步管理器进行管理，发送和接收邮箱各自独立控制，例如同步管理器0控制发送邮箱，同步管理器1控制接收邮箱。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值