小白study
小白study

CANOpen服务数据对象报文

https://blog.csdn.net/lushoumin/article/details/79668443

 SDO是服务数据对象接口(ServiceData Object)的缩写，顾名思义提供服务数据的访问接口，所谓服务数据指一些实时性要求不高的数据，一般是指节点配置参数，因此，SDO一般用来配置和获得节点的配置参数，充当OD对外的接口。

SDO基于CS模式，所有报文都需要确认。通常从节点作为SDO服务器，主节点作为客户端。客户端通过索引和子索引，访问服务器上的任意对象字典，SDO的上传与下载，是从server的角度去理解的，上传：client对server的OD进行读操作；下载：client对server的OD进行写操作。

传送机制有两种：域传送和块传送。

SDO报文格式如下：

CANOpen服务数据对象报文_第1张图片



SDO域传输一共实现了5个请求/应答协议：启动域下载，启动域上传，域分段下载，域分段上传，域传送中止。

SDO命令字包含如下信息：该报文是上传还是下载，该报文是请求还是应答，该报文是分段还是加速，CAN帧数据字节长度，后续分段的触发位。

CANOpen服务数据对象报文_第2张图片

CANOpen服务数据对象报文_第3张图片

块传输这里不进行详细讨论，只给出块下载流程：
 1.客户端：初始化传输通道
           发送块下载初始化指令，包括索引、子索引、字节数


 2.服务器：初始化传输通道
           发送块下载初始化响应，包括索引、子索引、一次传输块数量


 3.客户端：复位传输超时定时器
           发送多个数据包块下载，包括是否最后一块、序列号、数据


 4.服务器：复位传输超时定时器
           将数据拷贝到传输通道
           发送数据包块下载响应，包括序列号、一次传输块数量


 5.客户端：如果没有下载完，重复步骤3、4
           如果下载完，发送块下载结束指令，包括最后一块补零数


 6.服务器：发送块下载结束响应
           将数据拷贝到字典中
           复位传输通道


 7.客户端：停止传输超时定时器
           设置传输通道为完成状态
           调用传输完成回调函数



[cpp]  view plain  copy
  1. #include   
  2. #include "canfestival.h"  
  3. #include "sysdep.h"  
  4.   
  5. #define NO_INLINE  
  6.   
  7. #ifdef NO_INLINE  
  8. #define INLINE  
  9. #else  
  10. #define INLINE inline  
  11. #endif  
  12.   
  13. /* 通过节点号查找客户端号 */  
  14. UNS8 GetSDOClientFromNodeId(CO_Data *d, UNS8 nodeId);  
  15.   
  16. /* 写服务器字典 */  
  17. INLINE UNS8 _writeNetworkDict(CO_Data *d, UNS8 nodeId, UNS16 index, UNS8 subIndex,   
  18.                                                             UNS32 count, UNS8 dataType, void *data,   
  19.                                                             SDOCallback_t Callback, UNS8 endianize, UNS8 useBlockMode);  
  20.   
  21. /* 读服务器字典 */  
  22. INLINE UNS8 _readNetworkDict(CO_Data *d, UNS8 nodeId, UNS16 index, UNS8 subIndex, UNS8 dataType, SDOCallback_t Callback, UNS8 useBlockMode);  
  23.   
  24. #define getSDOcs(byte) (byte >> 5)  
  25. #define getSDOn2(byte) ((byte >> 2) & 3)  
  26. #define getSDOn3(byte) ((byte >> 1) & 7)  
  27. #define getSDOe(byte) ((byte >> 1) & 1)  
  28. #define getSDOs(byte) (byte & 1)  
  29. #define getSDOc(byte) (byte & 1)  
  30. #define getSDOt(byte) ((byte >> 4) & 1)  
  31. #define getSDOindex(byte1, byte2) (((UNS16)byte2 << 8) | ((UNS16)byte1))  
  32. #define getSDOsubIndex(byte3) (byte3)  
  33. #define getSDOblockSC(byte) (byte & 3)  
  34.   
  35.   
  36. /* sdo传输超时回调函数 */  
  37. void SDOTimeoutAlarm(CO_Data *d, UNS32 id)  
  38. {  
  39.     UNS16 offset;  
  40.     UNS8 nodeId;  
  41.       
  42.     /* 第一个sdo客户端在字典中的下标 */  
  43.     offset = d->firstIndex->SDO_CLT;  
  44.     if((offset == 0) || ((offset + d->transfers[id].CliServNbr) > d->lastIndex->SDO_CLT))   
  45.     {  
  46.         return;  
  47.     }  
  48.       
  49.     /* 从字典中取出服务器节点id */  
  50.     nodeId = (UNS8)*((UNS32*)d->objdict[offset + d->transfers[id].CliServNbr].pSubindex[3].pObject);  
  51.       
  52.     MSG_ERR(0x1A01, "SDO timeout. SDO response not received.", 0);  
  53.     MSG_WAR(0x2A02, "server node id : ", nodeId);  
  54.     MSG_WAR(0x2A02, "         index : ", d->transfers[id].index);  
  55.     MSG_WAR(0x2A02, "      subIndex : ", d->transfers[id].subIndex);  
  56.       
  57.     /* 传输通道超时定时器置空 */  
  58.     d->transfers[id].timer = TIMER_NONE;  
  59.     /* 传输通道状态设置为内部中止 */  
  60.     d->transfers[id].state = SDO_ABORTED_INTERNAL;  
  61.     /* 向主站发送中止报文 */  
  62.     sendSDOabort(d, d->transfers[id].whoami, d->transfers[id].CliServNbr, d->transfers[id].index, d->transfers[id].subIndex, SDOABT_TIMED_OUT);  
  63.     /* 错误码设置为超时 */  
  64.     d->transfers[id].abortCode = SDOABT_TIMED_OUT;  
  65.       
  66.     /* 如果传输通道超时，则调用回调函数 */  
  67.     if(d->transfers[id].Callback)  
  68.         (*d->transfers[id].Callback)(d, nodeId);  
  69.   
  70.     /* 复位sdo传输通道 */  
  71.     if(d->transfers[id].abortCode == SDOABT_TIMED_OUT)   
  72.         resetSDOline(d, (UNS8)id);  
  73. }  
  74.   
  75. /* 停止sdo超时定时器 */  
  76. #define StopSDO_TIMER(id) \  
  77.     MSG_WAR(0x3A05, "StopSDO_TIMER for line : ", line);\  
  78. d->transfers[id].timer = DelAlarm(d->transfers[id].timer);  
  79.   
  80. /* 启动sdo超时定时器 */  
  81. #define StartSDO_TIMER(id) \  
  82.     MSG_WAR(0x3A06, "StartSDO_TIMER for line : ", line);\  
  83.     d->transfers[id].timer = SetAlarm(d, id, &SDOTimeoutAlarm,MS_TO_TIMEVAL(SDO_TIMEOUT_MS),0);  
  84.   
  85. /* 重启sdo超时定时器 */  
  86. #define RestartSDO_TIMER(id) \  
  87.     MSG_WAR(0x3A07, "restartSDO_TIMER for line : ", line);\  
  88. if(d->transfers[id].timer != TIMER_NONE) { StopSDO_TIMER(id) StartSDO_TIMER(id) }  
  89.   
  90. /* 复位所有sdo传输通道 */  
  91. void resetSDO(CO_Data *d)  
  92. {  
  93.     UNS8 j;  
  94.   
  95.     /* 复位所有sdo传输通道 */  
  96.     for(j = 0; j < SDO_MAX_SIMULTANEOUS_TRANSFERS; j++)  
  97.     {  
  98.         resetSDOline(d, j);  
  99.     }  
  100. }  
  101.   
  102. /* 将数据从传输通道缓冲区拷贝到字典中 */  
  103. UNS32 SDOlineToObjdict(CO_Data *d, UNS8 line)  
  104. {  
  105.     UNS32 size;  
  106.     UNS32 errorCode;  
  107.       
  108.     MSG_WAR(0x3A08, "Enter in SDOlineToObjdict ", line);  
  109.       
  110.     /* 确定该传输通道传输了多少字节 */  
  111.     if(d->transfers[line].count == 0)  
  112.     {  
  113.         d->transfers[line].count = d->transfers[line].offset;  
  114.     }  
  115.     size = d->transfers[line].count;  
  116.   
  117.     /* 将数据拷贝到字典中 */  
  118. #ifdef SDO_DYNAMIC_BUFFER_ALLOCATION  
  119.     if(size > SDO_MAX_LENGTH_TRANSFER)  
  120.     {  
  121.         errorCode = setODentry(d, d->transfers[line].index, d->transfers[line].subIndex,   
  122.                                                      (void *)d->transfers[line].dynamicData, &size, 1);  
  123.     }  
  124.     else  
  125.     {  
  126.         errorCode = setODentry(d, d->transfers[line].index, d->transfers[line].subIndex,  
  127.                                                      (void *)d->transfers[line].data, &size, 1);  
  128.     }  
  129. #else  
  130.     errorCode = setODentry(d, d->transfers[line].index, d->transfers[line].subIndex,  
  131.                                                  (void *)d->transfers[line].data, &size, 1);  
  132. #endif  
  133.     if(errorCode != OD_SUCCESSFUL)  
  134.         return errorCode;  
  135.   
  136.     MSG_WAR(0x3A08, "exit of SDOlineToObjdict ", line);  
  137.   
  138.     return 0;  
  139.   
  140. }  
  141.   
  142. /* 将数据从字典中拷贝到传输通道缓冲区 */  
  143. UNS32 objdictToSDOline(CO_Data *d, UNS8 line)  
  144. {  
  145.     UNS32 size = SDO_MAX_LENGTH_TRANSFER;  
  146.     UNS8 dataType;  
  147.     UNS32 errorCode;  
  148.   
  149.     MSG_WAR(0x3A05, "objdict->line index : ", d->transfers[line].index);  
  150.     MSG_WAR(0x3A06, "  subIndex : ", d->transfers[line].subIndex);  
  151.   
  152.     /* 支持动态内存分配 */  
  153. #ifdef SDO_DYNAMIC_BUFFER_ALLOCATION  
  154.     /* 从字典中将数据拷贝出来 */  
  155.     errorCode = getODentry(d, d->transfers[line].index, d->transfers[line].subIndex,   
  156.                                                  (void *)d->transfers[line].data, &size, &dataType, 1);  
  157.     /* 如果内存不够拷贝 */  
  158.     if(errorCode == SDOABT_OUT_OF_MEMORY)   
  159.     {  
  160.         if(size <= SDO_DYNAMIC_BUFFER_ALLOCATION_SIZE)   
  161.         {  
  162.             /* 动态分配内存 */  
  163.             d->transfers[line].dynamicData = (UNS8 *)malloc(size * sizeof(UNS8));  
  164.             if(d->transfers[line].dynamicData != NULL)   
  165.             {  
  166.                 d->transfers[line].dynamicDataSize = size;  
  167.                 /* 从字典中将数据拷贝出来 */  
  168.                 errorCode = getODentry(d, d->transfers[line].index, d->transfers[line].subIndex, (void *)d->transfers[line].dynamicData,  
  169.                                                              &d->transfers[line].dynamicDataSize, &dataType, 1);  
  170.             }  
  171.         }  
  172.     }  
  173. #else  
  174.     /* 从字典中将数据拷贝出来 */  
  175.     errorCode = getODentry(d, d->transfers[line].index, d->transfers[line].subIndex,   
  176.                                                  (void *)d->transfers[line].data, &size, &dataType, 1);  
  177. #endif  
  178.     if(errorCode != OD_SUCCESSFUL)  
  179.         return errorCode;  
  180.   
  181.     d->transfers[line].count = size;  
  182.     d->transfers[line].offset = 0;  
  183.   
  184.     return 0;  
  185. }  
  186.   
  187. /* 将数据从传输通道缓冲区拷贝出来 */  
  188. UNS8 lineToSDO(CO_Data *d, UNS8 line, UNS32 nbBytes, UNS8 *data)   
  189. {  
  190.     UNS8 i;  
  191.     UNS32 offset;  
  192.   
  193. #ifndef SDO_DYNAMIC_BUFFER_ALLOCATION  
  194.     /* 如果不支持内存动态分配，并且字节数大于静态缓冲区，则报错 */  
  195.     if((d->transfers[line].offset + nbBytes) > SDO_MAX_LENGTH_TRANSFER)   
  196.     {  
  197.         MSG_ERR(0x1A10,"SDO Size of data too large. Exceed SDO_MAX_LENGTH_TRANSFER", nbBytes);  
  198.         return 0xFF;  
  199.     }  
  200. #endif  
  201.   
  202.     /* 如果传输通道字节数大于配置的大小 */  
  203.     if((d->transfers[line].offset + nbBytes) > d->transfers[line].count)   
  204.     {  
  205.         MSG_ERR(0x1A11,"SDO Size of data too large. Exceed count", nbBytes);  
  206.         return 0xFF;  
  207.     }  
  208.     offset = d->transfers[line].offset;  
  209. #ifdef SDO_DYNAMIC_BUFFER_ALLOCATION  
  210.     /* 如果说sdo传输通道字节数小于静态缓冲区 */  
  211.     if(d->transfers[line].count <= SDO_MAX_LENGTH_TRANSFER)  
  212.     {  
  213.         /* 将数据从静态缓冲区拷贝出来 */  
  214.         for(i = 0; i < nbBytes; i++)  
  215.             *(data + i) = d->transfers[line].data[offset + i];  
  216.     }  
  217.     /* 如果说sdo传输通道字节数大于静态缓冲区 */  
  218.     else  
  219.     {  
  220.         if(d->transfers[line].dynamicData == NULL)  
  221.         {  
  222.             MSG_ERR(0x1A11,"SDO's dynamic buffer not allocated. Line", line);  
  223.             return 0xFF;  
  224.         }  
  225.           
  226.         /* 将数据从动态缓冲区拷贝出来 */  
  227.         for(i = 0; i < nbBytes; i++)  
  228.             *(data + i) = d->transfers[line].dynamicData[offset + i];  
  229.     }  
  230. #else  
  231.     /* 将数据拷贝出来 */  
  232.     for(i = 0; i < nbBytes; i++)  
  233.         *(data + i) = d->transfers[line].data[offset + i];  
  234. #endif  
  235.     /* 偏移量增大 */  
  236.     d->transfers[line].offset = d->transfers[line].offset + nbBytes;  
  237.       
  238.     return 0;  
  239. }  
  240.   
  241. /* 将数据拷贝到传输通道缓冲区 */  
  242. UNS8 SDOtoLine(CO_Data *d, UNS8 line, UNS32 nbBytes, UNS8 *data)  
  243. {  
  244.     UNS8 i;  
  245.     UNS32 offset;  
  246.   
  247. #ifndef SDO_DYNAMIC_BUFFER_ALLOCATION  
  248.     /* 不允许动态分配时数据量不能大于缓冲区 */  
  249.     if((d->transfers[line].offset + nbBytes) > SDO_MAX_LENGTH_TRANSFER)   
  250.     {  
  251.         MSG_ERR(0x1A15,"SDO Size of data too large. Exceed SDO_MAX_LENGTH_TRANSFER", nbBytes);  
  252.         return 0xFF;  
  253.     }  
  254. #endif  
  255.   
  256.     /* 缓冲区偏移量 */  
  257.     offset = d->transfers[line].offset;  
  258.       
  259. #ifdef SDO_DYNAMIC_BUFFER_ALLOCATION  
  260.     {  
  261.         UNS8 *lineData = d->transfers[line].data;  
  262.           
  263.         /* 当数据量大于缓冲区时 */  
  264.         if((d->transfers[line].offset + nbBytes) > SDO_MAX_LENGTH_TRANSFER)   
  265.         {  
  266.             /* 如果还没有动态分配内存 */  
  267.             if(d->transfers[line].dynamicData == NULL)   
  268.             {  
  269.                 /* 动态分配内存 */  
  270.                 d->transfers[line].dynamicData = (UNS8 *)malloc(SDO_DYNAMIC_BUFFER_ALLOCATION_SIZE);  
  271.                 d->transfers[line].dynamicDataSize = SDO_DYNAMIC_BUFFER_ALLOCATION_SIZE;  
  272.                 if(d->transfers[line].dynamicData == NULL)   
  273.                 {  
  274.                     MSG_ERR(0x1A15,"SDO allocating dynamic buffer failed, size", SDO_DYNAMIC_BUFFER_ALLOCATION_SIZE);  
  275.                     return 0xFF;  
  276.                 }  
  277.                   
  278.                 /* 将静态缓冲区数据拷贝到动态内存区 */  
  279.                 memcpy(d->transfers[line].dynamicData, d->transfers[line].data, offset);  
  280.             }  
  281.             /* 如果已经动态分配内存，则要重新分配 */  
  282.             else if((d->transfers[line].offset + nbBytes) > d->transfers[line].dynamicDataSize)  
  283.             {  
  284.                 UNS8 *newDynamicBuffer = (UNS8*)realloc(d->transfers[line].dynamicData, d->transfers[line].dynamicDataSize + SDO_DYNAMIC_BUFFER_ALLOCATION_SIZE);  
  285.                 if(newDynamicBuffer == NULL)   
  286.                 {  
  287.                     MSG_ERR(0x1A15,"SDO reallocating dynamic buffer failed, size", d->transfers[line].dynamicDataSize + SDO_DYNAMIC_BUFFER_ALLOCATION_SIZE);  
  288.                     return 0xFF;  
  289.                 }  
  290.                 d->transfers[line].dynamicData = newDynamicBuffer;  
  291.                 d->transfers[line].dynamicDataSize += SDO_DYNAMIC_BUFFER_ALLOCATION_SIZE;  
  292.             }  
  293.             lineData = d->transfers[line].dynamicData;  
  294.         }  
  295.   
  296.         /* 将数据拷贝到缓冲区 */  
  297.         for(i = 0; i < nbBytes; i++)  
  298.         {  
  299.             lineData[offset + i] = *(data + i);  
  300.       
  301.         }  
  302.     }  
  303. #else  
  304.     /* 将数据拷贝到缓冲区 */  
  305.     for (i = 0; i < nbBytes; i++)  
  306.         d->transfers[line].data[offset + i] = *(data + i);  
  307. #endif  
  308.   
  309.     /* 缓冲区偏移量增加 */  
  310.     d->transfers[line].offset = d->transfers[line].offset + nbBytes;  
  311.       
  312.     return 0;  
  313. }  
  314.   
  315. /* sdo传输通道失败 */  
  316. UNS8 failedSDO(CO_Data *d, UNS8 CliServNbr, UNS8 whoami, UNS16 index, UNS8 subIndex, UNS32 abortCode)  
  317. {  
  318.     UNS8 err;  
  319.     UNS8 line;  
  320.       
  321.     /* 通过客户端/服务器号获取sdo传输通道号 */  
  322.     err = getSDOlineOnUse(d, CliServNbr, whoami, &line);  
  323.     if(!err)  
  324.     {  
  325.         MSG_WAR(0x3A20, "FailedSDO : line found : ", line);  
  326.     }  
  327.       
  328.     /* 如果自身是服务器，直接复位传输通道 */  
  329.     if((!err) && (whoami == SDO_SERVER))   
  330.     {  
  331.         resetSDOline(d, line);  
  332.         MSG_WAR(0x3A21, "FailedSDO : line released : ", line);  
  333.     }  
  334.     /* 如果自身是客户端，则停止sdo传输超时定时器并将状态置为中止并设置错误码 */  
  335.     if((!err) && (whoami == SDO_CLIENT))   
  336.     {  
  337.         StopSDO_TIMER(line);  
  338.         d->transfers[line].state = SDO_ABORTED_INTERNAL;  
  339.         d->transfers[line].abortCode = abortCode;  
  340.     }  
  341.       
  342.     MSG_WAR(0x3A22, "Sending SDO abort ", 0);  
  343.       
  344.     /* 发送sdo中止报文 */  
  345.     err = sendSDOabort(d, whoami, CliServNbr, index, subIndex, abortCode);  
  346.     if(err)   
  347.     {  
  348.         MSG_WAR(0x3A23, "Unable to send the SDO abort", 0);  
  349.         return 0xFF;  
  350.     }  
  351.   
  352.     return 0;  
  353. }  
  354.   
  355. /* 复位sdo通道 */  
  356. void resetSDOline(CO_Data *d, UNS8 line)  
  357. {  
  358.     UNS32 i;  
  359.       
  360.     MSG_WAR(0x3A25, "reset SDO line nb : ", line);  
  361.       
  362.     /* 初始化sdo通道 */  
  363.     initSDOline(d, line, 0, 0, 0, SDO_RESET);  
  364.       
  365.     /* 将sdo传输通道缓冲区清空 */  
  366.     for(i = 0; i < SDO_MAX_LENGTH_TRANSFER; i++)  
  367.         d->transfers[line].data[i] = 0;  
  368.       
  369.     /* 传输通道归属(服务器/客户端)清空 */  
  370.     d->transfers[line].whoami = 0;  
  371.       
  372.     /* 传输通道错误码清空 */  
  373.     d->transfers[line].abortCode = 0;  
  374. }  
  375.   
  376. /* 初始化sdo传输通道 */  
  377. UNS8 initSDOline(CO_Data *d, UNS8 line, UNS8 CliServNbr, UNS16 index, UNS8 subIndex, UNS8 state)  
  378. {  
  379.     MSG_WAR(0x3A25, "init SDO line nb : ", line);  
  380.       
  381.     /* 判断是否该SDO传输通道在域下载/域上传/块下载/块上传过程中 */  
  382.     if(state == SDO_DOWNLOAD_IN_PROGRESS || state == SDO_UPLOAD_IN_PROGRESS ||   
  383.          state == SDO_BLOCK_DOWNLOAD_IN_PROGRESS || state == SDO_BLOCK_UPLOAD_IN_PROGRESS)  
  384.     {  
  385.         /* 开启sdo定时器，通讯超时做相应处理 */  
  386.         StartSDO_TIMER(line)  
  387.     }  
  388.     /* 不在传输过程中，关闭定时器 */  
  389.     else  
  390.     {  
  391.         StopSDO_TIMER(line)  
  392.     }  
  393.   
  394.     /* 初始化客户端/服务器号 */  
  395.     d->transfers[line].CliServNbr = CliServNbr;  
  396.     /* 初始化对象索引 */  
  397.     d->transfers[line].index = index;  
  398.     /* 初始化对象子索引 */  
  399.     d->transfers[line].subIndex = subIndex;  
  400.     /* 初始化传输通道状态 */  
  401.     d->transfers[line].state = state;  
  402.     d->transfers[line].toggle = 0;  
  403.     /* 初始化字节数 */  
  404.     d->transfers[line].count = 0;  
  405.     d->transfers[line].offset = 0;  
  406.     d->transfers[line].peerCRCsupport = 0;  
  407.     d->transfers[line].blksize = 0;  
  408.     d->transfers[line].ackseq = 0;  
  409.     d->transfers[line].objsize = 0;  
  410.     d->transfers[line].lastblockoffset = 0;  
  411.     d->transfers[line].seqno = 0;  
  412.     d->transfers[line].endfield = 0;  
  413.     /* 初始化块传输接收状态 */  
  414.     d->transfers[line].rxstep = RXSTEP_INIT;  
  415.     d->transfers[line].dataType = 0;  
  416.     /* 超时回调函数 */  
  417.     d->transfers[line].Callback = NULL;  
  418. #ifdef SDO_DYNAMIC_BUFFER_ALLOCATION  
  419.     free(d->transfers[line].dynamicData);  
  420.     d->transfers[line].dynamicData = 0;  
  421.     d->transfers[line].dynamicDataSize = 0;  
  422. #endif  
  423.     return 0;  
  424. }  
  425.   
  426. /* 获取空闲的sdo传输通道 */  
  427. UNS8 getSDOfreeLine(CO_Data *d, UNS8 whoami, UNS8 *line)  
  428. {  
  429.     UNS8 i;  
  430.   
  431.     /* 遍历所有传输通道，查找空闲的传输通道 */  
  432.     for(i = 0; i < SDO_MAX_SIMULTANEOUS_TRANSFERS; i++)  
  433.     {  
  434.         if(d->transfers[i].state == SDO_RESET)   
  435.         {  
  436.             *line = i;  
  437.             d->transfers[i].whoami = whoami;  
  438.             return 0;  
  439.         }  
  440.     }  
  441.       
  442.     MSG_ERR(0x1A25, "Too many SDO in progress. Aborted.", i);  
  443.   
  444.     return 0xFF;  
  445. }  
  446.   
  447. /* 通过客户端/服务器号获取sdo传输通道号 */  
  448. UNS8 getSDOlineOnUse(CO_Data *d, UNS8 CliServNbr, UNS8 whoami, UNS8 *line)  
  449. {  
  450.     UNS8 i;  
  451.   
  452.     /* 遍历所有sdo传输通道 */  
  453.     for(i = 0; i < SDO_MAX_SIMULTANEOUS_TRANSFERS; i++)  
  454.     {  
  455.         /* 如果该通道处于正常状态并且客户端/服务器号匹配，则说明找到了该通道 */  
  456.         if((d->transfers[i].state != SDO_RESET) &&  
  457.              (d->transfers[i].state != SDO_ABORTED_INTERNAL) &&  
  458.              (d->transfers[i].CliServNbr == CliServNbr) &&  
  459.              (d->transfers[i].whoami == whoami))   
  460.         {  
  461.             /* 获取该通道号 */  
  462.             if(line)  
  463.             {                 
  464.                 *line = i;  
  465.             }  
  466.               
  467.             return 0;  
  468.         }  
  469.     }  
  470.   
  471.     return 0xFF;  
  472. }  
  473.   
  474. /* 通过客户端/服务器号获取sdo传输通道号 */  
  475. UNS8 getSDOlineToClose(CO_Data *d, UNS8 CliServNbr, UNS8 whoami, UNS8 *line)  
  476. {  
  477.     UNS8 i;  
  478.   
  479.     for(i = 0; i < SDO_MAX_SIMULTANEOUS_TRANSFERS; i++)  
  480.     {  
  481.         if((d->transfers[i].state != SDO_RESET) &&  
  482.              (d->transfers[i].CliServNbr == CliServNbr) &&  
  483.              (d->transfers[i].whoami == whoami))   
  484.         {  
  485.             if(line)   
  486.                 *line = i;  
  487.               
  488.             return 0;  
  489.         }  
  490.     }  
  491.       
  492.     return 0xFF;  
  493. }  
  494.   
  495. /* 关闭sdo传输通道 */  
  496. UNS8 closeSDOtransfer(CO_Data *d, UNS8 nodeId, UNS8 whoami)  
  497. {  
  498.     UNS8 err;  
  499.     UNS8 line;  
  500.     UNS8 CliNbr;  
  501.       
  502.     /* 通过节点号查找客户端号 */  
  503.     CliNbr = GetSDOClientFromNodeId(d, nodeId);  
  504.     if(CliNbr >= 0xFE)  
  505.         return SDO_ABORTED_INTERNAL;  
  506.       
  507.     /* 通过客户端/服务器号获取sdo传输通道号 */  
  508.     err = getSDOlineToClose(d, CliNbr, whoami, &line);  
  509.     if(err)   
  510.     {  
  511.         MSG_WAR(0x2A30, "No SDO communication to close", 0);  
  512.         return 0xFF;  
  513.     }  
  514.   
  515.     /* 复位sdo通道 */  
  516.     resetSDOline(d, line);  
  517.       
  518.     return 0;  
  519. }  
  520.   
  521. /* 获取传输通道剩余字节数 */  
  522. UNS8 getSDOlineRestBytes(CO_Data *d, UNS8 line, UNS32 *nbBytes)  
  523. {  
  524.     if(d->transfers[line].count == 0)  
  525.         *nbBytes = 0;  
  526.     else  
  527.         *nbBytes = d->transfers[line].count - d->transfers[line].offset;  
  528.     return 0;  
  529. }  
  530.   
  531. /* sdo传输通道剩余字节数 */  
  532. UNS8 setSDOlineRestBytes(CO_Data *d, UNS8 line, UNS32 nbBytes)  
  533. {  
  534. #ifndef SDO_DYNAMIC_BUFFER_ALLOCATION  
  535.     if(nbBytes > SDO_MAX_LENGTH_TRANSFER)   
  536.     {  
  537.         MSG_ERR(0x1A35,"SDO Size of data too large. Exceed SDO_MAX_LENGTH_TRANSFER", nbBytes);  
  538.         return 0xFF;  
  539.     }  
  540. #endif  
  541.     d->transfers[line].count = nbBytes;  
  542.   
  543.     return 0;  
  544. }  
  545.   
  546. /* 发送sdo报文 */  
  547. UNS8 sendSDO(CO_Data *d, UNS8 whoami, UNS8 CliServNbr, UNS8 *pData)  
  548. {  
  549.     UNS16 offset;  
  550.     UNS8 i;  
  551.     Message m;  
  552.   
  553.     MSG_WAR(0x3A38, "sendSDO",0);  
  554.   
  555.     /* 运行态或预运行态才可以使用sdo报文 */  
  556.     if(!((d->nodeState == Operational) || (d->nodeState == Pre_operational)))   
  557.     {  
  558.         MSG_WAR(0x2A39, "unable to send the SDO (not in op or pre-op mode", d->nodeState);  
  559.         return 0xFF;  
  560.     }  
  561.   
  562.     /* 服务器端发送sdo报文 */  
  563.     if(whoami == SDO_SERVER)      
  564.     {  
  565.         /* 取出sdo服务器端的发送cob_id */  
  566.         offset = d->firstIndex->SDO_SVR;  
  567.         if((offset == 0) || ((offset + CliServNbr) > d->lastIndex->SDO_SVR))   
  568.         {  
  569.             MSG_ERR(0x1A42, "SendSDO : SDO server not found", 0);  
  570.             return 0xFF;  
  571.         }  
  572.         m.cob_id = (UNS16)*((UNS32*)d->objdict[offset + CliServNbr].pSubindex[2].pObject);  
  573.         MSG_WAR(0x3A41, "I am server Tx cobId : ", m.cob_id);  
  574.     }  
  575.     /* 客户端发送sdo报文 */  
  576.     else   
  577.     {  
  578.         /* 取出sdo客户端发送cob_id */  
  579.         offset = d->firstIndex->SDO_CLT;  
  580.         if((offset == 0) || ((offset+CliServNbr) > d->lastIndex->SDO_CLT))   
  581.         {  
  582.             MSG_ERR(0x1A42, "SendSDO : SDO client not found", 0);  
  583.             return 0xFF;  
  584.         }  
  585.         m.cob_id = (UNS16)*((UNS32*)d->objdict[offset + CliServNbr].pSubindex[1].pObject);  
  586.         MSG_WAR(0x3A41, "I am client Tx cobId : ", m.cob_id);  
  587.     }  
  588.     /* 数据帧 */  
  589.     m.rtr = NOT_A_REQUEST;  
  590.     /* sdo报文固定8字节 */  
  591.     m.len = 8;  
  592.     /* 数据 */  
  593.     for(i = 0; i < 8; i++)   
  594.     {  
  595.         m.data[i] =  pData[i];  
  596.     }  
  597.       
  598.     /* 发送报文 */  
  599.     return canSend(d->canHandle,&m);  
  600. }  
  601.   
  602. /* 发送sdo中止报文 */  
  603. UNS8 sendSDOabort(CO_Data* d, UNS8 whoami, UNS8 CliServNbr, UNS16 index, UNS8 subIndex, UNS32 abortCode)  
  604. {  
  605.     UNS8 data[8];  
  606.     UNS8 ret;  
  607.   
  608.     MSG_WAR(0x2A50,"Sending SDO abort ", abortCode);  
  609.   
  610.     data[0] = 0x80;  
  611.     data[1] = index & 0xFF;  
  612.     data[2] = (index >> 8) & 0xFF;  
  613.     data[3] = subIndex;  
  614.     data[4] = (UNS8)(abortCode & 0xFF);  
  615.     data[5] = (UNS8)((abortCode >> 8) & 0xFF);  
  616.     data[6] = (UNS8)((abortCode >> 16) & 0xFF);  
  617.     data[7] = (UNS8)((abortCode >> 24) & 0xFF);  
  618.   
  619.     /* 发送sdo报文 */  
  620.     ret = sendSDO(d, whoami, CliServNbr, data);  
  621.   
  622.     return ret;  
  623. }  
  624.   
  625. /* 处理sdo报文 */  
  626. UNS8 proceedSDO(CO_Data *d, Message *m)  
  627. {  
  628.     UNS8 err;  
  629.     UNS8 cs;  
  630.     UNS8 line;  
  631.     UNS32 nbBytes;  
  632.     UNS8 nodeId = 0;  
  633.     UNS8 CliServNbr;  
  634.     UNS8 whoami = SDO_UNKNOWN;  
  635.     UNS32 errorCode;  
  636.     UNS8 data[8];  
  637.     UNS16 index;  
  638.     UNS8 subIndex;  
  639.     UNS32 abortCode;  
  640.     UNS32 i;  
  641.     UNS8    j;  
  642.     UNS32 *pCobId = NULL;  
  643.     UNS16 offset;  
  644.     UNS16 lastIndex;  
  645.     UNS8 SubCommand;  
  646.   UNS8 SeqNo;  
  647.   UNS8 AckSeq;  
  648.     UNS8 NbBytesNoData;  
  649.   
  650.     MSG_WAR(0x3A60, "proceedSDO ", 0);  
  651.   
  652.     whoami = SDO_UNKNOWN;  
  653.       
  654.     /* 第一个sdo服务器在字典中的下标 */  
  655.     offset = d->firstIndex->SDO_SVR;  
  656.     /* 最后一个sdo服务器在字典中的下标 */  
  657.     lastIndex = d->lastIndex->SDO_SVR;  
  658.       
  659.     j = 0;  
  660.       
  661.     /* 如果字典中配置了sdo服务器 */  
  662.     if(offset)   
  663.     {  
  664.         /* 遍历所有sdo服务器 */  
  665.         while(offset <= lastIndex)   
  666.         {  
  667.             /* 服务器端子索引不能低于1个 */  
  668.             if(d->objdict[offset].bSubCount <= 1)   
  669.             {  
  670.                 MSG_ERR(0x1A61, "Subindex 1  not found at index ", 0x1200 + j);  
  671.                 return 0xFF;  
  672.             }  
  673.               
  674.             /* 取出服务器端的接收CobId */  
  675.             pCobId = (UNS32*)d->objdict[offset].pSubindex[1].pObject;  
  676.             /* 如果和接收到的报文匹配 */  
  677.             if(*pCobId == UNS16_LE(m->cob_id))   
  678.             {  
  679.                 /* 说明自己是服务器 */  
  680.                 whoami = SDO_SERVER;  
  681.                 MSG_WAR(0x3A62, "proceedSDO. I am server. index : ", 0x1200 + j);  
  682.                 /* 客户端/服务器号 */  
  683.                 CliServNbr = j;  
  684.                 break;  
  685.             }  
  686.             j++;  
  687.             offset++;  
  688.         }  
  689.     }  
  690.       
  691.     /* 如果不是服务器，判断自己是不是客户端 */  
  692.     if(whoami == SDO_UNKNOWN)   
  693.     {  
  694.         /* 第一个客户端在字典中的下标 */  
  695.         offset = d->firstIndex->SDO_CLT;  
  696.         /* 最后一个客户端在字典中的下标 */  
  697.         lastIndex = d->lastIndex->SDO_CLT;  
  698.           
  699.         j = 0;  
  700.           
  701.         /* 如果配置了客户端 */  
  702.         if(offset)   
  703.         {  
  704.             /* 遍历所有sdo客户端 */  
  705.             while(offset <= lastIndex)   
  706.             {  
  707.                 /* 子索引不可以低于3个 */  
  708.                 if(d->objdict[offset].bSubCount <= 3)   
  709.                 {  
  710.                     MSG_ERR(0x1A63, "Subindex 3  not found at index ", 0x1280 + j);  
  711.                     return 0xFF;  
  712.                 }  
  713.                 /* 取出客户端的接收CobId */  
  714.                 pCobId = (UNS32*)d->objdict[offset].pSubindex[2].pObject;  
  715.                 /* 如果和接收到的报文匹配 */  
  716.                 if(*pCobId == UNS16_LE(m->cob_id))   
  717.                 {  
  718.                     /* 自己为客户端 */  
  719.                     whoami = SDO_CLIENT;  
  720.                       
  721.                     MSG_WAR(0x3A64, "proceedSDO. I am client index : ", 0x1280 + j);  
  722.                       
  723.                     /* 服务器/客户端号 */  
  724.                     CliServNbr = j;  
  725.                       
  726.                     /* 服务器端的节点号 */  
  727.                     nodeId = *((UNS8*) d->objdict[offset].pSubindex[3].pObject);  
  728.                     break;  
  729.                 }  
  730.                 j++;  
  731.                 offset++;  
  732.             }  
  733.         }  
  734.     }  
  735.       
  736.     /* 如果没有配置服务器，也没有配置客户端，则不用处理该保文 */  
  737.     if(whoami == SDO_UNKNOWN)   
  738.     {  
  739.         return 0xFF;  
  740.     }  
  741.   
  742.     /* SDO报文一定是8字节 */  
  743.     if((*m).len != 8)   
  744.     {  
  745.         MSG_ERR(0x1A67, "Error size SDO", 0);  
  746.         failedSDO(d, CliServNbr, whoami, 0, 0, SDOABT_GENERAL_ERROR);  
  747.         return 0xFF;  
  748.     }  
  749.   
  750.     if(whoami == SDO_CLIENT)   
  751.     {  
  752.         MSG_WAR(0x3A68, "I am CLIENT number ", CliServNbr);  
  753.     }  
  754.     else   
  755.     {  
  756.         MSG_WAR(0x3A69, "I am SERVER number ", CliServNbr);  
  757.     }  
  758.   
  759.     /* 通服务器/客户端号获取通道号 */  
  760.     err = getSDOlineOnUse(d, CliServNbr, whoami, &line);  
  761.   
  762.     cs = 0xFF;   
  763.   if(!err)   
  764.     {  
  765.         /* 客户端->服务器：块下载过程中 服务器->客户端：上传过程中 */  
  766.         if(((whoami == SDO_SERVER) && (d->transfers[line].state == SDO_BLOCK_DOWNLOAD_IN_PROGRESS)) ||  
  767.              ((whoami == SDO_CLIENT) && (d->transfers[line].state == SDO_BLOCK_UPLOAD_IN_PROGRESS)))   
  768.         {  
  769.             if(m->data[0] == 0x80)  
  770.                 cs = 4;  
  771.             else  
  772.                 cs = 6;  
  773.         }  
  774.     }  
  775.     if(cs == 0xFF)  
  776.     {  
  777.         cs = getSDOcs(m->data[0]);  
  778.     }  
  779.       
  780.     /* 判断指令 */  
  781.     switch(cs)   
  782.     {  
  783.         /* 客户端->服务器:域分段下载/服务器->客户端:域分段上传 */  
  784.         case 0:  
  785.             /* 客户端->服务器的域分段下载 */  
  786.             if(whoami == SDO_SERVER)   
  787.             {  
  788.                 /* 验证传输通道是否在域分段下载中 */  
  789.                 if(!err)  
  790.                 {  
  791.                     err = d->transfers[line].state != SDO_DOWNLOAD_IN_PROGRESS;  
  792.                 }  
  793.                 if(err)   
  794.                 {  
  795.                     MSG_ERR(0x1A70, "SDO error : Received download segment for unstarted trans. index 0x1200 + ", CliServNbr);  
  796.                     failedSDO(d, CliServNbr, whoami, 0, 0, SDOABT_LOCAL_CTRL_ERROR);  
  797.                     return 0xFF;  
  798.                 }  
  799.                 /* 重启传输通道超时定时器 */  
  800.                 RestartSDO_TIMER(line)  
  801.                   
  802.                 MSG_WAR(0x3A71, "Received SDO download segment defined at index 0x1200 + ", CliServNbr);  
  803.                   
  804.                 /* 取出索引号 */  
  805.                 index = d->transfers[line].index;  
  806.                 /* 取出子索引号 */  
  807.                 subIndex = d->transfers[line].subIndex;  
  808.                   
  809.                 /* 校验触发位是否同步 */  
  810.                 if(d->transfers[line].toggle != getSDOt(m->data[0]))   
  811.                 {  
  812.                     MSG_ERR(0x1A72, "SDO error : Toggle error : ", getSDOt(m->data[0]));  
  813.                     failedSDO(d, CliServNbr, whoami, index, subIndex, SDOABT_TOGGLE_NOT_ALTERNED);  
  814.                     return 0xFF;  
  815.                 }  
  816.                   
  817.                 /* 取出字节数 */  
  818.                 nbBytes = 7 - getSDOn3(m->data[0]);  
  819.                 /* 将数据从sdo数据包中拷贝到传输通道缓冲区 */  
  820.                 err = SDOtoLine(d, line, nbBytes, (*m).data + 1);  
  821.                 if(err)  
  822.                 {  
  823.                     failedSDO(d, CliServNbr, whoami, index, subIndex, SDOABT_GENERAL_ERROR);  
  824.                     return 0xFF;  
  825.                 }  
  826.                   
  827.                 /* 构建响应包 */  
  828.                 data[0] = (1 << 5) | (d->transfers[line].toggle << 4);  
  829.                 for(i = 1 ; i < 8 ; i++)  
  830.                 {  
  831.                     data[i] = 0;  
  832.                 }  
  833.                 MSG_WAR(0x3A73, "SDO. Send response to download request defined at index 0x1200 + ", CliServNbr);  
  834.                   
  835.                 /* 发送响应包 */  
  836.                 sendSDO(d, whoami, CliServNbr, data);  
  837.                   
  838.                 /* 触发位取反 */  
  839.                 d->transfers[line].toggle = !d->transfers[line].toggle & 1;  
  840.                 /* 检查该段是否是最后一段 */  
  841.                 if(getSDOc(m->data[0]))   
  842.                 {  
  843.                     /* 将数据从sdo传输通道缓冲区拷贝到字典中 */  
  844.                     errorCode = SDOlineToObjdict(d, line);  
  845.                     if(errorCode)   
  846.                     {  
  847.                         MSG_ERR(0x1A54, "SDO error : Unable to copy the data in the object dictionary", 0);  
  848.                         /* sdo传输失败 */  
  849.                         failedSDO(d, CliServNbr, whoami, index, subIndex, errorCode);  
  850.                         return 0xFF;  
  851.                     }  
  852.                     /* 复位sdo传输通道 */  
  853.                     resetSDOline(d, line);  
  854.                     MSG_WAR(0x3A74, "SDO. End of download defined at index 0x1200 + ", CliServNbr);  
  855.                 }  
  856.             }  
  857.             /* 服务器->客户端:域分段上传 */  
  858.             else   
  859.             {  
  860.                 /* 验证传输通道是否在域分段上传中 */  
  861.                 if(!err)  
  862.                 {  
  863.                     err = d->transfers[line].state != SDO_UPLOAD_IN_PROGRESS;  
  864.                 }  
  865.                 if(err)   
  866.                 {  
  867.                     MSG_ERR(0x1A75, "SDO error : Received segment response for unknown trans. from nodeId", nodeId);  
  868.                     failedSDO(d, CliServNbr, whoami, 0, 0, SDOABT_LOCAL_CTRL_ERROR);  
  869.                       
  870.                     return 0xFF;  
  871.                 }  
  872.                 /* 重启传输通道超时定时器 */  
  873.                 RestartSDO_TIMER(line)  
  874.                   
  875.                 /* 取出索引号 */  
  876.                 index = d->transfers[line].index;  
  877.                 /* 取出子索引号 */  
  878.                 subIndex = d->transfers[line].subIndex;  
  879.                   
  880.                 /* 校验触发位是否同步 */  
  881.                 if(d->transfers[line].toggle != getSDOt(m->data[0]))   
  882.                 {  
  883.                     MSG_ERR(0x1A76, "SDO error : Received segment response Toggle error. from nodeId", nodeId);  
  884.                     failedSDO(d, CliServNbr, whoami, index, subIndex, SDOABT_TOGGLE_NOT_ALTERNED);  
  885.                     return 0xFF;  
  886.                 }  
  887.                 /* 取出字节数 */  
  888.                 nbBytes = 7 - getSDOn3(m->data[0]);  
  889.                 /* 将数据从sdo数据包中拷贝到传输通道缓冲区 */  
  890.                 err = SDOtoLine(d, line, nbBytes, (*m).data + 1);  
  891.                 if(err)   
  892.                 {  
  893.                     failedSDO(d, CliServNbr, whoami, index, subIndex, SDOABT_GENERAL_ERROR);  
  894.                     return 0xFF;  
  895.                 }  
  896.                 /* 触发位取反 */  
  897.                 d->transfers[line].toggle = ! d->transfers[line].toggle & 1;  
  898.                 /* 检查该段是否是最后一段 */  
  899.                 if(getSDOc(m->data[0]))   
  900.                 {  
  901.                     /* 停止超时定时器 */  
  902.                     StopSDO_TIMER(line)  
  903.                     /* 传输完成 */  
  904.                     d->transfers[line].state = SDO_FINISHED;  
  905.                     /* 传输完成回调函数 */  
  906.                     if(d->transfers[line].Callback)  
  907.                     {  
  908.                         (*d->transfers[line].Callback)(d,nodeId);  
  909.                     }  
  910.                       
  911.                     MSG_WAR(0x3A77, "SDO. End of upload from node : ", nodeId);  
  912.                 }  
  913.                 /* 如果不是最后一段，继续请求上传 */  
  914.                 else   
  915.                 {  
  916.                     data[0] = (3 << 5) | (d->transfers[line].toggle << 4);  
  917.                     for(i = 1; i < 8; i++)  
  918.                         data[i] = 0;  
  919.                     sendSDO(d, whoami, CliServNbr, data);  
  920.                     MSG_WAR(0x3A78, "SDO send upload segment request to nodeId", nodeId);  
  921.                 }  
  922.             }  
  923.             break;  
  924.   
  925.         /* 客户端->服务器:启动域下载/服务器->客户端:域分段下载 */  
  926.         case 1:  
  927.             /* 客户端->服务器:启动域下载 */  
  928.             if(whoami == SDO_SERVER)   
  929.             {  
  930.                 /* 索引 */  
  931.                 index = getSDOindex(m->data[1], m->data[2]);  
  932.                 /* 子索引 */  
  933.                 subIndex = getSDOsubIndex(m->data[3]);  
  934.                 MSG_WAR(0x3A79, "Received SDO Initiate Download (to store data) defined at index 0x1200 + ", CliServNbr);  
  935.                 MSG_WAR(0x3A80, "Writing at index : ", index);  
  936.                 MSG_WAR(0x3A80, "Writing at subIndex : ", subIndex);  
  937.                 if(!err)   
  938.                 {  
  939.                     MSG_ERR(0x1A81, "SDO error : Transmission yet started.", 0);  
  940.                     failedSDO(d, CliServNbr, whoami, index, subIndex, SDOABT_LOCAL_CTRL_ERROR);  
  941.                     return 0xFF;  
  942.                 }  
  943.                   
  944.                 /* 查找空闲传输通道 */  
  945.                 err = getSDOfreeLine(d, whoami, &line);  
  946.                 if(err)   
  947.                 {  
  948.                     MSG_ERR(0x1A82, "SDO error : No line free, too many SDO in progress. Aborted.", 0);  
  949.                     failedSDO(d, CliServNbr, whoami, index, subIndex, SDOABT_LOCAL_CTRL_ERROR);  
  950.                     return 0xFF;  
  951.                 }  
  952.                 /* 初始化sdo传输通道 */  
  953.                 initSDOline(d, line, CliServNbr, index, subIndex, SDO_DOWNLOAD_IN_PROGRESS);  
  954.   
  955.                 /* 如果是快速传输 */  
  956.                 if(getSDOe(m->data[0]))   
  957.                 {  
  958.                     /* 取出字节数 */  
  959.                     nbBytes = 4 - getSDOn2(m->data[0]);  
  960.                     /* 存储字节数 */  
  961.                     d->transfers[line].count = nbBytes;  
  962.                     /* 将数据数据拷贝到传输通道缓冲区 */  
  963.                     err = SDOtoLine(d, line, nbBytes, (*m).data + 4);  
  964.                     if(err)   
  965.                     {  
  966.                         failedSDO(d, CliServNbr, whoami, index, subIndex, SDOABT_GENERAL_ERROR);  
  967.                         return 0xFF;  
  968.                     }  
  969.   
  970.                     MSG_WAR(0x3A83, "SDO Initiate Download is an expedited transfer. Finished. ", 0);  
  971.                       
  972.                     /* 将数据从传输通道缓冲区拷贝到字典中 */  
  973.                     errorCode = SDOlineToObjdict(d, line);  
  974.                     if(errorCode)   
  975.                     {  
  976.                         MSG_ERR(0x1A84, "SDO error : Unable to copy the data in the object dictionary", 0);  
  977.                         failedSDO(d, CliServNbr, whoami, index, subIndex, errorCode);  
  978.                         return 0xFF;  
  979.                     }  
  980.                     /* 复位sdo通道 */  
  981.                     resetSDOline(d, line);  
  982.                 }  
  983.                 /* 如果是正常传输 */  
  984.                 else   
  985.                 {  
  986.                     /* 数据字节为字节计数器 */  
  987.                     if(getSDOs(m->data[0]))   
  988.                     {  
  989.                         /* 取出字节数 */  
  990.                         nbBytes = (m->data[4]) + ((UNS32)(m->data[5])<<8) + ((UNS32)(m->data[6])<<16) + ((UNS32)(m->data[7])<<24);  
  991.                         /* 设置sdo传输通道字节数剩余 */  
  992.                         err = setSDOlineRestBytes(d, line, nbBytes);  
  993.                         if(err)  
  994.                         {  
  995.                             failedSDO(d, CliServNbr, whoami, index, subIndex, SDOABT_GENERAL_ERROR);  
  996.                             return 0xFF;  
  997.                         }  
  998.                     }  
  999.                 }  
  1000.                 /* 发送启动域下载响应 */  
  1001.                 data[0] = 3 << 5;  
  1002.                 data[1] = index & 0xFF;  
  1003.                 data[2] = (index >> 8) & 0xFF;  
  1004.                 data[3] = subIndex;  
  1005.                 for(i = 4 ; i < 8 ; i++)  
  1006.                     data[i] = 0;  
  1007.                 sendSDO(d, whoami, CliServNbr, data);  
  1008.             }  
  1009.             /* 服务器->客户端:域分段下载 */  
  1010.             else   
  1011.             {  
  1012.                 /* 验证传输通道是否在域分段下载中 */  
  1013.                 if(!err)  
  1014.                     err = d->transfers[line].state != SDO_DOWNLOAD_IN_PROGRESS;  
  1015.                 if(err)   
  1016.                 {  
  1017.                     MSG_ERR(0x1A85, "SDO error : Received segment response for unknown trans. from nodeId", nodeId);  
  1018.                     failedSDO(d, CliServNbr, whoami, 0, 0, SDOABT_LOCAL_CTRL_ERROR);  
  1019.                     return 0xFF;  
  1020.                 }  
  1021.                   
  1022.                 /* 重启传输通道超时定时器 */  
  1023.                 RestartSDO_TIMER(line)  
  1024.                 /* 索引 */      
  1025.                 index = d->transfers[line].index;  
  1026.                 /* 子索引 */  
  1027.                 subIndex = d->transfers[line].subIndex;  
  1028.                 /* 校验触发位是否同步 */  
  1029.                 if(d->transfers[line].toggle != getSDOt(m->data[0]))   
  1030.                 {  
  1031.                     MSG_ERR(0x1A86, "SDO error : Received segment response Toggle error. from nodeId", nodeId);  
  1032.                     failedSDO(d, CliServNbr, whoami, index, subIndex, SDOABT_TOGGLE_NOT_ALTERNED);  
  1033.                     return 0xFF;  
  1034.                 }  
  1035.   
  1036.                 /* 获取传输通道剩余字节数 */  
  1037.                 getSDOlineRestBytes(d, line, &nbBytes);  
  1038.                 /* 如果已经传输完 */  
  1039.                 if(nbBytes == 0)   
  1040.                 {  
  1041.                     MSG_WAR(0x3A87, "SDO End download. segment response received. OK. from nodeId", nodeId);  
  1042.                     /* 停止超时定时器 */  
  1043.                     StopSDO_TIMER(line)  
  1044.                     /* 将状态置为完成 */  
  1045.                     d->transfers[line].state = SDO_FINISHED;  
  1046.                     /* 传输完成回调函数 */  
  1047.                     if(d->transfers[line].Callback)   
  1048.                     {  
  1049.                         (*d->transfers[line].Callback)(d,nodeId);  
  1050.                     }  
  1051.                       
  1052.                     return 0x00;  
  1053.                 }  
  1054.   
  1055.                 /* 如果至少还有7个字节没传输完毕  */  
  1056.                 if(nbBytes > 7)   
  1057.                 {  
  1058.                     /* 触发位取反 */  
  1059.                     d->transfers[line].toggle = ! d->transfers[line].toggle & 1;  
  1060.                     /* 构建报文 */  
  1061.                     data[0] = (d->transfers[line].toggle << 4);  
  1062.                     /* 将数据从传输通道缓冲区拷贝到sdo报文中 */  
  1063.                     err = lineToSDO(d, line, 7, data + 1);  
  1064.                     if(err)   
  1065.                     {  
  1066.                         failedSDO(d, CliServNbr, whoami, index, subIndex, SDOABT_GENERAL_ERROR);  
  1067.                         return 0xFF;  
  1068.                     }  
  1069.                 }  
  1070.                 /* 如果数据量小于7个字节 */  
  1071.                 else   
  1072.                 {  
  1073.                     /* 触发位取反 */  
  1074.                     d->transfers[line].toggle = !d->transfers[line].toggle & 1;  
  1075.                     /* 构建报文 */  
  1076.                     data[0] = (UNS8)((d->transfers[line].toggle << 4) | ((7 - nbBytes) << 1) | 1);  
  1077.                     /* 将数据从传输通道缓冲区拷贝到sdo报文中 */  
  1078.                     err = lineToSDO(d, line, nbBytes, data + 1);  
  1079.                     if(err)   
  1080.                     {  
  1081.                         failedSDO(d, CliServNbr, whoami, index, subIndex, SDOABT_GENERAL_ERROR);  
  1082.                         return 0xFF;  
  1083.                     }  
  1084.                       
  1085.                     /* 剩余字节填0 */  
  1086.                     for(i = nbBytes + 1; i < 8; i++)  
  1087.                     {  
  1088.                         data[i] = 0;  
  1089.                     }  
  1090.                 }  
  1091.                 MSG_WAR(0x3A88, "SDO sending download segment to nodeId", nodeId);  
  1092.                   
  1093.                 /* 发送sdo报文 */  
  1094.                 sendSDO(d, whoami, CliServNbr, data);  
  1095.             }  
  1096.             break;  
  1097.   
  1098.         /* 客户端->服务器:启动域上传/服务器->客户端:启动域上传 */  
  1099.         case 2:  
  1100.             /* 客户端->服务器:启动域上传 */  
  1101.             if(whoami == SDO_SERVER)   
  1102.             {  
  1103.                 /* 索引 */  
  1104.                 index = getSDOindex(m->data[1], m->data[2]);  
  1105.                 /* 子索引 */  
  1106.                 subIndex = getSDOsubIndex(m->data[3]);  
  1107.                 MSG_WAR(0x3A89, "Received SDO Initiate upload (to send data) defined at index 0x1200 + ", CliServNbr);  
  1108.                 MSG_WAR(0x3A90, "Reading at index : ", index);  
  1109.                 MSG_WAR(0x3A91, "Reading at subIndex : ", subIndex);  
  1110.                 if(!err)   
  1111.                 {  
  1112.                     MSG_ERR(0x1A92, "SDO error : Transmission yet started at line : ", line);  
  1113.                     MSG_WAR(0x3A93, "Server Nbr = ", CliServNbr);  
  1114.                     failedSDO(d, CliServNbr, whoami, index, subIndex, SDOABT_LOCAL_CTRL_ERROR);  
  1115.                     return 0xFF;  
  1116.                 }  
  1117.                 /* 获取sdo空闲传输通道 */  
  1118.                 err = getSDOfreeLine(d, whoami, &line);  
  1119.                 if(err)   
  1120.                 {  
  1121.                     MSG_ERR(0x1A71, "SDO error : No line free, too many SDO in progress. Aborted.", 0);  
  1122.                     failedSDO(d, CliServNbr, whoami, index, subIndex, SDOABT_LOCAL_CTRL_ERROR);  
  1123.                     return 0xFF;  
  1124.                 }  
  1125.                 /* 初始化传输通道 */  
  1126.                 initSDOline(d, line, CliServNbr, index, subIndex, SDO_UPLOAD_IN_PROGRESS);  
  1127.                 /* 将数据从字典中拷贝到传输通道缓冲区 */  
  1128.                 errorCode = objdictToSDOline(d, line);  
  1129.                 if(errorCode)   
  1130.                 {  
  1131.                     MSG_ERR(0x1A94, "SDO error : Unable to copy the data from object dictionary. Err code : ", errorCode);  
  1132.                     failedSDO(d, CliServNbr, whoami, index, subIndex, errorCode);  
  1133.                     return 0xFF;  
  1134.                 }  
  1135.                 /* 获取传输通道剩余字节数 */  
  1136.                 getSDOlineRestBytes(d, line, &nbBytes);  
  1137.                 /* 字节数大于4，正常传输 */  
  1138.                 if(nbBytes > 4)   
  1139.                 {  
  1140.                     /* 命令 */  
  1141.                     data[0] = (2 << 5) | 1;  
  1142.                     /* 索引 */  
  1143.                     data[1] = index & 0xFF;  
  1144.                     data[2] = (index >> 8) & 0xFF;  
  1145.                     /* 子索引 */  
  1146.                     data[3] = subIndex;  
  1147.                     /* 字节计数器 */  
  1148.                     data[4] = (UNS8)nbBytes;  
  1149.                     data[5] = (UNS8)(nbBytes >> 8);  
  1150.                     data[6] = (UNS8)(nbBytes >> 16);  
  1151.                     data[7] = (UNS8)(nbBytes >> 24);  
  1152.                     MSG_WAR(0x3A95, "SDO. Sending normal upload initiate response defined at index 0x1200 + ", nodeId);  
  1153.                     /* 发送sdo报文 */  
  1154.                     sendSDO(d, whoami, CliServNbr, data);  
  1155.                 }  
  1156.                 /* 字节数不高于4，快速传输 */  
  1157.                 else  
  1158.                 {  
  1159.                     /* 命令 */  
  1160.                     data[0] = (UNS8)((2 << 5) | ((4 - nbBytes) << 2) | 3);  
  1161.                     /* 索引 */  
  1162.                     data[1] = index & 0xFF;  
  1163.                     data[2] = (index >> 8) & 0xFF;  
  1164.                     /* 子索引 */  
  1165.                     data[3] = subIndex;  
  1166.                     /* 将数据从传输通道缓冲区拷贝到sdo报文 */  
  1167.                     err = lineToSDO(d, line, nbBytes, data + 4);  
  1168.                     if(err)   
  1169.                     {  
  1170.                         failedSDO(d, CliServNbr, whoami, index, subIndex, SDOABT_GENERAL_ERROR);  
  1171.                         return 0xFF;  
  1172.                     }  
  1173.                     /* 不足8字节填0 */  
  1174.                     for(i = 4 + nbBytes; i < 8; i++)  
  1175.                     {  
  1176.                         data[i] = 0;  
  1177.                     }  
  1178.                       
  1179.                     MSG_WAR(0x3A96, "SDO. Sending expedited upload initiate response defined at index 0x1200 + ", CliServNbr);  
  1180.                       
  1181.                     /* 发送sdo报文 */  
  1182.                     sendSDO(d, whoami, CliServNbr, data);  
  1183.                       
  1184.                     /* 复位sdo传输通道 */  
  1185.                     resetSDOline(d, line);  
  1186.                 }  
  1187.             }  
  1188.             /* 服务器->客户端:启动域上传 */  
  1189.             else   
  1190.             {  
  1191.                 /* 验证传输通道是否在域上传中 */  
  1192.                 if(!err)  
  1193.                     err = d->transfers[line].state != SDO_UPLOAD_IN_PROGRESS;  
  1194.                 if(err)   
  1195.                 {  
  1196.                     MSG_ERR(0x1A97, "SDO error : Received response for unknown upload request from nodeId", nodeId);  
  1197.                     failedSDO(d, CliServNbr, whoami, 0, 0, SDOABT_LOCAL_CTRL_ERROR);  
  1198.                     return 0xFF;  
  1199.                 }  
  1200.                   
  1201.                 /* 重置传输超时定时器 */  
  1202.                 RestartSDO_TIMER(line)  
  1203.                   
  1204.                 /* 索引 */  
  1205.                 index = d->transfers[line].index;  
  1206.                 /* 子索引 */  
  1207.                 subIndex = d->transfers[line].subIndex;  
  1208.   
  1209.                 /* 加速传输完成 */  
  1210.                 if(getSDOe(m->data[0]))   
  1211.                 {  
  1212.                     /* 字节数 */  
  1213.                     nbBytes = 4 - getSDOn2(m->data[0]);  
  1214.                     /* 将数据拷贝到传输通道缓冲区 */  
  1215.                     err = SDOtoLine(d, line, nbBytes, (*m).data + 4);  
  1216.                     if(err)   
  1217.                     {  
  1218.                         failedSDO(d, CliServNbr, whoami, index, subIndex, SDOABT_GENERAL_ERROR);  
  1219.                         return 0xFF;  
  1220.                     }  
  1221.   
  1222.                     MSG_WAR(0x3A98, "SDO expedited upload finished. Response received from node : ", nodeId);  
  1223.                       
  1224.                     /* 停止sdo传输通道超时定时器 */  
  1225.                     StopSDO_TIMER(line)  
  1226.                       
  1227.                     /* 接收到的字节数 */  
  1228.                     d->transfers[line].count = nbBytes;  
  1229.                       
  1230.                     /* sdo传输通道传输完成 */  
  1231.                     d->transfers[line].state = SDO_FINISHED;  
  1232.                       
  1233.                     /* 传输完成后调用回调函数 */  
  1234.                     if(d->transfers[line].Callback)   
  1235.                         (*d->transfers[line].Callback)(d,nodeId);  
  1236.                       
  1237.                     return 0;  
  1238.                 }  
  1239.                 /* 正常传输 */  
  1240.                 else   
  1241.                 {  
  1242.                     if(getSDOs(m->data[0]))   
  1243.                     {  
  1244.                         /* 字节计数器 */  
  1245.                         nbBytes = m->data[4] + ((UNS32)(m->data[5]) << 8) + ((UNS32)(m->data[6]) << 16) + ((UNS32)(m->data[7]) << 24);  
  1246.                         /* 设置sdo传输通道剩余字节数 */  
  1247.                         err = setSDOlineRestBytes(d, line, nbBytes);  
  1248.                         if(err)   
  1249.                         {  
  1250.                             failedSDO(d, CliServNbr, whoami, index, subIndex, SDOABT_GENERAL_ERROR);  
  1251.                             return 0xFF;  
  1252.                         }  
  1253.                     }  
  1254.   
  1255.                     /* 请求：域分段上传 */  
  1256.                     data[0] = 3 << 5;  
  1257.                     for(i = 1; i < 8; i++)  
  1258.                         data[i] = 0;  
  1259.   
  1260.                     MSG_WAR(0x3A99, "SDO. Sending upload segment request to node : ", nodeId);  
  1261.                       
  1262.                     /* 发送报文 */  
  1263.                     sendSDO(d, whoami, CliServNbr, data);  
  1264.                 }  
  1265.             }  
  1266.             break;  
  1267.   
  1268.         /* 客户端->服务器：域分段上传/服务器->客户端：启动域下载 */  
  1269.         case 3:  
  1270.             /* 客户端->服务器：域分段上传 */  
  1271.             if(whoami == SDO_SERVER)   
  1272.             {  
  1273.                 if(!err)  
  1274.                     err = d->transfers[line].state != SDO_UPLOAD_IN_PROGRESS;  
  1275.                 if(err)   
  1276.                 {  
  1277.                     MSG_ERR(0x1AA0, "SDO error : Received upload segment for unstarted trans. index 0x1200 + ", CliServNbr);  
  1278.                     failedSDO(d, CliServNbr, whoami, 0, 0, SDOABT_LOCAL_CTRL_ERROR);  
  1279.                       
  1280.                     return 0xFF;  
  1281.                 }  
  1282.   
  1283.                 /* 复位sdo传输通道超时定时器 */  
  1284.                 RestartSDO_TIMER(line)  
  1285.                       
  1286.                 MSG_WAR(0x3AA1, "Received SDO upload segment defined at index 0x1200 + ", CliServNbr);  
  1287.                   
  1288.                 /* 索引 */  
  1289.                 index = d->transfers[line].index;  
  1290.                 /* 子索引 */  
  1291.                 subIndex = d->transfers[line].subIndex;  
  1292.                   
  1293.                 /* 校验触发位是否同步 */  
  1294.                 if(d->transfers[line].toggle != getSDOt(m->data[0]))   
  1295.                 {  
  1296.                     MSG_ERR(0x1AA2, "SDO error : Toggle error : ", getSDOt(m->data[0]));  
  1297.                     failedSDO(d, CliServNbr, whoami, index, subIndex, SDOABT_TOGGLE_NOT_ALTERNED);  
  1298.                       
  1299.                     return 0xFF;  
  1300.                 }  
  1301.   
  1302.                 /* 获取传输通道剩余字节数 */  
  1303.                 getSDOlineRestBytes(d, line, &nbBytes);  
  1304.                 /* 如果至少还有7个字节没传输完毕  */  
  1305.                 if(nbBytes > 7)   
  1306.                 {  
  1307.                     /* 构建报文 */  
  1308.                     data[0] = (d->transfers[line].toggle << 4);  
  1309.                     /* 将数据从sdo传输通道缓冲区拷贝到sdo报文中 */  
  1310.                     err = lineToSDO(d, line, 7, data + 1);  
  1311.                     if(err)   
  1312.                     {  
  1313.                         failedSDO(d, CliServNbr, whoami, index, subIndex, SDOABT_GENERAL_ERROR);  
  1314.                         return 0xFF;  
  1315.                     }  
  1316.   
  1317.                     /* 将触发位取反 */  
  1318.                     d->transfers[line].toggle = !d->transfers[line].toggle & 1;  
  1319.                       
  1320.                     MSG_WAR(0x3AA3, "SDO. Sending upload segment defined at index 0x1200 + ", CliServNbr);  
  1321.                       
  1322.                     /* 发送报文 */  
  1323.                     sendSDO(d, whoami, CliServNbr, data);  
  1324.                 }  
  1325.                 /* 不大于7字节，则说明是最后一段 */  
  1326.                 else   
  1327.                 {  
  1328.                     /* 构建报文 */  
  1329.                     data[0] = (UNS8)((d->transfers[line].toggle << 4) | ((7 - nbBytes) << 1) | 1);  
  1330.                     /* 将数据从sdo传输通道缓冲区拷贝到sdo报文中 */  
  1331.                     err = lineToSDO(d, line, nbBytes, data + 1);  
  1332.                     if (err) {  
  1333.                         failedSDO(d, CliServNbr, whoami, index, subIndex, SDOABT_GENERAL_ERROR);  
  1334.                         return 0xFF;  
  1335.                     }  
  1336.                     /* 不满8字节补0 */  
  1337.                     for(i = nbBytes + 1; i < 8; i++)  
  1338.                         data[i] = 0;  
  1339.                       
  1340.                     MSG_WAR(0x3AA4, "SDO. Sending last upload segment defined at index 0x1200 + ", CliServNbr);  
  1341.                       
  1342.                     /* 发送报文 */  
  1343.                     sendSDO(d, whoami, CliServNbr, data);  
  1344.                       
  1345.                     /* 复位传输通道 */  
  1346.                     resetSDOline(d, line);  
  1347.                 }  
  1348.             }  
  1349.             /* 服务器->客户端：启动域下载 */  
  1350.             else   
  1351.             {  
  1352.                 /* 校验传输通道是否在域下载过程中 */  
  1353.                 if(!err)  
  1354.                     err = d->transfers[line].state != SDO_DOWNLOAD_IN_PROGRESS;  
  1355.                 if(err)   
  1356.                 {  
  1357.                     MSG_ERR(0x1AA5, "SDO error : Received response for unknown download request from nodeId", nodeId);  
  1358.                     failedSDO(d, CliServNbr, whoami, 0, 0, SDOABT_LOCAL_CTRL_ERROR);  
  1359.                     return 0xFF;  
  1360.                 }  
  1361.                   
  1362.                 /* 复位sdo传输通道定时器 */  
  1363.                 RestartSDO_TIMER(line)  
  1364.                   
  1365.                 /* 索引 */  
  1366.                 index = d->transfers[line].index;  
  1367.                 /* 子索引 */  
  1368.                 subIndex = d->transfers[line].subIndex;  
  1369.                   
  1370.                 /* 获取sdo传输通道剩余字节数 */  
  1371.                 getSDOlineRestBytes(d, line, &nbBytes);  
  1372.                   
  1373.                 /* 传输完成 */  
  1374.                 if(nbBytes == 0)   
  1375.                 {  
  1376.                     MSG_WAR(0x3AA6, "SDO End download expedited. Response received. from nodeId", nodeId);  
  1377.                       
  1378.                     /* 停止传输通道超时定时器 */  
  1379.                     StopSDO_TIMER(line)  
  1380.                       
  1381.                     /* 将传输通道状态设置为完成 */  
  1382.                     d->transfers[line].state = SDO_FINISHED;  
  1383.                       
  1384.                     /* 传输完成回调函数 */  
  1385.                     if(d->transfers[line].Callback)   
  1386.                         (*d->transfers[line].Callback)(d,nodeId);  
  1387.                       
  1388.                     return 0x00;  
  1389.                 }  
  1390.                   
  1391.                 /* 剩余字节数大于7个：域分段下载 */  
  1392.                 if(nbBytes > 7)   
  1393.                 {  
  1394.                     /* 构建报文 */  
  1395.                     data[0] = (d->transfers[line].toggle << 4);  
  1396.                       
  1397.                     /* 将数据从传输通道中拷贝到sdo报文中 */  
  1398.                     err = lineToSDO(d, line, 7, data + 1);  
  1399.                     if(err)   
  1400.                     {  
  1401.                         failedSDO(d, CliServNbr, whoami, index, subIndex, SDOABT_GENERAL_ERROR);  
  1402.                         return 0xFF;  
  1403.                     }  
  1404.                 }  
  1405.                 /* 剩余字节数不大于7个：域分段下载，最后一段 */  
  1406.                 else   
  1407.                 {  
  1408.                     /* 构建报文 */  
  1409.                     data[0] = (UNS8)((d->transfers[line].toggle << 4) | ((7 - nbBytes) << 1) | 1);  
  1410.                       
  1411.                     /* 将数据从传输通道中拷贝到sdo报文中 */  
  1412.                     err = lineToSDO(d, line, nbBytes, data + 1);  
  1413.                     if(err)   
  1414.                     {  
  1415.                         failedSDO(d, CliServNbr, whoami, index, subIndex, SDOABT_GENERAL_ERROR);  
  1416.                         return 0xFF;  
  1417.                     }  
  1418.   
  1419.                     /* 不足8字节补0 */  
  1420.                     for(i = nbBytes + 1; i < 8; i++)  
  1421.                         data[i] = 0;  
  1422.                 }  
  1423.                   
  1424.                 MSG_WAR(0x3AA7, "SDO sending download segment to nodeId", nodeId);  
  1425.                   
  1426.                 /* 发送sdo报文 */  
  1427.                 sendSDO(d, whoami, CliServNbr, data);  
  1428.             }  
  1429.             break;  
  1430.   
  1431.         /* 中止 */  
  1432.         case 4:  
  1433.             /* 中止码 */  
  1434.             abortCode = (UNS32)m->data[4] | ((UNS32)m->data[5] << 8) | ((UNS32)m->data[6] << 16) | ((UNS32)m->data[7] << 24);  
  1435.             /* 客户端->服务器：中止 */  
  1436.             if(whoami == SDO_SERVER)   
  1437.             {  
  1438.                 /* 复位sdo传输通道 */  
  1439.                 if(!err)   
  1440.                 {  
  1441.                     resetSDOline(d, line);  
  1442.                     MSG_WAR(0x3AA8, "SD0. Received SDO abort. Line released. Code : ", abortCode);  
  1443.                 }  
  1444.                 else  
  1445.                     MSG_WAR(0x3AA9, "SD0. Received SDO abort. No line found. Code : ", abortCode);  
  1446.             }  
  1447.             /* 服务器->客户端：中止 */  
  1448.             else   
  1449.             {  
  1450.                 if(!err)   
  1451.                 {  
  1452.                     /* 停止sdo传输通道超时定时器 */  
  1453.                     StopSDO_TIMER(line)  
  1454.                     /* 将传输通道状态设置为中止 */  
  1455.                     d->transfers[line].state = SDO_ABORTED_RCV;  
  1456.                     /* 中止码 */  
  1457.                     d->transfers[line].abortCode = abortCode;  
  1458.                       
  1459.                     MSG_WAR(0x3AB0, "SD0. Received SDO abort. Line state ABORTED. Code : ", abortCode);  
  1460.                       
  1461.                     /* 传输结束调用回调函数 */  
  1462.                     if(d->transfers[line].Callback)   
  1463.                         (*d->transfers[line].Callback)(d, nodeId);  
  1464.                 }  
  1465.                 else  
  1466.                     MSG_WAR(0x3AB1, "SD0. Received SDO abort. No line found. Code : ", abortCode);  
  1467.             }  
  1468.             break;  
  1469.   
  1470.         /* 服务器->客户端：块下载初始化/服务器->客户端：块下载/服务器->客户端：块下载结束 */  
  1471.         /* 客户端->服务器：块上传初始化/客户端->服务器：块上传开始命令/客户端->服务器：块上传/客户端->服务器：块上传结束 */  
  1472.         case 5:  
  1473.             /* 子命令 */  
  1474.             SubCommand = getSDOblockSC(m->data[0]);  
  1475.               
  1476.             /* 客户端->服务器：块上传初始化/客户端->服务器：块上传/客户端->服务器：块上传结束 */  
  1477.             if(whoami == SDO_SERVER)   
  1478.             {  
  1479.                 /* 客户端->服务器：块上传初始化 */  
  1480.                 if(SubCommand == SDO_BCS_INITIATE_UPLOAD_REQUEST)   
  1481.                 {  
  1482.                     /* 索引 */  
  1483.                     index = getSDOindex(m->data[1], m->data[2]);  
  1484.                     /* 子索引 */  
  1485.                     subIndex = getSDOsubIndex(m->data[3]);  
  1486.                       
  1487.                     MSG_WAR(0x3AB2, "Received SDO Initiate block upload defined at index 0x1200 + ", CliServNbr);  
  1488.                     MSG_WAR(0x3AB3, "Reading at index : ", index);  
  1489.                     MSG_WAR(0x3AB4, "Reading at subIndex : ", subIndex);  
  1490.                     if(!err)   
  1491.                     {  
  1492.                         MSG_ERR(0x1A93, "SDO error : Transmission yet started at line : ", line);  
  1493.                         MSG_WAR(0x3AB5, "Server Nbr = ", CliServNbr);  
  1494.                         failedSDO(d, CliServNbr, whoami, index, subIndex, SDOABT_LOCAL_CTRL_ERROR);  
  1495.                         return 0xFF;  
  1496.                     }  
  1497.                       
  1498.                     /* 获取sdo空闲传输通道 */  
  1499.                     err = getSDOfreeLine(d, whoami, &line);  
  1500.                     if(err)   
  1501.                     {  
  1502.                         MSG_ERR(0x1A73, "SDO error : No line free, too many SDO in progress. Aborted.", 0);  
  1503.                         failedSDO(d, CliServNbr, whoami, index, subIndex, SDOABT_LOCAL_CTRL_ERROR);  
  1504.                         return 0xFF;  
  1505.                     }  
  1506.                       
  1507.                     /* 初始化sdo传输通道 */  
  1508.                     initSDOline(d, line, CliServNbr, index, subIndex, SDO_BLOCK_UPLOAD_IN_PROGRESS);  
  1509.                       
  1510.                     /* 是否支持crc校验 */  
  1511.                     d->transfers[line].peerCRCsupport = ((m->data[0]) >> 2) & 1;  
  1512.                       
  1513.                     /* 块数量 */  
  1514.                     d->transfers[line].blksize = m->data[4];  
  1515.                     /* 将数据从字典中拷贝到sdo传输通道缓冲区 */  
  1516.                     errorCode = objdictToSDOline(d, line);  
  1517.                     if(errorCode)   
  1518.                     {  
  1519.                         MSG_ERR(0x1A95, "SDO error : Unable to copy the data from object dictionary. Err code : ", errorCode);  
  1520.                         failedSDO(d, CliServNbr, whoami, index, subIndex, errorCode);  
  1521.                         return 0xFF;  
  1522.                     }  
  1523.                     /* 获取sdo传输剩余字节数 */  
  1524.                     getSDOlineRestBytes(d, line, &nbBytes);  
  1525.                     /* 设置对象大小 */  
  1526.                     d->transfers[line].objsize = nbBytes;  
  1527.                       
  1528.                     /* sdo块上传初始化响应 */  
  1529.                     data[0] = (6 << 5) | (1 << 1) | SDO_BSS_INITIATE_UPLOAD_RESPONSE;  
  1530.                     /* 索引 */  
  1531.                     data[1] = index & 0xFF;  
  1532.                     data[2] = (index >> 8) & 0xFF;  
  1533.                     /* 子索引 */  
  1534.                     data[3] = subIndex;  
  1535.                     /* 字节数 */  
  1536.                     data[4] = (UNS8)nbBytes;  
  1537.                     data[5] = (UNS8)(nbBytes >> 8);  
  1538.                     data[6] = (UNS8)(nbBytes >> 16);  
  1539.                     data[7] = (UNS8)(nbBytes >> 24);  
  1540.                       
  1541.                     MSG_WAR(0x3A9A, "SDO. Sending normal block upload initiate response defined at index 0x1200 + ", nodeId);  
  1542.                       
  1543.                     /* 发送sdo报文 */  
  1544.                     sendSDO(d, whoami, CliServNbr, data);  
  1545.                 }  
  1546.                 /* 客户端->服务器：块上传结束响应 */  
  1547.                 else if(SubCommand == SDO_BCS_END_UPLOAD_REQUEST)   
  1548.                 {  
  1549.                     MSG_WAR(0x3AA2, "Received SDO block END upload request defined at index 0x1200 + ", CliServNbr);  
  1550.                       
  1551.                     /* 校验是否在块上传过程中 */  
  1552.                     if(!err)  
  1553.                         err = d->transfers[line].state != SDO_BLOCK_UPLOAD_IN_PROGRESS;  
  1554.                     if(err)   
  1555.                     {  
  1556.                         MSG_ERR(0x1AA1, "SDO error : Received block upload request for unstarted trans. index 0x1200 + ", CliServNbr);  
  1557.                         failedSDO(d, CliServNbr, whoami, 0, 0, SDOABT_LOCAL_CTRL_ERROR);  
  1558.                         return 0xFF;  
  1559.                     }  
  1560.                                       
  1561.                     /* 复位sdo传输通道 */  
  1562.                     resetSDOline(d, line);  
  1563.                 }  
  1564.                 /* 客户端->服务器：块上传/客户端->服务器：块上传开始命令 */  
  1565.                 else if((SubCommand == SDO_BCS_UPLOAD_RESPONSE) || (SubCommand == SDO_BCS_START_UPLOAD))   
  1566.                 {  
  1567.                     /* 校验是否在块上传过程中 */  
  1568.                     if(!err)  
  1569.                         err = d->transfers[line].state != SDO_BLOCK_UPLOAD_IN_PROGRESS;  
  1570.                     if(err)   
  1571.                     {  
  1572.                         MSG_ERR(0x1AA1, "SDO error : Received block upload response for unstarted trans. index 0x1200 + ", CliServNbr);  
  1573.                         failedSDO(d, CliServNbr, whoami, 0, 0, SDOABT_LOCAL_CTRL_ERROR);  
  1574.                         return 0xFF;  
  1575.                     }  
  1576.                       
  1577.                     /* 重启传输通道超时定时器 */  
  1578.                     RestartSDO_TIMER(line);  
  1579.                       
  1580.                     /* 索引 */  
  1581.                     index = d->transfers[line].index;  
  1582.                     /* 子索引 */  
  1583.                     subIndex = d->transfers[line].subIndex;  
  1584.   
  1585.                     /* 块上传响应 */  
  1586.                     if(SubCommand == SDO_BCS_UPLOAD_RESPONSE)   
  1587.                     {  
  1588.                         MSG_WAR(0x3AA2, "Received SDO block upload response defined at index 0x1200 + ", CliServNbr);  
  1589.                           
  1590.                         /* 一次最大上传块数 */  
  1591.                         d->transfers[line].blksize = m->data[2];  
  1592.                         /* 响应序列号 */  
  1593.                         AckSeq = (m->data[1]) & 0x7f;  
  1594.                         /* 获取剩余字节数 */  
  1595.                         getSDOlineRestBytes(d, line, &nbBytes);  
  1596.                         /* 如果传输完 */  
  1597.                         if((nbBytes == 0) && (AckSeq == d->transfers[line].seqno))  
  1598.                         {  
  1599.                             /* 上传结束指令 */  
  1600.                             data[0] = (6 << 5) | ((d->transfers[line].endfield) << 2) | SDO_BSS_END_UPLOAD_RESPONSE;  
  1601.                             for(i = 1; i < 8; i++)  
  1602.                                 data[i] = 0;  
  1603.               
  1604.                             MSG_WAR(0x3AA5, "SDO. Sending block END upload response defined at index 0x1200 + ", CliServNbr);  
  1605.   
  1606.                             /* 发送sdo报文 */  
  1607.                             sendSDO(d, whoami, CliServNbr, data);  
  1608.                             break;  
  1609.                         }  
  1610.                         else  
  1611.                             d->transfers[line].offset = d->transfers[line].lastblockoffset + 7 * AckSeq;  
  1612.   
  1613.                         if(d->transfers[line].offset > d->transfers[line].count)   
  1614.                         {  
  1615.                             MSG_ERR(0x1AA1, "SDO error : Received upload response with bad ackseq index 0x1200 + ", CliServNbr);  
  1616.                             failedSDO(d, CliServNbr, whoami, 0, 0, SDOABT_LOCAL_CTRL_ERROR);  
  1617.                             return 0xFF;  
  1618.                         }  
  1619.                     }  
  1620.                     else  
  1621.                         MSG_WAR(0x3AA2, "Received SDO block START upload defined at index 0x1200 + ", CliServNbr);  
  1622.   
  1623.                     /* 上一次块传输后数据偏移量 */  
  1624.                     d->transfers[line].lastblockoffset = (UNS8) d->transfers[line].offset;  
  1625.   
  1626.                     /* 进行一次块上传数据 */  
  1627.                     for(SeqNo = 1; SeqNo <= d->transfers[line].blksize; SeqNo++)   
  1628.                     {  
  1629.                         /* 块序列号 */  
  1630.                         d->transfers[line].seqno = SeqNo;  
  1631.                           
  1632.                         /* 获取传输通道剩余字节数 */  
  1633.                         getSDOlineRestBytes(d, line, &nbBytes);  
  1634.                         /* 如果大于7字节，则说明不是最后一块数据 */  
  1635.                         if(nbBytes > 7)   
  1636.                         {  
  1637.                             /* 块序列号 */  
  1638.                             data[0] = SeqNo;  
  1639.                             /* 将传输通道上的数据拷贝到sdo报文中 */  
  1640.                             err = lineToSDO(d, line, 7, data + 1);  
  1641.                             if(err)   
  1642.                             {  
  1643.                                 failedSDO(d, CliServNbr, whoami, index, subIndex, SDOABT_GENERAL_ERROR);  
  1644.                                 return 0xFF;  
  1645.                             }  
  1646.                               
  1647.                             MSG_WAR(0x3AA5, "SDO. Sending upload segment defined at index 0x1200 + ", CliServNbr);  
  1648.                               
  1649.                             /* 发送sdo报文 */  
  1650.                             sendSDO(d, whoami, CliServNbr, data);  
  1651.                         }  
  1652.                         /* 如果不大于7字节，则说明是最后一块数据 */  
  1653.                         else   
  1654.                         {  
  1655.                             /* 块序列号，最高位表示最后一块 */  
  1656.                             data[0] = 0x80 | SeqNo;  
  1657.                               
  1658.                             /* 将传输通道上的数据拷贝到sdo报文中 */  
  1659.                             err = lineToSDO(d, line, nbBytes, data + 1);  
  1660.                             if(err)   
  1661.                             {  
  1662.                                 failedSDO(d, CliServNbr, whoami, index, subIndex, SDOABT_GENERAL_ERROR);  
  1663.                                 return 0xFF;  
  1664.                             }  
  1665.                               
  1666.                             /* 不满8字节补0 */  
  1667.                             for(i = nbBytes + 1 ; i < 8 ; i++)  
  1668.                                 data[i] = 0;  
  1669.                               
  1670.                             MSG_WAR(0x3AA5, "SDO. Sending last upload segment defined at index 0x1200 + ", CliServNbr);  
  1671.                               
  1672.                             /* 发送sdo报文 */  
  1673.                             sendSDO(d, whoami, CliServNbr, data);  
  1674.                               
  1675.                             /* 记录补零个数 */  
  1676.                             d->transfers[line].endfield = (UNS8)(7 - nbBytes);  
  1677.                             break;  
  1678.                         }  
  1679.                     }  
  1680.                 }  
  1681.             }  
  1682.             /* 服务器->客户端：块下载初始化/服务器->客户端：块下载/服务器->客户端：块下载结束 */  
  1683.             else   
  1684.             {  
  1685.                 /* 服务器->客户端：块下载初始化/服务器->客户端：块下载 */  
  1686.                 if((SubCommand == SDO_BSS_INITIATE_DOWNLOAD_RESPONSE) ||   
  1687.                      (SubCommand == SDO_BSS_DOWNLOAD_RESPONSE))   
  1688.                 {  
  1689.                     /* 判断sdo传输通道是否在块下载过程中 */  
  1690.                     if(!err)  
  1691.                         err = d->transfers[line].state != SDO_BLOCK_DOWNLOAD_IN_PROGRESS;  
  1692.                     if(err)  
  1693.                     {  
  1694.                         MSG_ERR(0x1AAA, "SDO error : Received response for unknown block download request from node id", nodeId);  
  1695.                         failedSDO(d, CliServNbr, whoami, 0, 0, SDOABT_LOCAL_CTRL_ERROR);  
  1696.                         return 0xFF;  
  1697.                     }  
  1698.                       
  1699.                     /* 复位sdo传输超时定时器 */  
  1700.                     RestartSDO_TIMER(line)  
  1701.                       
  1702.                     /* 服务器->客户端：块下载初始化 */  
  1703.                     if(SubCommand == SDO_BSS_INITIATE_DOWNLOAD_RESPONSE)   
  1704.                     {  
  1705.                         /* 索引 */  
  1706.                         index = d->transfers[line].index;  
  1707.                         /* 子索引 */  
  1708.                         subIndex = d->transfers[line].subIndex;  
  1709.                         /* 是否支持crc校验 */  
  1710.                         d->transfers[line].peerCRCsupport = ((m->data[0])>>2) & 1;  
  1711.                         /* 块数量 */  
  1712.                         d->transfers[line].blksize = m->data[4];  
  1713.                     }  
  1714.                     /* 服务器->客户端：块下载 */  
  1715.                     else   
  1716.                     {  
  1717.                         /* 块数量 */  
  1718.                         d->transfers[line].blksize = m->data[2];  
  1719.                         /* 序列号 */  
  1720.                         AckSeq = (m->data[1]) & 0x7f;  
  1721.                         /* 获取sdo传输通道缓冲区剩余字节数 */  
  1722.                         getSDOlineRestBytes(d, line, &nbBytes);  
  1723.                         /* 如果剩余字节数为0，并且序列号校验通过 */  
  1724.                         if((nbBytes == 0) && (AckSeq == d->transfers[line].seqno))  
  1725.                         {  
  1726.                             /* 块下载结束 */  
  1727.                             data[0] = (6 << 5) | ((d->transfers[line].endfield) << 2) | SDO_BCS_END_DOWNLOAD_REQUEST;  
  1728.                             /* 数据填0 */  
  1729.                             for(i = 1; i < 8; i++)  
  1730.                                 data[i] = 0;  
  1731.                               
  1732.                             MSG_WAR(0x3AA5, "SDO. Sending block END download request defined at index 0x1200 + ", CliServNbr);  
  1733.                               
  1734.                             /* 发送sdo报文 */  
  1735.                             sendSDO(d, whoami, CliServNbr, data);  
  1736.                             break;  
  1737.                         }  
  1738.                         /* 如果剩余字节数不为0 */  
  1739.                         else  
  1740.                             d->transfers[line].offset = d->transfers[line].lastblockoffset + 7 * AckSeq;  
  1741.                           
  1742.                         if(d->transfers[line].offset > d->transfers[line].count)   
  1743.                         {  
  1744.                             MSG_ERR(0x1AA1, "SDO error : Received upload segment with bad ackseq index 0x1200 + ", CliServNbr);  
  1745.                             failedSDO(d, CliServNbr, whoami, 0, 0, SDOABT_LOCAL_CTRL_ERROR);  
  1746.                             return 0xFF;  
  1747.                         }  
  1748.                     }  
  1749.                     /* 上一次内存块发送完后传输通道的偏移量 */  
  1750.                     d->transfers[line].lastblockoffset = (UNS8)d->transfers[line].offset;  
  1751.                     /* 将数据分块发送出去，不能超过从站指定的最大块数量 */  
  1752.                     for(SeqNo = 1; SeqNo <= d->transfers[line].blksize; SeqNo++)   
  1753.                     {  
  1754.                         /* 块序列号 */  
  1755.                         d->transfers[line].seqno = SeqNo;  
  1756.                         /* 获取传输通道剩余字节数 */  
  1757.                         getSDOlineRestBytes(d, line, &nbBytes);  
  1758.                         /* 如果剩余字节数大于7 */  
  1759.                         if(nbBytes > 7)   
  1760.                         {  
  1761.                             /* 块序列号，最高位表示是否最后一块 */  
  1762.                             data[0] = SeqNo;  
  1763.                             /* 将传输通道缓冲区数据拷贝到sdo报文中 */  
  1764.                             err = lineToSDO(d, line, 7, data + 1);  
  1765.                             if(err)   
  1766.                             {  
  1767.                                 failedSDO(d, CliServNbr, whoami, index, subIndex, SDOABT_GENERAL_ERROR);  
  1768.                                 return 0xFF;  
  1769.                             }  
  1770.                               
  1771.                             MSG_WAR(0x3AAB, "SDO. Sending download segment to node id ", nodeId);  
  1772.                               
  1773.                             /* 发送报文 */  
  1774.                             sendSDO(d, whoami, CliServNbr, data);  
  1775.                         }  
  1776.                         /* 如果剩余字节数不大于7，说明这是最后一块 */  
  1777.                         else   
  1778.                         {  
  1779.                             /* 块序列号，最高位表示是否最后一块 */  
  1780.                             data[0] = 0x80 | SeqNo;  
  1781.                             /* 将传输通道缓冲区数据拷贝到sdo报文中 */  
  1782.                             err = lineToSDO(d, line, nbBytes, data + 1);  
  1783.                             if(err)   
  1784.                             {  
  1785.                                 failedSDO(d, CliServNbr, whoami, index, subIndex, SDOABT_GENERAL_ERROR);  
  1786.                                 return 0xFF;  
  1787.                             }  
  1788.                               
  1789.                             /* 不足8字节补0 */  
  1790.                             for(i = nbBytes + 1; i < 8; i++)  
  1791.                                 data[i] = 0;  
  1792.                               
  1793.                             MSG_WAR(0x3AAB, "SDO. Sending last download segment to node id ", nodeId);  
  1794.                               
  1795.                             /* 发送报文 */  
  1796.                             sendSDO(d, whoami, CliServNbr, data);  
  1797.                               
  1798.                             /* 最后一个块数据包中，补0的字节数 */  
  1799.                             d->transfers[line].endfield = (UNS8)(7 - nbBytes);  
  1800.                             break;  
  1801.                         }  
  1802.                     }  
  1803.                 }  
  1804.                 /* 服务器->客户端：块下载结束 */  
  1805.                 else if(SubCommand == SDO_BSS_END_DOWNLOAD_RESPONSE)   
  1806.                 {  
  1807.                     MSG_WAR(0x3AAC, "SDO End block download response from nodeId", nodeId);  
  1808.                       
  1809.                     /* 停止sdo传输超时定时器 */  
  1810.                     StopSDO_TIMER(line)  
  1811.                     /* 传输通道状态置为传输完成 */  
  1812.                     d->transfers[line].state = SDO_FINISHED;  
  1813.                       
  1814.                     /* 传输完成调用回调函数 */  
  1815.                     if(d->transfers[line].Callback)   
  1816.                         (*d->transfers[line].Callback)(d, nodeId);  
  1817.                     return 0x00;  
  1818.                 }  
  1819.                 /* 错误指令 */  
  1820.                 else   
  1821.                 {  
  1822.                     MSG_ERR(0x1AAB, "SDO error block download : Received wrong subcommand from nodeId", nodeId);  
  1823.                     failedSDO(d, CliServNbr, whoami, 0, 0, SDOABT_LOCAL_CTRL_ERROR);  
  1824.                 return 0xFF;  
  1825.                 }  
  1826.             }  
  1827.             break;  
  1828.   
  1829.         /* 客户端->服务器：块下载初始化/客户端->服务器：块下载/客户端->服务器：块下载结束 */  
  1830.         /* 服务器->客户端：块上传初始化/服务器->客户端：块上传/服务器->客户端：块上传结束 */  
  1831.         case 6:  
  1832.             /* 客户端->服务器：块下载初始化/客户端->服务器：块下载/客户端->服务器：块下载结束 */  
  1833.             if(whoami == SDO_SERVER)   
  1834.             {  
  1835.                 /* 如果传输通道未建立，则说明客户端->服务器：块下载初始化 */  
  1836.                 if(err)   
  1837.                 {  
  1838.                     /* 取出子命令，判断是否为块下载初始化 */  
  1839.                     SubCommand = (m->data[0]) & 1;  
  1840.                     if(SubCommand != SDO_BCS_INITIATE_DOWNLOAD_REQUEST)   
  1841.                     {  
  1842.                         MSG_ERR(0x1AAC, "SDO error block download : Received wrong subcommand from node id", nodeId);  
  1843.                         failedSDO(d, CliServNbr, whoami, 0, 0, SDOABT_LOCAL_CTRL_ERROR);  
  1844.                           
  1845.                         return 0xFF;  
  1846.                   }  
  1847.                       
  1848.                     /* 取出索引 */  
  1849.                     index = getSDOindex(m->data[1], m->data[2]);  
  1850.                     /* 取出子索引 */  
  1851.                     subIndex = getSDOsubIndex(m->data[3]);  

你可能感兴趣的:(STM32)

  • STM32中的计时与延时 lupinjia STM32stm32单片机
    前言在裸机开发中，延时作为一种规定循环周期的方式经常被使用，其中尤以HAL库官方提供的HAL_Delay为甚。刚入门的小白可能会觉得既然有官方提供的延时函数，而且精度也还挺好，为什么不用呢？实际上HAL_Delay中有不少坑，而这些也只是HAL库中无数坑的其中一些。想从坑里跳出来还是得加强外设原理的学习和理解，切不可只依赖HAL库。除了延时之外，我们在开发中有时也会想要确定某段程序的耗时，这就需要
  • 基于STM32与Qt的自动平衡机器人：从控制到人机交互的的详细设计流程 极客小张 stm32qt机器人物联网人机交互毕业设计c语言
    一、项目概述目标和用途本项目旨在开发一款基于STM32控制的自动平衡机器人，结合步进电机和陀螺仪传感器，实现对平衡机器人的精确控制。该机器人可以用于教育、科研、娱乐等多个领域，帮助用户了解自动控制、机器人运动学等相关知识。技术栈关键词STM32单片机步进电机陀螺仪传感器AD采集电路Qt人机界面实时数据监控二、系统架构系统架构设计本项目的系统架构设计包括以下主要组件：控制单元:STM32单片机传感器
  • 基于STM32的汽车仪表显示系统：集成CAN、UART与I2C总线设计流程 极客小张 stm32汽车嵌入式硬件物联网单片机c语言
    一、项目概述项目目标与用途本项目旨在设计和实现一个基于STM32微控制器的汽车仪表显示系统。该系统能够实时显示汽车的速度、转速、油量等关键信息，并通过CAN总线与其他汽车控制单元进行通信。这种仪表显示系统不仅提高了驾驶的安全性和便捷性，还能为汽车提供更智能的用户体验。技术栈关键词微控制器：STM32显示技术：TFTLCD/OLED传感器：速度传感器、温度传感器、油量传感器通信协议：CAN总线、UA
  • 基于STM32的简易RTOS分析-预备知识 騏威 嵌入式
    写下这篇文章的主要目的是对自己学习RTOS的历程做一个记录和总结，方便以后回忆翻看。以下内容主要来自宋岩先生翻译的《Cortex-M3权威指南》。目录一、Cortex-M3寄存器简介二、堆栈操作简介三、汇编指令简介LDR和STR指令STMDB和LDMIA指令B、BX、BL、BLX指令MRS和MSR指令四、中断简介中断响应过程简介SVC和PensSV中断简介软件中断五、汇编基础一、Cortex-M3
  • 15-自编写rtos-结合stm32实际调试(ladylolo-os) Ladylolo-lsm stm32嵌入式硬件单片机
    一、任务调度:1.理解:任务切换，用堆栈指针SP保存即将要切换的任务的前后文，然后是用PendSV来执行这些操作的；由于是基于优先级的调度策略，所以每次“心跳”都会看有没有优先级更高的出现，如果有就用PendSV进行上下文切换。2.编写部分:①每个任务自己的属性统称为TCB任务控制块。②任务就绪表有设置优先级(设置的时候变量或上优先级的变量让某个位数等于1)，从任务就绪表中删除(删除时用与来得等于
  • 小米嵌入式面试题目RTOS面试题目 嵌入式面试题目 好家伙VCC 面试杂谈杂谈面试职场和发展
    第一章-非RTOSbootloader工作流程MCU启动流程通信协议，SPIIICMCU怎么选型，STM32F1和F4有什么区别外部RAM和内部RAM区别，怎么分配外部总线和内部总线区别MCU上的固件，数据是怎么分配的MCU启动流程IAP是怎么升级的，突然断电怎么办挑了麦轮项目（因为大疆RM也是麦轮，面试官看样子比较感兴趣）为什么用的CAN总线你说一下spi和i2c和UART的各自的工作方式优缺点
  • 基于STM32F103C8T6定时器的PWM通道的重映射 —你的鼬先生 stm32嵌入式硬件单片机
    在我们平时的的使用中，我们最常使用的是TIM2和TIM3的PWM通道，但是由于C8T6的IO口有限，所以可能会出现PWM通道的资源不够的情况，从而我们可能会使用PWM4的PWM通道，但是TIM4的PWM通道并不能直接使用，它需要进行一个重映射，不然可能会导致PWM波不能正常发送。以下就是对PWM4的PWM通道进行一个重映射#include"stm32f10x.h"//Deviceheadervoi
  • 【STM32系统】基于STM32设计的锂电池电量/电压检测报警器系统——文末完整资料下载（程序源码/电路原理图/电路PCB/设计文档/模块资料/元器件清单/实物图/答辩问题技巧/PPT模版等） 阿齐Archie 单片机嵌入式项目stm32嵌入式硬件单片机
    基于STM32设计的锂电池电量/电压检测报警器系统系统视频：摘要：本设计旨在研究一个基于STM32F103C8T6微控制器的锂电池电量/电压检测报警器系统，应用于便携式电子设备电池管理。系统通过STM32的ADC模块对锂电池电压进行采集，利用LCD1602显示模块实时显示电池电压，当检测到电池电量不足或电压异常时，蜂鸣器报警模块会发出警报提醒用户。系统采用简单的硬件结构和优化的软件架构，通过对实际
  • 使用STM32实现简单的智能温控系统 棂梓知识 stm32单片机嵌入式硬件
    智能温控系统是一种能够根据环境温度实时调整设备的工作状态的系统。在本篇文章中，我们将使用STM32微控制器来实现一个简单的智能温控系统。该系统将会有以下功能：实时监测环境温度，并显示在LCD屏幕上。当环境温度超过设定的阈值时，自动开启风扇。当环境温度恢复正常时，自动关闭风扇。通过按键模拟调节设定的阈值。系统设计首先，我们需要准备一些硬件设备。具体而言，我们需要以下组件：STM32F103C8T6开
  • STM32 HAL freertos零基础（九）任务通知 啥也不会的小白研究生 零基础学习Freertosstm32嵌入式硬件单片机
    1、任务通知任务通知用于任务之间同步和通信。任务通知允许一个任务向另一个任务发送一个32位的值，并可以选择是否唤醒正在等待通知的任务。这使得任务之间的同步更加简单和灵活。任务通知功能：发送通知：一个任务可以向另一个任务发送一个32位的值。接收通知：接收任务可以根据接收到的通知来决定何时执行某些操作。通知状态：可以检查任务的当前通知状态。2、相关APIxTaskNotify()//发送通知，带有通知
  • 4×4矩阵键盘详解（STM32） 辰哥单片机设计 STM32传感器教学矩阵计算机外设stm32嵌入式硬件单片机传感器
    目录一、介绍二、传感器原理1.原理图2.工作原理介绍三、程序设计main.c文件button4_4.h文件button4_4.c文件四、实验效果五、资料获取项目分享一、介绍矩阵键盘，又称为行列式键盘，是用4条I/O线作为行线，4条I/O线作为列线组成的键盘。在行线和列线的每一个交叉点上设置一个按键，因此键盘中按键的个数是4×4个。这种行列式键盘结构能够有效地提高单片机系统中I/O口的利用率，节约单
  • STM32的寄存器深度解析 千千道 STM32stm32单片机物联网
    目录一、STM32寄存器概述二、寄存器的定义与作用三、寄存器分类1.内核寄存器2.外设寄存器四、重要寄存器详解1.GPIO相关寄存器2.定时器相关寄存器3.中断相关寄存器4.RCC相关寄存器五、寄存器操作方法1.直接操作寄存器2.使用库函数操作寄存器六、总结在嵌入式系统开发中，STM32微控制器以其强大的性能和丰富的功能而备受青睐。而理解和掌握STM32的寄存器是深入学习和开发STM32的关键。本
  • STM32 如何生成随机数 千千道 STM32stm32单片机物联网
    目录一、引言二、STM32随机数发生器概述三、工作原理1.噪声源2.线性反馈移位寄存器（LFSR）3.数据寄存器（RNG_DR）4.监控和检测电路：5.控制和状态寄存器6.生成流程四、使用方法1.使能随机数发生器2.读取随机数3.错误处理五、注意事项1.随机数的质量2.安全性3.性能考虑六、总结一、引言在嵌入式系统开发中，随机数的生成常常是一个重要的需求。无论是用于加密、模拟、游戏还是其他需要不确
  • STM32——看门狗通俗解析 百里与司空 stm32嵌入式硬件单片机门控循环单元
    笔者在学习看门狗的视频后，对看门狗仍然是一知半解，后面在实际应用中发现它是一个很好用的检测或者调试工具。所以总结一下笔者作为初学小白对看门狗的理解。主函数初始化阶段、循环阶段和复位众所周知，程序的运行一般是这样的：程序在进入循环阶段之前，会在初始化阶段将每个寄存器或者某些变量赋值。初始化阶段的代码执行一次后，就不再执行了。而循环阶段的代码会执行很多次，一直循环反复的执行下去。这时，如果进行了复位，
  • STM32 的 RTC（实时时钟）详解 千千道 STM32stm32物联网单片机
    目录一、引言二、RTC概述三、RTC的工作原理1.时钟源2.计数器3.闹钟功能4.备份寄存器四、RTC寄存器1.RTC_TR（TimeRegister，时间寄存器）2.RTC_DR（DateRegister，日期寄存器）3.RTC_SSR（SubsecondRegister，亚秒寄存器）4.RTC_PRER（PrescalerRegister，预分频器寄存器）5.RTC_CR（ControlReg
  • 2020-11-12 写单片机内存的脚本 nc openocd 事务自动测试 linuxScripter
    这是写单片机内存的脚本：z@z-ThinkPad-T400:~/zworkT400/EDA_heiche/zREPOgit/simple-gcc-stm32-project$catz.wholeRun.oneCase.cmdcattmp6.toWrite|awk'{system("echomwb"$1""$2"|nclocalhost4444");}'catUSER/DEBUG/debug.h|g
  • arm-none-eabi-gcc 不识别__attribute__((at(xxx))命令如何将数据定义到外部SDAM（已验证） 梓默 #C
    提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录可以利用__attribute__((section(".xxx")))实现同样的效果步骤：1.在linker链接文件中添加指定SDRAM加偏移地址2.添加SDRAM自定义section3.将数据定义到自定义区可以利用__attribute__((section(".xxx")))实现同样的效果步骤：从STM32H7xx参考手
  • Error: No STM32 target found! If your product embeds Debug Authentication, please perform a discover BABA8891 stm32嵌入式硬件单片机
    这个错误信息“Error:NoSTM32targetfound!IfyourproductembedsDebugAuthentication,pleaseperformadiscoveryusingDebugAuthentication”通常出现在使用STM32微控制器的开发过程中，尤其是在尝试通过调试接口（如SWD或JTAG）与设备通信时。这个错误表明调试器或开发工具无法识别或连接到STM32目
  • STM32与ESP8266的使用 每天的积累 嵌入式学习日记stm32stm32单片机嵌入式硬件
    串口透传“透传”通常指的是数据的透明传输，意思是在不对数据进行任何处理或修改的情况下，将数据从一个接口转发到另一个接口。值得注意的是要避免串口之间无限制的透明，可以采用互斥锁的方式进行限制使用方法对USART1和USART3(用他俩举例)的模式都是设置为Asynchronous，并开启对应的中断。RCC的HighSPeedCLock模式设置为Crystal/Ceramic配置对应的时钟为64Mhz
  • ARM-Cortex-M架构：1、STM32函数参数传递 天城寺电子 嵌入式软件开发arm开发stm32汇编C语言
    文章目录参数传递概览堆栈传递参数具体过程参数传递概览在调用子函数时，ARMCortex-M3处理器可以使用寄存器和堆栈来传递参数。具体使用哪种方式取决于传递的参数数量和调用约定（callingconvention）。参数传递方式ARMCortex-M3处理器使用ARMEABI(EmbeddedApplicationBinaryInterface)标准来定义参数传递的约定。根据这个约定：1、寄存器传
  • 物流系统中的嵌入式：STM32微控制器与智能算法驱动的物理循迹小车详细流程 极客小张 stm32嵌入式硬件单片机机器人算法物联网c语言
    一、项目概述本项目旨在开发一款基于STM32微控制器的物理循迹小车，具备二维码识别能力，并能够将物品送到指定的物流位置。通过传感器和算法的结合，小车将实现自主导航和路径规划，从而提高物流效率和准确性。项目的目标是为智能物流提供一种新颖的解决方案，适用于仓库、工厂等场景。技术栈关键词硬件平台：STM32微控制器（如STM32F4系列）传感器：红外循迹传感器、摄像头模块、超声波传感器驱动模块：电机驱动
  • 大疆开发型c板BMI088-IMU零漂问题优化解决（1） 一流L 单片机stm32嵌入式硬件
    在基于clion开发大疆开发型c板STM32F407IG过程中出现的零点漂移严重情况的解决1.首先我们先了解一下IMU零漂校准IMU数据的目的是消除传感器本身固有的偏差和不确定性，使得测量数据更加准确和可靠。在这个函数中，校准过程主要是通过乘以比例因子和加上偏移量来实现的，具体步骤如下：首先需要进行传感器的零偏校准（offsetcalibration）。这一步骤的目的是测量出传感器在静止状态下的输
  • STM32裸机-时间片任务轮询 妖异的小尾巴 代码结构
    瞎逼逼部分程序的编写裸机有几大类，分别是顺序执行前后台程序时间片任务轮询带系统的程序我们平常学习裸机开发程序中最常使用的可能就是顺序执行和前后台程序程序顺序执行的示例简单直接，直接往while(1)循环里放就是了前后台程序则是在顺序执行的基础上加上了中断，用于处理一些外部信号和比较紧急的事件但是这样出来的程序，实际的运行效果就比较乱了，我们无法确定某段程序能不能在我们需要的时候调用，比如让一些实时
  • STM32 Cube IDE HAL库驱动 W25Q128 进行读、写、擦除操作_w25q128驱动程序(1) 2401_85012262 2024年程序员学习物联网嵌入式硬件面试
    收集整理了一份《2024年最新物联网嵌入式全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升的朋友。如果你需要这些资料，可以戳这里获取需要这些体系化资料的朋友，可以加我V获取：vip1024c（备注嵌入式）一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习
  • stm32 RTC guanjianhe
    #include"stm32f10x.h"staticvoidRTC_Configuration(void){/*使能PWR和Backup时钟*/RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR|RCC_APB1Periph_BKP,ENABLE);/*允许访问Backup区域*/PWR_BackupAccessCmd(ENABLE);/*复位Backup区域*/
  • 基于STM32F407实现土壤湿度检测 Yu.y1 stm32单片机嵌入式硬件
    土壤湿度传感器它利用电磁脉冲原理、根据电磁波在介质中传播频率来测量土壤的表观介电常数,从而得到土壤相对含水量。代码流程1.看原理图确定GPIO与ADC通道PA5，ADC1IN52.配置GPIO为模拟模式3.ADC初始化a.结构体申明ADC_CommonInitTypeDefb.时钟使能c.结构体配置d.初始化4.ADC通道初始化a.结构体申明ADC_InitTypeDefb.结构体配置c.初始化5
  • stm32f4串口接收与发送 朴实妲己 单片机stm32嵌入式硬件
    之前有写一篇stm32f1串口接收与发送的文章，stm32f4与f1只有配置上的一点不同，今天把f4的串口接收与发送代码分享一下详细解释推荐大家看f1那篇，都是一样的，stm32f1串口发送与接收_居安士的博客-CSDN博客_stm32串口通信的接收与发送直接上代码voiduart_init(u32bound){//GPIO端口设置GPIO_InitTypeDefGPIO_InitStructur
  • STM32 HAL freertos零基础（六）计数型信号量 啥也不会的小白研究生 零基础学习Freertosstm32嵌入式硬件单片机
    1、计数型信号量计数型信号量（CountingSemaphore）是另一种类型的信号量，它可以保持一个大于等于0的整数值，这个值表示可用资源的数量。本质上相当于队列长度大于1得队列。经典问题就是剩余车辆统计，出入车辆，车辆数据可以实时更新。2、相关API函数xSemaphoreCreateCounting()//使用动态方法创建计数型信号量。xSemaphoreCreateCountingStat
  • STM32实现简单的智能手环 心梓知识 stm32单片机嵌入式硬件
    智能手环是一种智能穿戴设备，可以用于监测用户的运动、心率、睡眠等健康数据，并提供相应的分析和提醒功能。在本案例中，我们将使用STM32微控制器来实现一个简单的智能手环。首先，我们需要准备以下硬件和软件：STM32开发板（如STM32F103C8T6）OLED显示屏（128x64像素）心率传感器模块（如MAX30102）加速度传感器模块（如MPU6050）蓝牙模块（如HC-05）KeilMDK开发环
  • STM32 HAL freertos零基础（七）互斥量 啥也不会的小白研究生 零基础学习Freertosstm32嵌入式硬件单片机
    1、互斥量互斥量主要用于保护共享资源的访问，确保在同一时刻只有一个任务可以访问该资源。互斥性：当一个任务获取了一个互斥量后，其他任务将无法再获取同一个互斥量，直到原始任务释放该互斥量。优先级继承：为了防止优先级反转问题，FreeRTOS的互斥量支持优先级继承机制。当一个高优先级任务被低优先级任务阻塞时，低优先级任务会暂时提升自己的优先级，以尽快释放互斥量，让高优先级任务继续执行。递归锁定：互斥量支
  • SAX解析xml文件 小猪猪08 xml
    1.创建SAXParserFactory实例 2.通过SAXParserFactory对象获取SAXParser实例 3.创建一个类SAXParserHander继续DefaultHandler，并且实例化这个类 4.SAXParser实例的parse来获取文件     public static void main(String[] args) { //
  • 为什么mysql里的ibdata1文件不断的增长？ brotherlamp linuxlinux运维linux资料linux视频linux运维自学
    我们在 Percona 支持栏目经常收到关于 MySQL 的 ibdata1 文件的这个问题。 当监控服务器发送一个关于 MySQL 服务器存储的报警时，恐慌就开始了 —— 就是说磁盘快要满了。 一番调查后你意识到大多数地盘空间被 InnoDB 的共享表空间 ibdata1 使用。而你已经启用了 innodbfileper_table，所以问题是： ibdata1存了什么？ 当你启用了 i
  • Quartz-quartz.properties配置 eksliang quartz
    其实Quartz JAR文件的org.quartz包下就包含了一个quartz.properties属性配置文件并提供了默认设置。如果需要调整默认配置，可以在类路径下建立一个新的quartz.properties，它将自动被Quartz加载并覆盖默认的设置。   下面是这些默认值的解释 #-----集群的配置 org.quartz.scheduler.instanceName =
  • informatica session的使用 18289753290 workflowsessionlogInformatica
    如果希望workflow存储最近20次的log，在session里的Config  Object设置，log  options做配置，save  session log :sessions  run  ;savesessio log for  these runs:20 session下面的source 里面有个tracing 
  • Scrapy抓取网页时出现CRC check failed 0x471e6e9a != 0x7c07b839L的错误 酷的飞上天空 scrapy
    Scrapy版本0.14.4 出现问题现象： ERROR: Error downloading <GET http://xxxxx  CRC check failed   解决方法   1.设置网络请求时的header中的属性'Accept-Encoding': '*;q=0'   明确表示不支持任何形式的压缩格式，避免程序的解压
  • java Swing小集锦 永夜-极光 java swing
    1.关闭窗体弹出确认对话框   1.1   this.setDefaultCloseOperation (JFrame.DO_NOTHING_ON_CLOSE);   1.2   this.addWindowListener ( new WindowAdapter () { public void windo
  • 强制删除.svn文件夹 随便小屋 java
              在windows上，从别处复制的项目中可能带有.svn文件夹，手动删除太麻烦，并且每个文件夹下都有。所以写了个程序进行删除。因为.svn文件夹在windows上是只读的，所以用File中的delete()和deleteOnExist()方法都不能将其删除，所以只能采用windows命令方式进行删除
  • GET和POST有什么区别？及为什么网上的多数答案都是错的。 aijuans get post
        如果有人问你，GET和POST，有什么区别？你会如何回答？ 我的经历      前几天有人问我这个问题。我说GET是用于获取数据的，POST，一般用于将数据发给服务器之用。     这个答案好像并不是他想要的。于是他继续追问有没有别的区别？我说这就是个名字而已，如果服务器支持，他完全可以把G
  • 谈谈新浪微博背后的那些算法 aoyouzi 谈谈新浪微博背后的那些算法
    本文对微博中常见的问题的对应算法进行了简单的介绍，在实际应用中的算法比介绍的要复杂的多。当然，本文覆盖的主题并不全，比如好友推荐、热点跟踪等就没有涉及到。但古人云“窥一斑而见全豹”，希望本文的介绍能帮助大家更好的理解微博这样的社交网络应用。 微博是一个很多人都在用的社交应用。天天刷微博的人每天都会进行着这样几个操作：原创、转发、回复、阅读、关注、@等。其中，前四个是针对短博文，最后的关注和@则针
  • Connection reset 连接被重置的解决方法 百合不是茶 java字符流连接被重置
    流是java的核心部分,,昨天在做android服务器连接服务器的时候出了问题,就将代码放到java中执行,结果还是一样连接被重置   被重置的代码如下;   客户端代码; package 通信软件服务器; import java.io.BufferedWriter; import java.io.OutputStream; import java.io.O
  • web.xml配置详解之filter bijian1013 javaweb.xmlfilter
    一.定义 <filter> <filter-name>encodingfilter</filter-name> <filter-class>com.my.app.EncodingFilter</filter-class> <init-param> <param-name>encoding<
  • Heritrix Bill_chen 多线程xml算法制造配置管理
    作为纯Java语言开发的、功能强大的网络爬虫Heritrix，其功能极其强大，且扩展性良好，深受热爱搜索技术的盆友们的喜爱，但它配置较为复杂，且源码不好理解，最近又使劲看了下，结合自己的学习和理解，跟大家分享Heritrix的点点滴滴。 Heritrix的下载（http://sourceforge.net/projects/archive-crawler/）安装、配置，就不罗嗦了，可以自己找找资
  • 【Zookeeper】FAQ bit1129 zookeeper
    1.脱离IDE，运行简单的Java客户端程序 #ZkClient是简单的Zookeeper~$ java -cp "./:zookeeper-3.4.6.jar:./lib/*" ZKClient    1. Zookeeper是的Watcher回调是同步操作，需要添加异步处理的代码 2. 如果Zookeeper集群跨越多个机房，那么Leader/
  • The user specified as a definer ('aaa'@'localhost') does not exist 白糖_ localhost
    今天遇到一个客户BUG，当前的jdbc连接用户是root，然后部分删除操作都会报下面这个错误：The user specified as a definer ('aaa'@'localhost') does not exist 最后找原因发现删除操作做了触发器，而触发器里面有这样一句 /*!50017 DEFINER = ''aaa@'localhost' */  原来最初
  • javascript中showModelDialog刷新父页面 bozch JavaScript刷新父页面showModalDialog
    在页面中使用showModalDialog打开模式子页面窗口的时候，如果想在子页面中操作父页面中的某个节点，可以通过如下的进行：       window.showModalDialog('url',self,‘status...’); // 首先中间参数使用self       在子页面使用w
  • 编程之美-买书折扣 bylijinnan 编程之美
    import java.util.Arrays; public class BookDiscount { /**编程之美 买书折扣 书上的贪心算法的分析很有意思，我看了半天看不懂，结果作者说，贪心算法在这个问题上是不适用的。。 下面用动态规划实现。 哈利波特这本书一共有五卷，每卷都是8欧元，如果读者一次购买不同的两卷可扣除5%的折扣，三卷10%，四卷20%，五卷
  • 关于struts2.3.4项目跨站执行脚本以及远程执行漏洞修复概要 chenbowen00 strutsWEB安全
    因为近期负责的几个银行系统软件，需要交付客户，因此客户专门请了安全公司对系统进行了安全评测，结果发现了诸如跨站执行脚本，远程执行漏洞以及弱口令等问题。 下面记录下本次解决的过程以便后续 1、首先从最简单的开始处理，服务器的弱口令问题，首先根据安全工具提供的测试描述中发现应用服务器中存在一个匿名用户，默认是不需要密码的，经过分析发现服务器使用了FTP协议， 而使用ftp协议默认会产生一个匿名用
  • [电力与暖气]煤炭燃烧与电力加温 comsci
          在宇宙中,用贝塔射线观测地球某个部分,看上去,好像一个个马蜂窝,又像珊瑚礁一样,原来是某个国家的采煤区.....       不过,这个采煤区的煤炭看来是要用完了.....那么依赖将起燃烧并取暖的城市,在极度严寒的季节中...该怎么办呢?   &nbs
  • oracle O7_DICTIONARY_ACCESSIBILITY参数 daizj oracle
    O7_DICTIONARY_ACCESSIBILITY参数控制对数据字典的访问.设置为true,如果用户被授予了如select any table等any table权限,用户即使不是dba或sysdba用户也可以访问数据字典.在9i及以上版本默认为false,8i及以前版本默认为true.如果设置为true就可能会带来安全上的一些问题.这也就为什么O7_DICTIONARY_ACCESSIBIL
  • 比较全面的MySQL优化参考 dengkane mysql
    本文整理了一些MySQL的通用优化方法，做个简单的总结分享，旨在帮助那些没有专职MySQL DBA的企业做好基本的优化工作，至于具体的SQL优化，大部分通过加适当的索引即可达到效果，更复杂的就需要具体分析了，可以参考本站的一些优化案例或者联系我，下方有我的联系方式。这是上篇。   1、硬件层相关优化   1.1、CPU相关   在服务器的BIOS设置中，可
  • C语言homework2，有一个逆序打印数字的小算法 dcj3sjt126com c
    #h1#   0、完成课堂例子 1、将一个四位数逆序打印 1234 ==> 4321 实现方法一： # include <stdio.h> int main(void) { int i = 1234; int one = i%10; int two = i / 10 % 10; int three = i / 100 % 10;
  • apacheBench对网站进行压力测试 dcj3sjt126com apachebench
       ab 的全称是 ApacheBench ， 是 Apache 附带的一个小工具 ， 专门用于 HTTP Server 的 benchmark testing ， 可以同时模拟多个并发请求。前段时间看到公司的开发人员也在用它作一些测试，看起来也不错，很简单，也很容易使用，所以今天花一点时间看了一下。 通过下面的一个简单的例子和注释，相信大家可以更容易理解这个工具的使用。
  • 2种办法让HashMap线程安全 flyfoxs javajdkjni
    多线程之--2种办法让HashMap线程安全 多线程之--synchronized 和reentrantlock的优缺点 多线程之--2种JAVA乐观锁的比较( NonfairSync VS. FairSync)     HashMap不是线程安全的,往往在写程序时需要通过一些方法来回避.其实JDK原生的提供了2种方法让HashMap支持线程安全.  
  • Spring Security（04）——认证简介 234390216 Spring Security认证过程
    认证简介 目录 1.1     认证过程 1.2     Web应用的认证过程 1.2.1    ExceptionTranslationFilter 1.2.2    在request之间共享SecurityContext   1
  • Java 位运算 Javahuhui java位运算
    // 左移( << ) 低位补0 // 0000 0000 0000 0000 0000 0000 0000 0110 然后左移2位后，低位补0： // 0000 0000 0000 0000 0000 0000 0001 1000 System.out.println(6 << 2);// 运行结果是24 // 右移( >> ) 高位补"
  • mysql免安装版配置 ldzyz007 mysql
    1、my-small.ini是为了小型数据库而设计的。不应该把这个模型用于含有一些常用项目的数据库。 2、my-medium.ini是为中等规模的数据库而设计的。如果你正在企业中使用RHEL,可能会比这个操作系统的最小RAM需求(256MB)明显多得多的物理内存。由此可见，如果有那么多RAM内存可以使用，自然可以在同一台机器上运行其它服务。 3、my-large.ini是为专用于一个SQL数据
  • MFC和ado数据库使用时遇到的问题 你不认识的休道人 sqlC++mfc
    =================================================================== 第一个 =================================================================== try{ CString sql; sql.Format("select * from p
  • 表单重复提交Double Submits rensanning double
    可能发生的场景： *多次点击提交按钮 *刷新页面 *点击浏览器回退按钮 *直接访问收藏夹中的地址 *重复发送HTTP请求（Ajax） （1）点击按钮后disable该按钮一会儿，这样能避免急躁的用户频繁点击按钮。 这种方法确实有些粗暴，友好一点的可以把按钮的文字变一下做个提示，比如Bootstrap的做法： http://getbootstrap.co
  • Java String 十大常见问题 tomcat_oracle java正则表达式
    　1.字符串比较，使用“==”还是equals()? 　　"=="判断两个引用的是不是同一个内存地址(同一个物理对象)。 　　equals()判断两个字符串的值是否相等。 　　除非你想判断两个string引用是否同一个对象，否则应该总是使用equals()方法。 　　如果你了解字符串的驻留(String Interning)则会更好地理解这个问题。 　 　
  • SpringMVC 登陆拦截器实现登陆控制 xp9802 springMVC
    思路，先登陆后，将登陆信息存储在session中，然后通过拦截器，对系统中的页面和资源进行访问拦截，同时对于登陆本身相关的页面和资源不拦截。   实现方法： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他