【RL-TCPnet网络教程】第13章 RL-TCPnet之TCP服务器

席萌0209

第13章      RL-TCPnet之TCP服务器

        本章节为大家讲解RL-TCPnet的TCP服务器实现，学习本章节前，务必要优先学习第12章TCP传输控制协议基础知识。有了这些基础知识之后，再搞本章节会有事半功倍的效果。
        本章教程含STM32F407开发板和STM32F429开发板。
        13.1 初学者重要提示
        13.2 TCP服务器API函数
        13.3 TCP配置说明（Net_Config.c）
        13.4 TCP调试说明（Net_Debug.c）
        13.5 TCP服务器的实现方法
        13.6 网络调试助手和板子的调试操作步骤
        13.7 实验例程说明（裸机）
        13.8 实验例程说明（RTX）
        13.9      总结



13.1  初学者重要提示

1、学习本章节前，务必保证已经学习了第12章的基础知识。
2、本章要掌握的函数稍多，可以先学会基本的使用，然后再深入了解这些函数使用时的注意事项，争取达到熟练使用。
3、socket和监听的关系：
    （1）创建的一个socket只能创建一个监听。
    （2）创建的一个socket不能够监听多个 。
    （3）创建多个socket可以创建多个监听。
    （4）创建多个socket可以仅创建一个监听。

席萌0209

13.2 TCP服务器API函数


        使用如下12个函数可以实现RL-TCPnet的TCP通信：
（1） tcp_get_socket
（2） tcp_connect
（3） tcp_listen
（4） tcp_close
（5） tcp_abort
（6）tcp_release_socket
（7） tcp_get_buf
（8） tcp_max_dsize
（9） tcp_send
（10） tcp_get_state
（11） tcp_check_send
（12） tcp_reset_window
关于这12个函数的讲解及其使用方法可以看教程第 3 章 3.4 小节里面说的参考资料 rlarm.chm 文件：

这里我们重点的说以下7个函数，因为本章节配套的例子使用的是这 7 个函数：
（1）tcp_get_socket
（2）tcp_listen
（3）tcp_check_send
（4）tcp_max_dsize
（5）tcp_get_buf
（6）tcp_send
（7）tcp_get_state
关于这些函数注意以下两点：
（1）这些函数都不支持重入，也就是不支持多任务调用。
（2）TCP接口函数通过TCP Socket做数据传输，主要用于数据安全作为首选的场合。TCP Socket发送完数据后会等待应答，任何数据包失败都会重传。

13.2.1 函数tcp_get_socket


函数原型：

1. U8 tcp_get_socket (
2.     U8   type,          /* TCP Socket类型          */
3.     U8   tos,           /* TCP服务类型             */
4.     U16  tout,          /* 断开连接前的空闲溢出时间 */
5.     U16 (*listener)(    /* 回调函数                */
6.         U8  socket,     /* Socket句柄              */
7.         U8  event,      /* TCP事件                 */
8.         U8* ptr,        /* 记录接收到的数据或者远程机器的IP地址    */
9.         U16 par ));     /* 记录接收到的数据长度或者远程机器的端口号 */           [size=3][font=新宋体]         [/font][/size]

复制代码

函数描述：
函数tcp_get_socket用于获取一个TCP Socket。
（1）第1个参数是TCP Socket的类型。

（2） 第2个参数用于指定服务类型，默认取零即可。
（3）第3个参数用于设置空闲溢出时间，单位秒。Keep alive定时器用于监控TCP连接，如果连接的空闲时间（也就是长时间没有数据通信）超出了，那么会断开连接。如果设置了TCP_TYPE_KEEP_ALIVE属性，会通过发送keep alive数据包来保持连接。
（4）第4个参数是回调函数，用于事件监听。
        a. 回调函数第1个参数，TCP Socket的句柄，也就是函数tcp_get_socket的返回值。
        b. 回调函数第2个参数，事件类型。

         c. 回调函数第3个参数，事件类型是TCP_EVT_DATA，ptr指向的缓冲区记录着接收到的TCP数据，其余事件记录IP地址。
         d. 回调函数第4个参数，记录接收到的数据个数，其余事件记录端口号。
（5）返回值，如果获取成功，返回TCP Socket句柄，如果获取失败，返回0。
使用这个函数要注意以下问题：
1.     调用TCPSocket任何其它函数前，务必要调用此函数tcp_get_socket。
2.     使用函数tcp_get_socket，第四个参数的监听回调函数务必要设置。
3.     如果需要长时间连接，需要设置属性TCP_TYPE_KEEP_ALIVE。
使用举例：

1. /*
2. *********************************************************************************************************
3. *                                      用于本文件的调试
4. *********************************************************************************************************
5. */
6. #define PORT_NUM       1001    /* TCP服务器监听端口号 */
9. /*
10. *********************************************************************************************************
11. *                                         变量
12. *********************************************************************************************************
13. */
14. uint8_t socket_tcp;
17. /*
18. *********************************************************************************************************
19. *    函 数 名: tcp_callback
20. *    功能说明: TCP Socket的回调函数
21. *    形    参: soc  TCP Socket类型
22. *             evt  事件类型
23. *             ptr  事件类型是TCP_EVT_DATA，ptr指向的缓冲区记录着接收到的TCP数据，其余事件记录IP地址
24. *             par  事件类型是TCP_EVT_DATA，记录接收到的数据个数，其余事件记录端口号
25. *    返 回 值:
26. *********************************************************************************************************
27. */
28. U16 tcp_callback (U8 soc, U8 evt, U8 *ptr, U16 par)
29. {
30.      char buf[50];
31.      uint16_t i;
32.    
33.      /* 确保是socket_tcp的回调 */
34.      if (soc != socket_tcp)
35.      {
36.          return (0);
37.      }
39.      switch (evt)
40.      {
41.          /*
42.               远程客户端连接消息
43.              1、数组ptr存储远程设备的IP地址，par中存储端口号。
44.              2、返回数值1允许连接，返回数值0禁止连接。
45.          */
46.          case TCP_EVT_CONREQ:
47.               sprintf(buf, "远程客户端请求连接IP: %d.%d.%d.%d", ptr[0], ptr[1], ptr[2], ptr[3]);
48.               printf_debug("IP:%s  port:%d\\r\\n", buf, par);
49.               return (1);
50.         
51.          /* 连接终止 */
52.          case TCP_EVT_ABORT:
53.               break;
54.         
55.          /* Socket远程连接已经建立 */
56.          case TCP_EVT_CONNECT:
57.               printf_debug("Socket is connected to remote peer\\r\\n");
58.               break;
59.         
60.          /* 连接断开 */
61.          case TCP_EVT_CLOSE:
62.               printf_debug("Connection has been closed\\r\\n");
63.               break;
64.         
65.          /* 发送的数据收到远程设备应答 */
66.          case TCP_EVT_ACK:
67.               break;
68.         
69.          /* 接收到TCP数据帧，ptr指向数据地址，par记录数据长度，单位字节 */
70.          case TCP_EVT_DATA:
71.               printf_debug("Data length = %d\\r\\n", par);
72.               for(i = 0; i < par; i++)
73.               {
74.                    printf_debug("ptr[%d] = %d\\r\\n", i, ptr[i]);
75.               }
76.               break;
77.      }
78.    
79.      return (0);
80. }
82. /*
83. *********************************************************************************************************
84. *    函 数 名: TCPnetTest
85. *    功能说明: TCPnet应用
86. *    形    参: 无
87. *    返 回 值: 无
88. *********************************************************************************************************
89. */
90. void TCPnetTest(void)
91. {
92.      uint8_t res;
94.      /*
95.         创建TCP Socket并创建监听，客户端连接服务器后，10秒内无数据通信将断开连接。
96.         但是由于这里使能了TCP_TYPE_KEEP_ALIVE，会一直保持连接，不受10秒的时间限制。
97.      */
98.     socket_tcp = tcp_get_socket (TCP_TYPE_SERVER|TCP_TYPE_KEEP_ALIVE, 0, 10, tcp_callback);
99.      if(socket_tcp != 0)
100.      {
101.          res = tcp_listen (socket_tcp, PORT_NUM);
102.          printf_debug("tcp listen res = %d\\r\\n", res);
103.      }
104.    
105.      while (1)
106.      {
107.          /* 省略 */
108.      }
109. }

复制代码

13.2.2 函数tcp_listen


函数原型：

1. BOOL tcp_listen (
2.     U8  socket,       /* TCP socket 句柄 */
3. U16 locport );    /* 监听的端口号 */

复制代码

函数描述：
函数tcp_listen用于设置TCP服务器的监听端口。
（1）第1个参数是要设置监听的TCP Socket句柄。
（2）第2个参数是监听端口号。
（3）返回值，创建监听成功返回__TRUE，创建失败返回__FALSE。
使用这个函数要注意以下问题：
1.     RL-TCPnet服务器类应用，比如Telnet Server，HTTP Server，务必要打开一个TCP Socket用于监听。
2.     只有创建的TCP服务器才可以使用此函数，也就是调用函数tcp_get_socket的第一个形参必须得是TCP_TYPE_SERVER 或者 TCP_TYPE_CLIENT_SERVER。
使用举例：

1. /*
2. *********************************************************************************************************
3. *                                      用于本文件的调试
4. *********************************************************************************************************
5. */
6. #define PORT_NUM       1001    /* TCP服务器监听端口号 */
9. /*
10. *********************************************************************************************************
11. *                                         变量
12. *********************************************************************************************************
13. */
14. uint8_t socket_tcp;
17. /*
18. *********************************************************************************************************
19. *    函 数 名: tcp_callback
20. *    功能说明: TCP Socket的回调函数
21. *    形    参: soc  TCP Socket类型
22. *             evt  事件类型
23. *             ptr  事件类型是TCP_EVT_DATA，ptr指向的缓冲区记录着接收到的TCP数据，其余事件记录IP地址
24. *             par  事件类型是TCP_EVT_DATA，记录接收到的数据个数，其余事件记录端口号
25. *    返 回 值:
26. *********************************************************************************************************
27. */
28. U16 tcp_callback (U8 soc, U8 evt, U8 *ptr, U16 par)
29. {
30.      char buf[50];
31.      uint16_t i;
32.    
33.      /* 确保是socket_tcp的回调 */
34.      if (soc != socket_tcp)
35.      {
36.          return (0);
37.      }
39.      switch (evt)
40.      {
41.          /*
42.               远程客户端连接消息
43.              1、数组ptr存储远程设备的IP地址，par中存储端口号。
44.              2、返回数值1允许连接，返回数值0禁止连接。
45.          */
46.          case TCP_EVT_CONREQ:
47.               sprintf(buf, "远程客户端请求连接IP: %d.%d.%d.%d", ptr[0], ptr[1], ptr[2], ptr[3]);
48.               printf_debug("IP:%s  port:%d\\r\\n", buf, par);
49.               return (1);
50.         
51.          /* 连接终止 */
52.          case TCP_EVT_ABORT:
53.               break;
54.         
55.          /* Socket远程连接已经建立 */
56.          case TCP_EVT_CONNECT:
57.               printf_debug("Socket is connected to remote peer\\r\\n");
58.               break;
59.         
60.          /* 连接断开 */
61.          case TCP_EVT_CLOSE:
62.               printf_debug("Connection has been closed\\r\\n");
63.               break;
64.         
65.          /* 发送的数据收到远程设备应答 */
66.          case TCP_EVT_ACK:
67.               break;
68.         
69.          /* 接收到TCP数据帧，ptr指向数据地址，par记录数据长度，单位字节 */
70.          case TCP_EVT_DATA:
71.               printf_debug("Data length = %d\\r\\n", par);
72.               for(i = 0; i < par; i++)
73.               {
74.                    printf_debug("ptr[%d] = %d\\r\\n", i, ptr[i]);
75.               }
76.               break;
77.      }
78.    
79.      return (0);
80. }
82. /*
83. *********************************************************************************************************
84. *    函 数 名: TCPnetTest
85. *    功能说明: TCPnet应用
86. *    形    参: 无
87. *    返 回 值: 无
88. *********************************************************************************************************
89. */
90. void TCPnetTest(void)
91. {
92.      uint8_t res;
94.      /*
95.         创建TCP Socket并创建监听，客户端连接服务器后，10秒内无数据通信将断开连接。
96.         但是由于这里使能了TCP_TYPE_KEEP_ALIVE，会一直保持连接，不受10秒的时间限制。
97.      */
98.     socket_tcp = tcp_get_socket (TCP_TYPE_SERVER|TCP_TYPE_KEEP_ALIVE, 0, 10, tcp_callback);
99.      if(socket_tcp != 0)
100.      {
101.          res = tcp_listen (socket_tcp, PORT_NUM);
102.          printf_debug("tcp listen res = %d\\r\\n", res);
103.      }
104.    
105.      while (1)
106.      {
107.          /* 省略 */
108.      }
109. }

复制代码

13.2.3 函数tcp_check_send


函数原型：

1. BOOL tcp_check_send (
2.            U8 socket );    /* TCP socket 句柄 */     [size=3][font=新宋体]         [/font][/size]

复制代码

函数描述：
函数tcp_check_send用于检测是否可以发送数据。此函数通过检测TCP连接是否建立以及上次发送的数据是否接收到远程机器的应答来判断是否可以发送数据。
（1）第1个参数是TCP Socket句柄。
（2） 返回值，可以发送数据，返回__TRUE；不可以发送数据，返回__FALSE。
使用举例：

1. /*
2. *********************************************************************************************************
3. *                                      用于本文件的调试
4. *********************************************************************************************************
5. */
6. #define PORT_NUM       1001    /* TCP服务器监听端口号 */
9. /*
10. *********************************************************************************************************
11. *                                         变量
12. *********************************************************************************************************
13. */
14. uint8_t socket_tcp;
17. /*
18. *********************************************************************************************************
19. *    函 数 名: tcp_callback
20. *    功能说明: TCP Socket的回调函数
21. *    形    参: soc  TCP Socket类型
22. *             evt  事件类型
23. *             ptr  事件类型是TCP_EVT_DATA，ptr指向的缓冲区记录着接收到的TCP数据，其余事件记录IP地址
24. *             par  事件类型是TCP_EVT_DATA，记录接收到的数据个数，其余事件记录端口号
25. *    返 回 值:
26. *********************************************************************************************************
27. */
28. U16 tcp_callback (U8 soc, U8 evt, U8 *ptr, U16 par)
29. {
30.      char buf[50];
31.      uint16_t i;
32.    
33.      /* 确保是socket_tcp的回调 */
34.      if (soc != socket_tcp)
35.      {
36.          return (0);
37.      }
39.      switch (evt)
40.      {
41.          /*
42.               远程客户端连接消息
43.              1、数组ptr存储远程设备的IP地址，par中存储端口号。
44.              2、返回数值1允许连接，返回数值0禁止连接。
45.          */
46.          case TCP_EVT_CONREQ:
47.               sprintf(buf, "远程客户端请求连接IP: %d.%d.%d.%d", ptr[0], ptr[1], ptr[2], ptr[3]);
48.               printf_debug("IP:%s  port:%d\\r\\n", buf, par);
49.               return (1);
50.         
51.          /* 连接终止 */
52.          case TCP_EVT_ABORT:
53.               break;
54.         
55.          /* Socket远程连接已经建立 */
56.          case TCP_EVT_CONNECT:
57.               printf_debug("Socket is connected to remote peer\\r\\n");
58.               break;
59.         
60.          /* 连接断开 */
61.          case TCP_EVT_CLOSE:
62.               printf_debug("Connection has been closed\\r\\n");
63.               break;
64.         
65.          /* 发送的数据收到远程设备应答 */
66.          case TCP_EVT_ACK:
67.               break;
68.         
69.          /* 接收到TCP数据帧，ptr指向数据地址，par记录数据长度，单位字节 */
70.          case TCP_EVT_DATA:
71.               printf_debug("Data length = %d\\r\\n", par);
72.               for(i = 0; i < par; i++)
73.               {
74.                    printf_debug("ptr[%d] = %d\\r\\n", i, ptr[i]);
75.               }
76.               break;
77.      }
78.    
79.      return (0);
80. }
82. /*
83. *********************************************************************************************************
84. *    函 数 名: TCPnetTest
85. *    功能说明: TCPnet应用
86. *    形    参: 无
87. *    返 回 值: 无
88. *********************************************************************************************************
89. */
90. void TCPnetTest(void)
91. {
92.      uint8_t res;
94.      /*
95.         创建TCP Socket并创建监听，客户端连接服务器后，10秒内无数据通信将断开连接。
96.         但是由于这里使能了TCP_TYPE_KEEP_ALIVE，会一直保持连接，不受10秒的时间限制。
97.      */
98.     socket_tcp = tcp_get_socket (TCP_TYPE_SERVER|TCP_TYPE_KEEP_ALIVE, 0, 10, tcp_callback);
99.      if(socket_tcp != 0)
100.      {
101.          res = tcp_listen (socket_tcp, PORT_NUM);
102.          printf_debug("tcp listen res = %d\\r\\n", res);
103.      }
104.    
105.      while (1)
106.      {
107. /* RL-TCPnet处理函数 */
108.          main_TcpNet();
109.         
110.          /* 用于网线插拔的处理 */
111.          tcp_status = TCP_StatusCheck();
112.         
113.          /* 按键消息的处理 */
114.          if((os_evt_wait_or(0xFFFF, usMaxBlockTime) == OS_R_EVT)&&(tcp_status == __TRUE))
115.          {
116.               xResult = os_evt_get ();
117.               switch (xResult)
118.               {
119.                    /* 接收到K1键按下，给远程TCP客户端发送8字节数据 */
120.                    case KEY1_BIT0:              
121.                        printf_debug("tcp_get_state(socket_tcp) = %d\\r\\n", tcp_get_state(socket_tcp));
122.                        iCount = 8;
123.                        do
124.                        {
125.                             main_TcpNet();
126.                             if (tcp_check_send (socket_tcp) == __TRUE)
127.                             {
128.                                  maxlen = tcp_max_dsize (socket_tcp);
129.                                  iCount -= maxlen;
130.                                 
131.                                  if(iCount < 0)
132.                                  {
133.                                      /* 这么计算没问题的 */
134.                                      maxlen = iCount + maxlen;
135.                                  }
136.                                 
137.                                  sendbuf = tcp_get_buf(maxlen);
138.                                  sendbuf[0] = '1';
139.                                  sendbuf[1] = '2';
140.                                  sendbuf[2] = '3';
141.                                  sendbuf[3] = '4';
142.                                  sendbuf[4] = '5';
143.                                  sendbuf[5] = '6';
144.                                  sendbuf[6] = '7';
145.                                  sendbuf[7] = '8';
146.                                 
147.                                  /* 测试发现只能使用获取的内存 */
148.                                  tcp_send (socket_tcp, sendbuf, maxlen);
149.                             }
150.                            
151.                        }while(iCount > 0);
152.                        break;
153.                   
154.                     /* 其他的键值不处理 */
155.                    default:                    
156.                        break;
157.               }
158.          }
159.      }
160. }

复制代码

13.2.4 函数tcp_max_dsize


函数原型：

1. U16 tcp_max_dsize (
2.     U8 socket );    /* TCP socket 句柄 */       [size=3][font=新宋体]         [/font][/size]

复制代码

函数描述：
函数tcp_max_dsize用于获得当前可以发送的最大报文长度（MSS，Maximum Segment Size）。在配置向导中，默认配置的MSS是1460字节，然而在实际建立连接后，此值会被动态调整，但一定是小于等于1460字节的。
（1）第1个参数是TCP Socket句柄。
（2） 返回值，返回本次可以发送的最大报文长度，单位字节。
使用举例：

1. /*
2. *********************************************************************************************************
3. *                                      用于本文件的调试
4. *********************************************************************************************************
5. */
6. #define PORT_NUM       1001    /* TCP服务器监听端口号 */
9. /*
10. *********************************************************************************************************
11. *                                         变量
12. *********************************************************************************************************
13. */
14. uint8_t socket_tcp;
17. /*
18. *********************************************************************************************************
19. *    函 数 名: tcp_callback
20. *    功能说明: TCP Socket的回调函数
21. *    形    参: soc  TCP Socket类型
22. *             evt  事件类型
23. *             ptr  事件类型是TCP_EVT_DATA，ptr指向的缓冲区记录着接收到的TCP数据，其余事件记录IP地址
24. *             par  事件类型是TCP_EVT_DATA，记录接收到的数据个数，其余事件记录端口号
25. *    返 回 值:
26. *********************************************************************************************************
27. */
28. U16 tcp_callback (U8 soc, U8 evt, U8 *ptr, U16 par)
29. {
30.      char buf[50];
31.      uint16_t i;
32.    
33.      /* 确保是socket_tcp的回调 */
34.      if (soc != socket_tcp)
35.      {
36.          return (0);
37.      }
39.      switch (evt)
40.      {
41.          /*
42.               远程客户端连接消息
43.              1、数组ptr存储远程设备的IP地址，par中存储端口号。
44.              2、返回数值1允许连接，返回数值0禁止连接。
45.          */
46.          case TCP_EVT_CONREQ:
47.               sprintf(buf, "远程客户端请求连接IP: %d.%d.%d.%d", ptr[0], ptr[1], ptr[2], ptr[3]);
48.               printf_debug("IP:%s  port:%d\\r\\n", buf, par);
49.               return (1);
50.         
51.          /* 连接终止 */
52.          case TCP_EVT_ABORT:
53.               break;
54.         
55.          /* Socket远程连接已经建立 */
56.          case TCP_EVT_CONNECT:
57.               printf_debug("Socket is connected to remote peer\\r\\n");
58.               break;
59.         
60.          /* 连接断开 */
61.          case TCP_EVT_CLOSE:
62.               printf_debug("Connection has been closed\\r\\n");
63.               break;
64.         
65.          /* 发送的数据收到远程设备应答 */
66.          case TCP_EVT_ACK:
67.               break;
68.         
69.          /* 接收到TCP数据帧，ptr指向数据地址，par记录数据长度，单位字节 */
70.          case TCP_EVT_DATA:
71.               printf_debug("Data length = %d\\r\\n", par);
72.               for(i = 0; i < par; i++)
73.               {
74.                    printf_debug("ptr[%d] = %d\\r\\n", i, ptr[i]);
75.               }
76.               break;
77.      }
78.    
79.      return (0);
80. }
82. /*
83. *********************************************************************************************************
84. *    函 数 名: TCPnetTest
85. *    功能说明: TCPnet应用
86. *    形    参: 无
87. *    返 回 值: 无
88. *********************************************************************************************************
89. */
90. void TCPnetTest(void)
91. {
92.      uint8_t res;
94.      /*
95.         创建TCP Socket并创建监听，客户端连接服务器后，10秒内无数据通信将断开连接。
96.         但是由于这里使能了TCP_TYPE_KEEP_ALIVE，会一直保持连接，不受10秒的时间限制。
97.      */
98.     socket_tcp = tcp_get_socket (TCP_TYPE_SERVER|TCP_TYPE_KEEP_ALIVE, 0, 10, tcp_callback);
99.      if(socket_tcp != 0)
100.      {
101.          res = tcp_listen (socket_tcp, PORT_NUM);
102.          printf_debug("tcp listen res = %d\\r\\n", res);
103.      }
104.    
105.      while (1)
106.      {
107. /* RL-TCPnet处理函数 */
108.          main_TcpNet();
109.         
110.          /* 用于网线插拔的处理 */
111.          tcp_status = TCP_StatusCheck();
112.         
113.          /* 按键消息的处理 */
114.          if((os_evt_wait_or(0xFFFF, usMaxBlockTime) == OS_R_EVT)&&(tcp_status == __TRUE))
115.          {
116.               xResult = os_evt_get ();
117.               switch (xResult)
118.               {
119.                    /* 接收到K1键按下，给远程TCP客户端发送8字节数据 */
120.                    case KEY1_BIT0:              
121.                        printf_debug("tcp_get_state(socket_tcp) = %d\\r\\n", tcp_get_state(socket_tcp));
122.                        iCount = 8;
123.                        do
124.                        {
125.                             main_TcpNet();
126.                             if (tcp_check_send (socket_tcp) == __TRUE)
127.                             {
128.                                  maxlen = tcp_max_dsize (socket_tcp);
129.                                  iCount -= maxlen;
130.                                 
131.                                  if(iCount < 0)
132.                                  {
133.                                      /* 这么计算没问题的 */
134.                                      maxlen = iCount + maxlen;
135.                                  }
136.                                 
137.                                  sendbuf = tcp_get_buf(maxlen);
138.                                  sendbuf[0] = '1';
139.                                  sendbuf[1] = '2';
140.                                  sendbuf[2] = '3';
141.                                  sendbuf[3] = '4';
142.                                  sendbuf[4] = '5';
143.                                  sendbuf[5] = '6';
144.                                  sendbuf[6] = '7';
145.                                  sendbuf[7] = '8';
146.                                 
147.                                  /* 测试发现只能使用获取的内存 */
148.                                  tcp_send (socket_tcp, sendbuf, maxlen);
149.                             }
150.                            
151.                        }while(iCount > 0);
152.                        break;
153.                   
154.                     /* 其他的键值不处理 */
155.                    default:                    
156.                        break;
157.               }
158.          }
159.      }
160. }

复制代码

13.2.5 函数tcp_get_buf


函数原型：

1. U8* tcp_get_buf (
2. U16 size );    /* 申请的缓冲区大小 */

复制代码

函数描述：
函数tcp_get_buf用于获取TCP发送缓冲区，用户将要发送的数据存到这个缓冲区中，然后通过函数tcp_send发送。发送完毕后要等待远程主机的应答，收到应答后，会在函数tcp_send中释放申请的发送缓冲区。
（1）第1个参数是要申请的缓冲区大小.
（2） 返回值，返回获取的缓冲区地址。
使用这个函数要注意以下问题：
1.     每次发送都需要调用此函数获取发送缓冲区地址。
2.     申请的发送缓冲区大小不可超过最大报文长度（MSS，Maximum Segment Size），即1460字节。
3.     操作缓冲区的时候，切不可超过申请的缓冲区大小。
使用举例：

1. /*
2. *********************************************************************************************************
3. *                                      用于本文件的调试
4. *********************************************************************************************************
5. */
6. #define PORT_NUM       1001    /* TCP服务器监听端口号 */
9. /*
10. *********************************************************************************************************
11. *                                         变量
12. *********************************************************************************************************
13. */
14. uint8_t socket_tcp;
17. /*
18. *********************************************************************************************************
19. *    函 数 名: tcp_callback
20. *    功能说明: TCP Socket的回调函数
21. *    形    参: soc  TCP Socket类型
22. *             evt  事件类型
23. *             ptr  事件类型是TCP_EVT_DATA，ptr指向的缓冲区记录着接收到的TCP数据，其余事件记录IP地址
24. *             par  事件类型是TCP_EVT_DATA，记录接收到的数据个数，其余事件记录端口号
25. *    返 回 值:
26. *********************************************************************************************************
27. */
28. U16 tcp_callback (U8 soc, U8 evt, U8 *ptr, U16 par)
29. {
30.      char buf[50];
31.      uint16_t i;
32.    
33.      /* 确保是socket_tcp的回调 */
34.      if (soc != socket_tcp)
35.      {
36.          return (0);
37.      }
39.      switch (evt)
40.      {
41.          /*
42.               远程客户端连接消息
43.              1、数组ptr存储远程设备的IP地址，par中存储端口号。
44.              2、返回数值1允许连接，返回数值0禁止连接。
45.          */
46.          case TCP_EVT_CONREQ:
47.               sprintf(buf, "远程客户端请求连接IP: %d.%d.%d.%d", ptr[0], ptr[1], ptr[2], ptr[3]);
48.               printf_debug("IP:%s  port:%d\\r\\n", buf, par);
49.               return (1);
50.         
51.          /* 连接终止 */
52.          case TCP_EVT_ABORT:
53.               break;
54.         
55.          /* Socket远程连接已经建立 */
56.          case TCP_EVT_CONNECT:
57.               printf_debug("Socket is connected to remote peer\\r\\n");
58.               break;
59.         
60.          /* 连接断开 */
61.          case TCP_EVT_CLOSE:
62.               printf_debug("Connection has been closed\\r\\n");
63.               break;
64.         
65.          /* 发送的数据收到远程设备应答 */
66.          case TCP_EVT_ACK:
67.               break;
68.         
69.          /* 接收到TCP数据帧，ptr指向数据地址，par记录数据长度，单位字节 */
70.          case TCP_EVT_DATA:
71.               printf_debug("Data length = %d\\r\\n", par);
72.               for(i = 0; i < par; i++)
73.               {
74.                    printf_debug("ptr[%d] = %d\\r\\n", i, ptr[i]);
75.               }
76.               break;
77.      }
78.    
79.      return (0);
80. }
82. /*
83. *********************************************************************************************************
84. *    函 数 名: TCPnetTest
85. *    功能说明: TCPnet应用
86. *    形    参: 无
87. *    返 回 值: 无
88. *********************************************************************************************************
89. */
90. void TCPnetTest(void)
91. {
92.      uint8_t res;
94.      /*
95.         创建TCP Socket并创建监听，客户端连接服务器后，10秒内无数据通信将断开连接。
96.         但是由于这里使能了TCP_TYPE_KEEP_ALIVE，会一直保持连接，不受10秒的时间限制。
97.      */
98.     socket_tcp = tcp_get_socket (TCP_TYPE_SERVER|TCP_TYPE_KEEP_ALIVE, 0, 10, tcp_callback);
99.      if(socket_tcp != 0)
100.      {
101.          res = tcp_listen (socket_tcp, PORT_NUM);
102.          printf_debug("tcp listen res = %d\\r\\n", res);
103.      }
104.    
105.      while (1)
106.      {
107. /* RL-TCPnet处理函数 */
108.          main_TcpNet();
109.         
110.          /* 用于网线插拔的处理 */
111.          tcp_status = TCP_StatusCheck();
112.         
113.          /* 按键消息的处理 */
114.          if((os_evt_wait_or(0xFFFF, usMaxBlockTime) == OS_R_EVT)&&(tcp_status == __TRUE))
115.          {
116.               xResult = os_evt_get ();
117.               switch (xResult)
118.               {
119.                    /* 接收到K1键按下，给远程TCP客户端发送8字节数据 */
120.                    case KEY1_BIT0:              
121.                        printf_debug("tcp_get_state(socket_tcp) = %d\\r\\n", tcp_get_state(socket_tcp));
122.                        iCount = 8;
123.                        do
124.                        {
125.                             main_TcpNet();
126.                             if (tcp_check_send (socket_tcp) == __TRUE)
127.                             {
128.                                  maxlen = tcp_max_dsize (socket_tcp);
129.                                  iCount -= maxlen;
130.                                 
131.                                  if(iCount < 0)
132.                                  {
133.                                      /* 这么计算没问题的 */
134.                                      maxlen = iCount + maxlen;
135.                                  }
136.                                 
137.                                  sendbuf = tcp_get_buf(maxlen);
138.                                  sendbuf[0] = '1';
139.                                  sendbuf[1] = '2';
140.                                  sendbuf[2] = '3';
141.                                  sendbuf[3] = '4';
142.                                  sendbuf[4] = '5';
143.                                  sendbuf[5] = '6';
144.                                  sendbuf[6] = '7';
145.                                  sendbuf[7] = '8';
146.                                 
147.                                  /* 测试发现只能使用获取的内存 */
148.                                  tcp_send (socket_tcp, sendbuf, maxlen);
149.                             }
150.                            
151.                        }while(iCount > 0);
152.                        break;
153.                   
154.                     /* 其他的键值不处理 */
155.                    default:                    
156.                        break;
157.               }
158.          }
159.      }
160. }

复制代码

13.2.6 函数tcp_send


函数原型：

1. BOOL tcp_send (
2.     U8  socket,    /* TCP socket 句柄 */
3.     U8* buf,       /* 数据缓冲区地址 */
4.     U16 dlen );    /* 要发送的数据个数，单位字节 */

复制代码

函数描述：
函数tcp_send用于数据包发送。
（1）第1个参数是TCP Socket句柄。
（2） 第2个参数是函数tcp_get_buf获取的缓冲区地址。
（3） 第3个参数是发送数据个数，单位字节。
（4）返回值，发送成功返回__TRUE，发送失败返回__FALSE。
使用这个函数要注意以下问题：
1.     不管函数tcp_send发送成功还是失败，都会释放通过函数tcp_get_buf获取的缓冲区。
2.     以下两种情况不可使用函数tcp_send发送数据包：
    (1)    TCP连接还未建立。
    (2)    发送给远程机器的数据包还未收到应答。
3.     调用函数tcp_send前务必要调用函数tcp_get_buf获得缓冲区。
4.     申请的发送缓冲区大小不可超过最大报文长度（MSS，Maximum Segment Size），即1460字节。
5.     操作缓冲区的时候，切不可超过申请的缓冲区大小。
使用举例：

1. /*
2. *********************************************************************************************************
3. *                                      用于本文件的调试
4. *********************************************************************************************************
5. */
6. #define PORT_NUM       1001    /* TCP服务器监听端口号 */
9. /*
10. *********************************************************************************************************
11. *                                         变量
12. *********************************************************************************************************
13. */
14. uint8_t socket_tcp;
17. /*
18. *********************************************************************************************************
19. *    函 数 名: tcp_callback
20. *    功能说明: TCP Socket的回调函数
21. *    形    参: soc  TCP Socket类型
22. *             evt  事件类型
23. *             ptr  事件类型是TCP_EVT_DATA，ptr指向的缓冲区记录着接收到的TCP数据，其余事件记录IP地址
24. *             par  事件类型是TCP_EVT_DATA，记录接收到的数据个数，其余事件记录端口号
25. *    返 回 值:
26. *********************************************************************************************************
27. */
28. U16 tcp_callback (U8 soc, U8 evt, U8 *ptr, U16 par)
29. {
30.      char buf[50];
31.      uint16_t i;
32.    
33.      /* 确保是socket_tcp的回调 */
34.      if (soc != socket_tcp)
35.      {
36.          return (0);
37.      }
39.      switch (evt)
40.      {
41.          /*
42.               远程客户端连接消息
43.              1、数组ptr存储远程设备的IP地址，par中存储端口号。
44.              2、返回数值1允许连接，返回数值0禁止连接。
45.          */
46.          case TCP_EVT_CONREQ:
47.               sprintf(buf, "远程客户端请求连接IP: %d.%d.%d.%d", ptr[0], ptr[1], ptr[2], ptr[3]);
48.               printf_debug("IP:%s  port:%d\\r\\n", buf, par);
49.               return (1);
50.         
51.          /* 连接终止 */
52.          case TCP_EVT_ABORT:
53.               break;
54.         
55.          /* Socket远程连接已经建立 */
56.          case TCP_EVT_CONNECT:
57.               printf_debug("Socket is connected to remote peer\\r\\n");
58.               break;
59.         
60.          /* 连接断开 */
61.          case TCP_EVT_CLOSE:
62.               printf_debug("Connection has been closed\\r\\n");
63.               break;
64.         
65.          /* 发送的数据收到远程设备应答 */
66.          case TCP_EVT_ACK:
67.               break;
68.         
69.          /* 接收到TCP数据帧，ptr指向数据地址，par记录数据长度，单位字节 */
70.          case TCP_EVT_DATA:
71.               printf_debug("Data length = %d\\r\\n", par);
72.               for(i = 0; i < par; i++)
73.               {
74.                    printf_debug("ptr[%d] = %d\\r\\n", i, ptr[i]);
75.               }
76.               break;
77.      }
78.    
79.      return (0);
80. }
82. /*
83. *********************************************************************************************************
84. *    函 数 名: TCPnetTest
85. *    功能说明: TCPnet应用
86. *    形    参: 无
87. *    返 回 值: 无
88. *********************************************************************************************************
89. */
90. void TCPnetTest(void)
91. {
92.      uint8_t res;
94.      /*
95.         创建TCP Socket并创建监听，客户端连接服务器后，10秒内无数据通信将断开连接。
96.         但是由于这里使能了TCP_TYPE_KEEP_ALIVE，会一直保持连接，不受10秒的时间限制。
97.      */
98.     socket_tcp = tcp_get_socket (TCP_TYPE_SERVER|TCP_TYPE_KEEP_ALIVE, 0, 10, tcp_callback);
99.      if(socket_tcp != 0)
100.      {
101.          res = tcp_listen (socket_tcp, PORT_NUM);
102.          printf_debug("tcp listen res = %d\\r\\n", res);
103.      }
104.    
105.      while (1)
106.      {
107. /* RL-TCPnet处理函数 */
108.          main_TcpNet();
109.         
110.          /* 用于网线插拔的处理 */
111.          tcp_status = TCP_StatusCheck();
112.         
113.          /* 按键消息的处理 */
114.          if((os_evt_wait_or(0xFFFF, usMaxBlockTime) == OS_R_EVT)&&(tcp_status == __TRUE))
115.          {
116.               xResult = os_evt_get ();
117.               switch (xResult)
118.               {
119.                    /* 接收到K1键按下，给远程TCP客户端发送8字节数据 */
120.                    case KEY1_BIT0:              
121.                        printf_debug("tcp_get_state(socket_tcp) = %d\\r\\n", tcp_get_state(socket_tcp));
122.                        iCount = 8;
123.                        do
124.                        {
125.                             main_TcpNet();
126.                             if (tcp_check_send (socket_tcp) == __TRUE)
127.                             {
128.                                  maxlen = tcp_max_dsize (socket_tcp);
129.                                  iCount -= maxlen;
130.                                 
131.                                  if(iCount < 0)
132.                                  {
133.                                      /* 这么计算没问题的 */
134.                                      maxlen = iCount + maxlen;
135.                                  }
136.                                 
137.                                  sendbuf = tcp_get_buf(maxlen);
138.                                  sendbuf[0] = '1';
139.                                  sendbuf[1] = '2';
140.                                  sendbuf[2] = '3';
141.                                  sendbuf[3] = '4';
142.                                  sendbuf[4] = '5';
143.                                  sendbuf[5] = '6';
144.                                  sendbuf[6] = '7';
145.                                  sendbuf[7] = '8';
146.                                 
147.                                  /* 测试发现只能使用获取的内存 */
148.                                  tcp_send (socket_tcp, sendbuf, maxlen);
149.                             }
150.                            
151.                        }while(iCount > 0);
152.                        break;
153.                   
154.                     /* 其他的键值不处理 */
155.                    default:                    
156.                        break;
157.               }
158.          }
159.      }
160. }

复制代码

13.2.7 函数tcp_get_state


函数原型：

1. U8 tcp_get_state (
2.     U8 socket );    /* TCP socket 句柄 */

复制代码

函数描述：
函数tcp_get_state用于获取TCP Socket的当前状态。用户应用程序可以通过此函数监控TCP Socket的连接、断开等状态。最有用的状态值是TCP_STATE_CLOSED，TCP_STATE_LISTEN和TCP_STATE_CONNECT。
（1）第1个参数是TCP Socket句柄。
（2）返回值，返回以下几种状态值：

使用举例：

1. /*
2. *********************************************************************************************************
3. *    函 数 名: TCP_StatusCheck
4. *    功能说明: 检测TCP的连接状态，主要用于网线插拔的判断
5. *    形    参: 无
6. *    返 回 值: __TRUE  连接
7. *             __FALSE 断开
8. *********************************************************************************************************
9. */
10. uint8_t TCP_StatusCheck(void)
11. {
12.      uint8_t res;
13.    
14.      switch (tcp_get_state(socket_tcp))
15.      {
16.          case TCP_STATE_FREE:
17.          case TCP_STATE_CLOSED:
18.               res = tcp_listen (socket_tcp, PORT_NUM);
19.               printf_debug("tcp listen res = %d\\r\\n", res);
20.               break;
21.         
22.          case TCP_STATE_LISTEN:
23.               break;
24.         
25.          case TCP_STATE_CONNECT:
26.               return (__TRUE);
27.             
28.          default:
29.               break;
30.      }
31.    
32.      return (__FALSE);
33. }

复制代码

席萌0209

13.3 TCP配置说明（Net_Config.c）


    （本章节配套例子的配置与本小节的说明相同）
    RL-TCPnet的配置工作是通过配置文件Net_Config.c实现。在MDK工程中打开文件Net_Config.c，可以看到下图所示的工程配置向导：

RL-TCPnet要配置的选项非常多，我们这里把几个主要的配置选项简单介绍下。

u  System Definitions
（1）Local Host Name
    局域网域名。
    这里起名为armfly，使用局域网域名限制为15个字符。
（2）Memory Pool size
    参数范围1536-262144字节。
    内存池大小配置，单位字节。另外注意一点，配置向导这里显示的单位是字节，如果看原始定义，MDK会做一个自动的4字节倍数转换，比如我们这里配置的是8192字节，那么原始定义是#define MEM_SIZE  2048，也就是8192/4 = 2048。
（3）Tick Timer interval
    可取10，20，25，40，50，100，200，单位ms。
    系统滴答时钟间隔，也就是网络协议栈的系统时间基准，默认情况下，取值100ms。

u  Ethernet Network Interface
    以太网接口配置，勾选了此选项就可以配置了，如果没有使能DHCP的话，将使用这里配置的固定IP。
（1）MAC Address
    局域网内可以随意配置，只要不跟局域网内其它设备的MAC地址冲突即可。
（2）IP Address
    IP地址。
（3）Subnet mask
    子网掩码。
（4）Default Gateway
    默认网关。

u  Ethernet Network Interface
    以太网接口配置，这个配置里面还有如下两项比较重要的配置需要说明。
（1）NetBIOS Name Service
    NetBIOS局域网域名服务，这里打上对勾就使能了。这样我们就可以通过前面配置的Local Host Name局域网域名进行访问，而不需要通过IP地址访问了。
（2）Dynaminc Host Configuration
    即DHCP，这里打上对勾就使能了。使能了DHCP后，RL-TCPnet就可以从外接的路由器上获得动态IP地址。

u  UDP Sockets
UDP Sockets配置，打上对勾就使能了此项功能
（1）Number of UDP Sockets
    用于配置可创建的UDP Sockets数量。
    范围1 – 20。

u  TCP Sockets
TCP Sockets配置，打上对勾就使能了此项功能
（1）Number of TCP Sockets
    用于配置可创建的TCP Sockets数量。
（2）Number of Retries
    范围0-20。
    用于配置重试次数，TCP数据传输时，如果在设置的重试时间内得不到应答，算一次重试失败，这里就是配置的最大重试次数。
（3）Retry Timeout in seconds
    范围1-10，单位秒。
    重试时间。如果发送的数据在重试时间内得不到应答，将重新发送数据。
（4）Default Connect Timeout in seconds
    范围1-600，单位秒。
    用于配置默认的保持连接时间，即我们常说的Keep Alive时间，如果时间到了将断开连接。常用于HTTP Server，Telnet Server等。
（5）Maximum Segment Size
    范围536-1460，单位字节。
    MSS定义了TCP数据包能够传输的最大数据分段。
（6）Receive Window Size
    范围536-65535，单位字节。
    TCP接收窗口大小。

席萌0209

13.4 TCP调试说明（Net_Debug.c）


        （重要说明，RL-TCPnet的调试是通过串口打印出来的）
        RL-TCPnet的调试功能是通过配置文件Net_Debug.c实现。在MDK工程中打开文件Net_Debug.c，可以看到如图所示的工程配置向导：

Print Time Stamp
        勾选了此选项的话，打印消息时，前面会附带时间信息。
其它所有的选项
        默认情况下，所有的调试选项都是关闭的，每个选项有三个调试级别可选择，这里我们以Memory Management Debug为例，点击下拉列表，可以看到里面有Off，Errors only和Full debug三个调试级别可供选择，每个调试选项里面都是这三个级别。

Off：表示关闭此选项的调试功能。
Errorsonly：表示仅在此选项出错时，将其错误打印出来。
Fulldebug：表示此选项的全功能调试。
        具体测试，我们这里就不做了，大家可以按照第11章讲解的调试方法进行测试。

席萌0209

13.5 TCP服务器的实现方法


        有了本章节13.3小节的配置后，剩下的问题就是TCP服务器的创建和TCP服务器数据收发的实现。

13.5.1 创建TCP服务器


        TCP服务器的创建比较简单，调用函数tcp_get_socket即可，此函数的使用和注意事项在本章的13.2.1小节有讲解：

1. /*
2. *********************************************************************************************************
3. *                                        宏定义
4. *********************************************************************************************************
5. */
6. #define PORT_NUM       1001    /* TCP服务器监听端口号 */
9. /*
10. *********************************************************************************************************
11. *                                         变量
12. *********************************************************************************************************
13. */
14. uint8_t socket_tcp;
16. /*
17. *********************************************************************************************************
18. *    函 数 名: tcp_callback
19. *    功能说明: TCP Socket的回调函数
20. *    形    参: soc  TCP Socket类型
21. *             evt  事件类型
22. *             ptr  事件类型是TCP_EVT_DATA，ptr指向的缓冲区记录着接收到的TCP数据，其余事件记录IP地址
23. *             par  事件类型是TCP_EVT_DATA，记录接收到的数据个数，其余事件记录端口号
24. *    返 回 值:
25. *********************************************************************************************************
26. */
27. U16 tcp_callback (U8 soc, U8 evt, U8 *ptr, U16 par)
28. {
29.      char buf[50];
30.      uint16_t i;
31.    
32.      /* 确保是socket_tcp的回调 */
33.      if (soc != socket_tcp)
34.      {
35.          return (0);
36.      }
38.      switch (evt)
39.      {
40.          /*
41.               远程客户端连接消息
42.              1、数组ptr存储远程设备的IP地址，par中存储端口号。
43.              2、返回数值1允许连接，返回数值0禁止连接。
44.          */
45.          case TCP_EVT_CONREQ:
46.               sprintf(buf, "远程客户端请求连接IP: %d.%d.%d.%d", ptr[0], ptr[1], ptr[2], ptr[3]);
47.               printf_debug("IP:%s  port:%d\\r\\n", buf, par);
48.               return (1);
49.         
50.           /* 连接终止 */
51.          case TCP_EVT_ABORT:
52.               break;
53.         
54.          /* Socket远程连接已经建立 */
55.          case TCP_EVT_CONNECT:
56.               printf_debug("Socket is connected to remote peer\\r\\n");
57.               break;
58.         
59.          /* 连接断开 */
60.          case TCP_EVT_CLOSE:
61.               printf_debug("Connection has been closed\\r\\n");
62.               break;
63.         
64.          /* 发送的数据收到远程设备应答 */
65.          case TCP_EVT_ACK:
66.               break;
67.         
68.          /* 接收到TCP数据帧，ptr指向数据地址，par记录数据长度，单位字节 */
69.          case TCP_EVT_DATA:
70.               printf_debug("Data length = %d\\r\\n", par);
71.               for(i = 0; i < par; i++)
72.               {
73.                    printf_debug("ptr[%d] = %d\\r\\n", i, ptr[i]);
74.               }
75.               break;
76.      }
77.    
78.      return (0);
79. }
82. /*
83. *********************************************************************************************************
84. *    函 数 名: TCPnetTest
85. *    功能说明: TCPnet应用
86. *    形    参: 无
87. *    返 回 值: 无
88. *********************************************************************************************************
89. */
90. void TCPnetTest(void)
91. {
92.      uint8_t res;
93.    
94.    
95.      /* 初始化网络协议栈 */
96.      init_TcpNet ();
98.      /*
99.         创建TCP Socket并创建监听，客户端连接服务器后，10秒内无数据通信将断开连接。
100.         但是由于这里使能了TCP_TYPE_KEEP_ALIVE，会一直保持连接，不受10秒的时间限制。
101.      */
102.     socket_tcp = tcp_get_socket (TCP_TYPE_SERVER, 0, 10, tcp_callback);
103.      if(socket_tcp != 0)
104.      {
105.          res = tcp_listen (socket_tcp, PORT_NUM);
106.          printf_debug("tcp listen res = %d\\r\\n", res);
107.      }
109.     /* 省略 */
111. }

复制代码

13.5.2 TCP数据发送


        TCP Socket的数据发送一定要注意各个函数调用顺序和使用方法，非常重要！否则，数据发送很容易失败。数据发送所用到函数的使用方法和注意事项在本章节的13.2小节有讲解。下面的代码中对数据发送专门做了处理，支持任意字节大小的数据发送，仅需修改计数变量iCount的初始值即可，初始值是多少，就是发送多少字节。下面的代码是裸机方式的，测试发送8字节，1024字节和5MB：

1. /*
2. *********************************************************************************************************
3. *    函 数 名: tcpnet_poll
4. *    功能说明: 使用TCPnet必须要一直调用的函数
5. *    形    参: 无
6. *    返 回 值: 无
7. *********************************************************************************************************
8. */
9. void tcpnet_poll(void)
10. {
11.      if(bsp_CheckTimer(0))
12.      {
13.          /* 此函数坚决不可以放在中断里面跑 */
14.          timer_tick ();  //--------------（1）
15.      }
16.    
17.      main_TcpNet ();     //--------------（2）
19. }
21. /*
22. *********************************************************************************************************
23. *    函 数 名: TCPnetTest
24. *    功能说明: TCPnet应用
25. *    形    参: 无
26. *    返 回 值: 无
27. *********************************************************************************************************
28. */
29. void TCPnetTest(void)
30. {
31.      int32_t iCount;
32.      uint8_t *sendbuf;
33.      uint8_t tcp_status;
34.      uint16_t maxlen;
35.      uint8_t res;
36.      uint8_t ucKeyCode;
37.    
38.    
39.      /* 初始化网络协议栈 */
40.      init_TcpNet ();
42.      /*
43.         创建TCP Socket并创建监听，客户端连接服务器后，10秒内无数据通信将断开连接。
44.         但是由于这里使能了TCP_TYPE_KEEP_ALIVE，会一直保持连接，不受10秒的时间限制。
45.      */
46.     socket_tcp = tcp_get_socket (TCP_TYPE_SERVER, 0, 10, tcp_callback);
47.      if(socket_tcp != 0)
48.      {
49.          res = tcp_listen (socket_tcp, PORT_NUM);
50.          printf_debug("tcp listen res = %d\\r\\n", res);
51.      }
53.      /* 创建一个周期是100ms的软定时器 */
54.     bsp_StartAutoTimer(0, 100);
55.    
56.      while (1)
57.      {
58.           /* TCP轮询 */
59.          tcpnet_poll();
60.         
61.          /* 用于网线插拔的处理 */
62.          tcp_status = TCP_StatusCheck();
63.         
64.          /* 按键消息的处理 */
65.          ucKeyCode = bsp_GetKey();
66.          if ((ucKeyCode != KEY_NONE)&&(tcp_status == __TRUE))
67.          {
68.               switch (ucKeyCode)
69.               {
70.                    /* K1键按下，给远程TCP客户端发送8字节数据 */
71.                    case KEY_DOWN_K1:            
72.                        printf_debug("tcp_get_state(socket_tcp) = %d\\r\\n", tcp_get_state(socket_tcp));
73.                        iCount = 8;  //--------------（3）
74.                        do           //--------------（4）
75.                        {
76.                             tcpnet_poll();
77.                             if (tcp_check_send (socket_tcp) == __TRUE)
78.                             {
79.                                  maxlen = tcp_max_dsize (socket_tcp);
80.                                  iCount -= maxlen;
81.                                 
82.                                  if(iCount < 0)
83.                                  {
84.                                      /* 这么计算没问题的 */
85.                                      maxlen = iCount + maxlen;
86.                                  }
87.                                 
88.                                  sendbuf = tcp_get_buf(maxlen);
89.                                  sendbuf[0] = '1';
90.                                  sendbuf[1] = '2';
91.                                  sendbuf[2] = '3';
92.                                  sendbuf[3] = '4';
93.                                  sendbuf[4] = '5';
94.                                  sendbuf[5] = '6';
95.                                  sendbuf[6] = '7';
96.                                  sendbuf[7] = '8';
97.                                 
98.                                  /* 测试发现只能使用获取的内存 */
99.                                  tcp_send (socket_tcp, sendbuf, maxlen);
100.                             }
101.                            
102.                        }while(iCount > 0);
103.                        break;
105.                    /* K2键按下，给远程TCP客户端发送1024字节的数据 */
106.                    case KEY_DOWN_K2:     
107.                        printf_debug("tcp_get_state(socket_tcp) = %d\\r\\n", tcp_get_state(socket_tcp));
108.                        iCount = 1024; //--------------（5）
109.                        do
110.                        {
111.                             tcpnet_poll();
112.                             if (tcp_check_send (socket_tcp) == __TRUE)
113.                             {
114.                                  maxlen = tcp_max_dsize (socket_tcp);
115.                                  iCount -= maxlen;
116.                                 
117.                                  if(iCount < 0)
118.                                  {
119.                                      /* 这么计算没问题的 */
120.                                      maxlen = iCount + maxlen;
121.                                  }
122.                                 
123.                                  /* 这里仅初始化了每次所发送数据包的前8个字节 */
124.                                  sendbuf = tcp_get_buf(maxlen);
125.                                  sendbuf[0] = 'a';
126.                                  sendbuf[1] = 'b';
127.                                  sendbuf[2] = 'c';
128.                                  sendbuf[3] = 'd';
129.                                  sendbuf[4] = 'e';
130.                                  sendbuf[5] = 'f';
131.                                  sendbuf[6] = 'g';
132.                                  sendbuf[7] = 'h';
133.                                 
134.                                  /* 测试发现只能使用获取的内存 */
135.                                  tcp_send (socket_tcp, sendbuf, maxlen);
136.                             }
137.                            
138.                        }while(iCount > 0);                     
139.                        break;
140.                      
141.                    /* K3键按下，给远程TCP客户端发送5MB数据 */
142.                    case KEY_DOWN_K3:            
143.                        printf_debug("tcp_get_state(socket_tcp) = %d\\r\\n", tcp_get_state(socket_tcp));
144.                        iCount = 5*1024*1024; //--------------（6）
145.                        do
146.                        {
147.                             tcpnet_poll();
148.                             if (tcp_check_send (socket_tcp) == __TRUE)
149.                             {
150.                                  maxlen = tcp_max_dsize (socket_tcp);
151.                                  iCount -= maxlen;
152.                                 
153.                                  if(iCount < 0)
154.                                  {
155.                                      /* 这么计算没问题的 */
156.                                      maxlen = iCount + maxlen;
157.                                  }
158.                                 
159.                                  /* 这里仅初始化了每次所发送数据包的前8个字节 */
160.                                  sendbuf = tcp_get_buf(maxlen);
161.                                  sendbuf[0] = 'a';
162.                                  sendbuf[1] = 'b';
163.                                  sendbuf[2] = 'c';
164.                                  sendbuf[3] = 'd';
165.                                  sendbuf[4] = 'e';
166.                                  sendbuf[5] = 'f';
167.                                  sendbuf[6] = 'g';
168.                                  sendbuf[7] = 'h';
169.                                 
170.                                  /* 测试发现只能使用获取的内存 */
171.                                  tcp_send (socket_tcp, sendbuf, maxlen);
172.                             }
173.                            
174.                        }while(iCount > 0);
175.                        break;
176.                   
177.                     /* 其他的键值不处理 */
178.                    default:                    
179.                        break;
180.               }
181.          }
182.      }
183. }

复制代码

1.     函数timer_tick用于实现网络时间基准，必须要周期性调用，周期大小是由配置向导文件中参数Tick Timer interval决定的。默认情况下，我们都取100ms。
2.     函数main_TcpNet必须要一直调用着，协议栈的执行，主要靠它。
3.     通过变量iCount设置要发送的字节数，这里是发送8字节数据。
4.     do while语句中的流程很重要：
    (1)    函数tcp_poll一定要实时调用着。
    (2)    发送前务必要调用函数tcp_check_send查看发送是否就绪。
    (3)    函数tcp_max_dsize，tcp_get_buf和tcp_send务必要依次调用，一个都不能少。
5.     通过变量iCount设置要发送的字节数，这里是发送1024字节数据。
6.     通过变量iCount设置要发送的字节数，这里是发送5MB数据。

说完了裸机方式，下面说说RTOS方式的数据发送，这里我们以RTX操作系统为例进行说明（其它的uCOS-III和FreeRTOS的思路是一样的）。RTX操作系统与裸机方式的主要不同是为RL-TCPnet专门配套了两个任务，一个是RL-TCPnet主任务，另一个是网络系统时间基准更新任务。
网络系统时间更新任务：

1. /*
2. *********************************************************************************************************
3. *    函 数 名: AppTaskStart
4. *    功能说明: 启动任务，也是最高优先级任务，这里实现RL-TCPnet的时间基准更新。
5. *    形    参: 无
6. *    返 回 值: 无
7. *   优 先 级: 5
8. *********************************************************************************************************
9. */
10. __task void AppTaskStart(void)
11. {
12.      /* 初始化RL-TCPnet */
13.      init_TcpNet ();
14.    
15.      /* 创建任务 */
16.      AppTaskCreate();
17.    
18.      os_itv_set (100);
19.    
20.     while(1)
21.     {
22.          os_itv_wait ();
23.         
24.          /* RL-TCPnet时间基准更新函数 */
25.          timer_tick ();
26.     }
27. }

复制代码

特别注意，这里的网络时间基准函数timer_tick，必须要周期性调用，周期大小是由配置向导文件中参数TickTimer interval决定的。默认情况下，我们都取100ms，所以这里的延迟一定要匹配。
RL-TCPnet主任务，TCP数据收发在这个任务里面实现：

1. /*
2. *********************************************************************************************************
3. *    函 数 名: AppTaskTCPMain
4. *    功能说明: RL-TCPnet测试任务
5. *    形    参: 无
6. *    返 回 值: 无
7. *   优 先 级: 4
8. *********************************************************************************************************
9. */
10. __task void AppTaskTCPMain(void)
11. {
12.      while (1)
13.      {
14.          TCPnetTest();
15.      }
16. }

复制代码

函数TCPnetTest的具体实现如下：

1. /*
2. *********************************************************************************************************
3. *                                      宏定义
4. *********************************************************************************************************
5. */
6. #define PORT_NUM       1001    /* TCP服务器监听端口号 */
9. /*
10. *********************************************************************************************************
11. *                                         变量
12. *********************************************************************************************************
13. */
14. uint8_t socket_tcp;
16. /*
17. *********************************************************************************************************
18. *    函 数 名: TCPnetTest
19. *    功能说明: TCPnet应用
20. *    形    参: 无
21. *    返 回 值: 无
22. *********************************************************************************************************
23. */
24. void TCPnetTest(void)
25. {
26.      int32_t iCount;
27.      uint8_t *sendbuf;
28.      uint8_t tcp_status;
29.      uint16_t maxlen;
30.      uint8_t res;
31.      OS_RESULT xResult;
32.      const uint16_t usMaxBlockTime = 2; /* 延迟周期 */
34.      /*
35.         创建TCP Socket并创建监听，客户端连接服务器后，10秒内无数据通信将断开连接。
36.         但是由于这里使能了TCP_TYPE_KEEP_ALIVE，会一直保持连接，不受10秒的时间限制。
37.      */
38.     socket_tcp = tcp_get_socket (TCP_TYPE_SERVER|TCP_TYPE_KEEP_ALIVE, 0, 10, tcp_callback);
39.      if(socket_tcp != 0)
40.      {
41.          res = tcp_listen (socket_tcp, PORT_NUM);
42.          printf_debug("tcp listen res = %d\\r\\n", res);
43.      }
44.    
45.      while (1)
46.      {
47.          /* RL-TCPnet处理函数 */
48.          main_TcpNet();  //--------------（1）
49.         
50.          /* 用于网线插拔的处理 */
51.          tcp_status = TCP_StatusCheck();
52.         
53.          /* 按键消息的处理 */
54.          if((os_evt_wait_or(0xFFFF, usMaxBlockTime) == OS_R_EVT)&&(tcp_status == __TRUE)) //------（2）
55.          {
56.               xResult = os_evt_get ();
57.               switch (xResult)
58.               {
59.                    /* 接收到K1键按下，给远程TCP客户端发送8字节数据 */
60.                    case KEY1_BIT0:              
61.                        printf_debug("tcp_get_state(socket_tcp) = %d\\r\\n", tcp_get_state(socket_tcp));
62.                        iCount = 8; //--------------（3）
63.                        do
64.                        {
65.                             main_TcpNet();//--------------（4）
66.                             if (tcp_check_send (socket_tcp) == __TRUE)  
67.                             {
68.                                  maxlen = tcp_max_dsize (socket_tcp);
69.                                  iCount -= maxlen;
70.                                 
71.                                  if(iCount < 0)
72.                                  {
73.                                      /* 这么计算没问题的 */
74.                                      maxlen = iCount + maxlen;
75.                                  }
76.                                 
77.                                  sendbuf = tcp_get_buf(maxlen);
78.                                  sendbuf[0] = '1';
79.                                  sendbuf[1] = '2';
80.                                  sendbuf[2] = '3';
81.                                  sendbuf[3] = '4';
82.                                  sendbuf[4] = '5';
83.                                  sendbuf[5] = '6';
84.                                  sendbuf[6] = '7';
85.                                  sendbuf[7] = '8';
86.                                 
87.                                  /* 测试发现只能使用获取的内存 */
88.                                  tcp_send (socket_tcp, sendbuf, maxlen);
89.                             }
90.                            
91.                        }while(iCount > 0);
92.                        break;
94.                    /* 接收到K2键按下，给远程TCP客户端发送1024字节的数据 */
95.                    case KEY2_BIT1:      
96.                        printf_debug("tcp_get_state(socket_tcp) = %d\\r\\n", tcp_get_state(socket_tcp));
97.                        iCount = 1024; //--------------（5）
98.                        do
99.                        {
100.                             main_TcpNet();
101.                             if (tcp_check_send (socket_tcp) == __TRUE)
102.                             {
103.                                  maxlen = tcp_max_dsize (socket_tcp);
104.                                  iCount -= maxlen;
105.                                 
106.                                  if(iCount < 0)
107.                                  {
108.                                       /* 这么计算没问题的 */
109.                                      maxlen = iCount + maxlen;
110.                                  }
111.                                 
112.                                  /* 这里仅初始化了每次所发送数据包的前8个字节 */
113.                                  sendbuf = tcp_get_buf(maxlen);
114.                                  sendbuf[0] = 'a';
115.                                  sendbuf[1] = 'b';
116.                                  sendbuf[2] = 'c';
117.                                  sendbuf[3] = 'd';
118.                                  sendbuf[4] = 'e';
119.                                  sendbuf[5] = 'f';
120.                                  sendbuf[6] = 'g';
121.                                  sendbuf[7] = 'h';
122.                                 
123.                                  /* 测试发现只能使用获取的内存 */
124.                                  tcp_send (socket_tcp, sendbuf, maxlen);
125.                             }
126.                            
127.                        }while(iCount > 0);                     
128.                        break;
129.                      
130.                    /* 接收到K3键按下，给远程TCP客户端发送5MB数据 */
131.                    case KEY3_BIT2:              
132.                        printf_debug("tcp_get_state(socket_tcp) = %d\\r\\n", tcp_get_state(socket_tcp));
133.                        iCount = 5*1024*1024; //--------------（6）
134.                        do
135.                        {
136.                             main_TcpNet();
137.                             if (tcp_check_send (socket_tcp) == __TRUE)
138.                             {
139.                                  maxlen = tcp_max_dsize (socket_tcp);
140.                                  iCount -= maxlen;
141.                                 
142.                                  if(iCount < 0)
143.                                  {
144.                                      /* 这么计算没问题的 */
145.                                      maxlen = iCount + maxlen;
146.                                  }
147.                                 
148.                                  /* 这里仅初始化了每次所发送数据包的前8个字节 */
149.                                  sendbuf = tcp_get_buf(maxlen);
150.                                  sendbuf[0] = 'a';
151.                                  sendbuf[1] = 'b';
152.                                  sendbuf[2] = 'c';
153.                                  sendbuf[3] = 'd';
154.                                  sendbuf[4] = 'e';
155.                                  sendbuf[5] = 'f';
156.                                  sendbuf[6] = 'g';
157.                                  sendbuf[7] = 'h';
158.                                 
159.                                  /* 测试发现只能使用获取的内存 */
160.                                  tcp_send (socket_tcp, sendbuf, maxlen);
161.                             }
162.                            
163.                        }while(iCount > 0);
164.                        break;
165.                   
166.                     /* 其他的键值不处理 */
167.                    default:                    
168.                        break;
169.               }
170.          }
171.      }
172. }

复制代码

1.     函数main_TcpNet必须要一直调用着，协议栈的执行，主要靠它。
2.     这里使用了事件标志组，溢出时间设置为2毫秒。这样一方面保证了函数main_TcpNet的周期性执行，另一方面用来等待按键发送事件标志消息。
3.     通过变量iCount设置要发送的字节数，这里是发送8字节数据。
4.     do while语句中的流程很重要：
    (1)    函数main_TcpNet一定要实时调用着。
    (2)    发送前务必要调用函数tcp_check_send查看发送是否就绪。
    (3)    函数tcp_max_dsize，tcp_get_buf和tcp_send务必要依次调用，一个都不能少。
5.     通过变量iCount设置要发送的字节数，这里是发送1024字节数据。
6.     通过变量iCount设置要发送的字节数，这里是发送5MB数据。

13.5.3 TCP数据接收


    TCP数据接收主要是通过函数tcp_get_socket的回调函数实现（裸机，RTX，uCOS-III和FreeRTOS是一样的）：

1. /*
2. *********************************************************************************************************
3. *    函 数 名: tcp_callback
4. *    功能说明: TCP Socket的回调函数
5. *    形    参: soc  TCP Socket类型
6. *             evt  事件类型
7. *             ptr  事件类型是TCP_EVT_DATA，ptr指向的缓冲区记录着接收到的TCP数据，其余事件记录IP地址
8. *             par  事件类型是TCP_EVT_DATA，记录接收到的数据个数，其余事件记录端口号
9. *    返 回 值:
10. *********************************************************************************************************
11. */
12. U16 tcp_callback (U8 soc, U8 evt, U8 *ptr, U16 par)
13. {
14.      char buf[50];
15.      uint16_t i;
16.    
17.      /* 确保是socket_tcp的回调 */
18.      if (soc != socket_tcp)
19.      {
20.          return (0);
21.      }
23.      switch (evt)
24.      {
25.          /*
26.               远程客户端连接消息
27.              1、数组ptr存储远程设备的IP地址，par中存储端口号。
28.              2、返回数值1允许连接，返回数值0禁止连接。
29.          */
30.          case TCP_EVT_CONREQ:
31.               sprintf(buf, "远程客户端请求连接IP: %d.%d.%d.%d", ptr[0], ptr[1], ptr[2], ptr[3]);
32.               printf_debug("IP:%s  port:%d\\r\\n", buf, par);
33.               return (1);
34.         
35.          /* 连接终止 */
36.          case TCP_EVT_ABORT:
37.               break;
38.         
39.          /* Socket远程连接已经建立 */
40.          case TCP_EVT_CONNECT:
41.               printf_debug("Socket is connected to remote peer\\r\\n");
42.               break;
43.         
44.          /* 连接断开 */
45.           case TCP_EVT_CLOSE:
46.               printf_debug("Connection has been closed\\r\\n");
47.               break;
48.         
49.          /* 发送的数据收到远程设备应答 */
50.          case TCP_EVT_ACK:
51.               break;
52.         
53.          /* 接收到TCP数据帧，ptr指向数据地址，par记录数据长度，单位字节 */
54.          case TCP_EVT_DATA: //--------------（1）
55.               printf_debug("Data length = %d\\r\\n", par);
56.               for(i = 0; i < par; i++)
57.               {
58.                    printf_debug("ptr[%d] = %d\\r\\n", i, ptr[i]);
59.               }
60.               break;
61.      }
62.    
63.      return (0);
64. }

复制代码

1.     TCP服务器的数据接收主要是通过回调函数的TCP_EVT_DATA消息实现，进入消息后，指针变量ptr是接收数据缓冲区首地址，变量par记录接收到的数据长度，单位字节。

席萌0209

13.6 网络调试助手和板子的调试操作步骤


    我们这里使用下面这款调试助手，任何其它网络调试助手均可，不限制：http://www.armbbs.cn/forum.php?mod=viewthread&tid=1568 。

13.6.1 获取板子IP地址


    首先，强烈推荐将网线接到路由器或者交换机上面测试，因为已经使能了DHCP，可以自动获取IP地址，而且在前面的配置中使能了局域网域名NetBIOS，用户只需在电脑端ping armfly就可以获取板子的IP地址。测试方法如下：
（1）WIN+R组合键打开“运行”窗口，输入cmd。

（2）弹出的命令窗口中，输入ping armfly。

（3）输入ping armfly后，回车。

    获得IP地址是192.168.1.5。

13.6.2 网络调试助手创建TCP客户端

1、打开调试助手，点击左上角创建连接：

2、弹出如下界面，类型选择TCP，目标IP设置为192.168.1.5，端口号1001，最后点击创建：

    特别说明，我们这里直接填局域网域名armfly也是没有问题的，即下面这样：

3、创建后的界面效果如下：

4、点击连接，连接后的界面效果如下：

连接上后，串口软件也会打印出如下信息（波特率115200，数据位8，奇偶校验位无，停止位1）：

13.6.3 TCP服务器发送数据


    板子和网络调试助手建立连接后就可以相互收发数据了。对于发送数据。程序中创建了三种大小的数据发送测试。
（1）K1按键按下，发送了8个字符，从1到8。

（2）K2按键按下，发送1024字节，每次发送数据包的前8个字节设置了字符a到字符h，后面未做设置。

（3）K3按键按下，发送5*1024*1024 = 5242880字节，即5MB。每次发送数据包的前8个字节设置了字符a到字符h，后面都未做设置。

13.6.4 TCP服务器接收数据


    TCP服务器接收数据的测试也比较方便，我们这里通过网络调试助手给板子发送0到9，共10个字符：

点击发送后，可以看到串口软件打印出接收到的10个字符：

字符0对应的ASCII值就是48，其它字符数值依次增加。测试也是没问题的。

席萌0209

13.7 实验例程说明（裸机）



13.7.1 STM32F407开发板实验


配套例子：
    V5-1008_RL-TCPnet实验_TCP服务器（裸机）
实验目的：
    1.     学习RL-TCPnet的TCP服务器创建和数据收发。
实验内容：
    1.      强烈推荐将网线接到路由器或者交换机上面测试，因为已经使能了DHCP，可以自动获取IP地址。
    2.      创建了一个TCP Server，而且使能了局域网域名NetBIOS，用户只需在电脑端ping armfly就可以获得板子的IP地址，端口号1001。
    3.      用户可以在电脑端用网络调试软件创建TCP Client连接此服务器端。
    4.      按键K1按下，发送8字节的数据给TCPClient。
    5.      按键K2按下，发送1024字节的数据给TCPClient。
    6.      按键K3按下，发送5MB字节的数据给TCPClient。
实验操作：
        详见本章节13.6小节。
配置向导文件设置（Net_Config.c）：
        详见本章节13.3小节。
调试文件设置（Net_Debug.c）：
        详见本章节13.4小节。
程序设计：
u  主函数初始化
        在main.c文件实现：

1. /*
2. *********************************************************************************************************
3. *    函 数 名: main
4. *    功能说明: 标准c程序入口。
5. *    形    参: 无
6. *    返 回 值: 无
7. *********************************************************************************************************
8. */
9. int main (void)
10. {   
11.      /* 初始化外设 */
12.      bsp_Init();
14.      /* 进入RL-TCPnet测试函数 */
15.      TCPnetTest();
16. }

复制代码

u  硬件外设初始化
        硬件外设的初始化是在 bsp.c 文件实现：

1. /*
2. *********************************************************************************************************
3. *    函 数 名: bsp_Init
4. *    功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
5. *    形    参：无
6. *    返 回 值: 无
7. *********************************************************************************************************
8. */
9. void bsp_Init(void)
10. {
11.      /*
12.          由于ST固件库的启动文件已经执行了CPU系统时钟的初始化，所以不必再次重复配置系统时钟。
13.          启动文件配置了CPU主时钟频率、内部Flash访问速度和可选的外部SRAM FSMC初始化。
15.          系统时钟缺省配置为168MHz，如果需要更改，可以修改 system_stm32f4xx.c 文件
16.      */
17.      /* 优先级分组设置为4，可配置0-15级抢占式优先级，0级子优先级，即不存在子优先级。*/
18.      NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);
20.      bsp_InitUart();    /* 初始化串口 */
21.      bsp_InitKey();     /* 初始化按键变量（必须在 bsp_InitTimer() 之前调用） */
22.      bsp_InitLed();     /* 初始LED指示灯端口 */
23.      bsp_InitTimer();   /* 初始化滴答定时器 */
24. }

复制代码

u  RL-TCPnet功能测试
        这里专门创建了一个app_tcpnet_lib.c文件用于RL-TCPnet功能的测试，主要功能是创建了一个TCP Server。

1. /*
2. *********************************************************************************************************
3. *                                      用于本文件的调试
4. *********************************************************************************************************
5. */
6. #if 1
7.      #define printf_debug printf
8. #else
9.      #define printf_debug(...)
10. #endif
13. /*
14. *********************************************************************************************************
15. *                                      用于本文件的调试
16. *********************************************************************************************************
17. */
18. #define PORT_NUM       1001    /* TCP服务器监听端口号 */
21. /*
22. *********************************************************************************************************
23. *                                         变量
24. *********************************************************************************************************
25. */
26. uint8_t socket_tcp;
29. /*
30. *********************************************************************************************************
31. *    函 数 名: tcp_callback
32. *    功能说明: TCP Socket的回调函数
33. *    形    参: soc  TCP Socket类型
34. *             evt  事件类型
35. *             ptr  事件类型是TCP_EVT_DATA，ptr指向的缓冲区记录着接收到的TCP数据，其余事件记录IP地址
36. *             par  事件类型是TCP_EVT_DATA，记录接收到的数据个数，其余事件记录端口号
37. *    返 回 值:
38. *********************************************************************************************************
39. */
40. U16 tcp_callback (U8 soc, U8 evt, U8 *ptr, U16 par)
41. {
42.      char buf[50];
43.      uint16_t i;
44.    
45.      /* 确保是socket_tcp的回调 */
46.      if (soc != socket_tcp)
47.      {
48.          return (0);
49.      }
51.      switch (evt)
52.      {
53.          /*
54.               远程客户端连接消息
55.              1、数组ptr存储远程设备的IP地址，par中存储端口号。
56.              2、返回数值1允许连接，返回数值0禁止连接。
57.          */
58.          case TCP_EVT_CONREQ:
59.               sprintf(buf, "远程客户端请求连接IP: %d.%d.%d.%d", ptr[0], ptr[1], ptr[2], ptr[3]);
60.               printf_debug("IP:%s  port:%d\\r\\n", buf, par);
61.               return (1);
62.         
63.          /* 连接终止 */
64.          case TCP_EVT_ABORT:
65.               break;
66.         
67.          /* Socket远程连接已经建立 */
68.          case TCP_EVT_CONNECT:
69.               printf_debug("Socket is connected to remote peer\\r\\n");
70.               break;
71.         
72.          /* 连接断开 */
73.          case TCP_EVT_CLOSE:
74.               printf_debug("Connection has been closed\\r\\n");
75.               break;
76.         
77.          /* 发送的数据收到远程设备应答 */
78.          case TCP_EVT_ACK:
79.               break;
80.         
81.           /* 接收到TCP数据帧，ptr指向数据地址，par记录数据长度，单位字节 */
82.          case TCP_EVT_DATA:
83.               printf_debug("Data length = %d\\r\\n", par);
84.               for(i = 0; i < par; i++)
85.               {
86.                    printf_debug("ptr[%d] = %d\\r\\n", i, ptr[i]);
87.               }
88.               break;
89.      }
90.    
91.      return (0);
92. }
94. /*
95. *********************************************************************************************************
96. *    函 数 名: TCP_StatusCheck
97. *    功能说明: 检测TCP的连接状态，主要用于网线插拔的判断
98. *    形    参: 无
99. *    返 回 值: __TRUE  连接
100. *             __FALSE 断开
101. *********************************************************************************************************
102. */
103. uint8_t TCP_StatusCheck(void)
104. {
105.      uint8_t res;
106.    
107.      switch (tcp_get_state(socket_tcp))
108.      {
109.          case TCP_STATE_FREE:
110.          case TCP_STATE_CLOSED:
111.               res = tcp_listen (socket_tcp, PORT_NUM);
112.               printf_debug("tcp listen res = %d\\r\\n", res);
113.               break;
114.         
115.          case TCP_STATE_LISTEN:
116.               break;
117.         
118.          case TCP_STATE_CONNECT:
119.               return (__TRUE);
120.             
121.          default:
122.               break;
123.      }
124.    
125.      return (__FALSE);
126. }
128. /*
129. *********************************************************************************************************
130. *    函 数 名: tcpnet_poll
131. *    功能说明: 使用TCPnet必须要一直调用的函数
132. *    形    参: 无
133. *    返 回 值: 无
134. *********************************************************************************************************
135. */
136. void tcpnet_poll(void)
137. {
138.      if(bsp_CheckTimer(0))
139.      {
140.          /* 此函数坚决不可以放在中断里面跑 */
141.          timer_tick ();
142.      }
143.    
144.      main_TcpNet ();
145. }
147. /*
148. *********************************************************************************************************
149. *    函 数 名: TCPnetTest
150. *    功能说明: TCPnet应用
151. *    形    参: 无
152. *    返 回 值: 无
153. *********************************************************************************************************
154. */
155. void TCPnetTest(void)
156. {
157.      int32_t ulCount;
158.      uint8_t *sendbuf;
159.      uint8_t tcp_status;
160.      uint16_t maxlen;
161.      uint8_t res;
162.      uint8_t ucKeyCode;
163.    
164.    
165.      /* 初始化网络协议栈 */
166.      init_TcpNet ();
168.      /*
169.         创建TCP Socket并创建监听，客户端连接服务器后，10秒内无数据通信将断开连接。
170.         但是由于这里使能了TCP_TYPE_KEEP_ALIVE，会一直保持连接，不受10秒的时间限制。
171.      */
172.     socket_tcp = tcp_get_socket (TCP_TYPE_SERVER | TCP_TYPE_KEEP_ALIVE, 0, 10, tcp_callback);
173.      if(socket_tcp != 0)
174.      {
175.          res = tcp_listen (socket_tcp, PORT_NUM);
176.          printf_debug("tcp listen res = %d\\r\\n", res);
177.      }
179.      /* 创建一个周期是100ms的软定时器 */
180.     bsp_StartAutoTimer(0, 100);
181.    
182.      while (1)
183.      {
184.          /* TCP轮询 */
185.          tcpnet_poll();
186.         
187.           /* 用于网线插拔的处理 */
188.          tcp_status = TCP_StatusCheck();
189.         
190.           /* 按键消息的处理 */
191.          ucKeyCode = bsp_GetKey();
192.          if ((ucKeyCode != KEY_NONE)&&(tcp_status == __TRUE))
193.          {
194.               switch (ucKeyCode)
195.               {
196.                    /* K1键按下，给远程TCP客户端发送8字节数据 */
197.                    case KEY_DOWN_K1:            
198.                        printf_debug("tcp_get_state(socket_tcp) = %d\\r\\n", tcp_get_state(socket_tcp));
199.                        ulCount = 8;
200.                        do
201.                        {
202.                             tcpnet_poll();
203.                             if (tcp_check_send (socket_tcp) == __TRUE)
204.                             {
205.                                  maxlen = tcp_max_dsize (socket_tcp);
206.                                  ulCount -= maxlen;
207.                                 
208.                                  if(ulCount < 0)
209.                                  {
210.                                      /* 这么计算没问题的 */
211.                                      maxlen = ulCount + maxlen;
212.                                  }
213.                                 
214.                                  sendbuf = tcp_get_buf(maxlen);
215.                                  sendbuf[0] = '1';
216.                                  sendbuf[1] = '2';
217.                                  sendbuf[2] = '3';
218.                                  sendbuf[3] = '4';
219.                                  sendbuf[4] = '5';
220.                                  sendbuf[5] = '6';
221.                                  sendbuf[6] = '7';
222.                                  sendbuf[7] = '8';
223.                                 
224.                                  /* 测试发现只能使用获取的内存 */
225.                                  tcp_send (socket_tcp, sendbuf, maxlen);
226.                             }
227.                            
228.                        }while(ulCount > 0);
229.                        break;
231.                    /* K2键按下，给远程TCP客户端发送1024字节的数据 */
232.                    case KEY_DOWN_K2:     
233.                        printf_debug("tcp_get_state(socket_tcp) = %d\\r\\n", tcp_get_state(socket_tcp));
234.                        ulCount = 1024;
235.                        do
236.                        {
237.                             tcpnet_poll();
238.                             if (tcp_check_send (socket_tcp) == __TRUE)
239.                             {
240.                                  maxlen = tcp_max_dsize (socket_tcp);
241.                                  ulCount -= maxlen;
242.                                 
243.                                  if(ulCount < 0)
244.                                  {
245.                                      /* 这么计算没问题的 */
246.                                      maxlen = ulCount + maxlen;
247.                                  }
248.                                 
249.                                  /* 这里仅初始化了每次所发送数据包的前8个字节 */
250.                                  sendbuf = tcp_get_buf(maxlen);
251.                                  sendbuf[0] = 'a';
252.                                  sendbuf[1] = 'b';
253.                                  sendbuf[2] = 'c';
254.                                  sendbuf[3] = 'd';
255.                                  sendbuf[4] = 'e';
256.                                  sendbuf[5] = 'f';
257.                                  sendbuf[6] = 'g';
258.                                  sendbuf[7] = 'h';
259.                                 
260.                                  /* 测试发现只能使用获取的内存 */
261.                                  tcp_send (socket_tcp, sendbuf, maxlen);
262.                             }
263.                            
264.                        }while(ulCount > 0);                     
265.                        break;
266.                      
267.                    /* K3键按下，给远程TCP客户端发送5MB数据 */
268.                    case KEY_DOWN_K3:            
269.                        printf_debug("tcp_get_state(socket_tcp) = %d\\r\\n", tcp_get_state(socket_tcp));
270.                        ulCount = 5*1024*1024;
271.                        do
272.                        {
273.                             tcpnet_poll();
274.                             if (tcp_check_send (socket_tcp) == __TRUE)
275.                             {
276.                                  maxlen = tcp_max_dsize (socket_tcp);
277.                                  ulCount -= maxlen;
278.                                 
279.                                  if(ulCount < 0)
280.                                  {
281.                                      /* 这么计算没问题的 */
282.                                      maxlen = ulCount + maxlen;
283.                                  }
284.                                 
285.                                  /* 这里仅初始化了每次所发送数据包的前8个字节 */
286.                                  sendbuf = tcp_get_buf(maxlen);
287.                                  sendbuf[0] = 'a';
288.                                  sendbuf[1] = 'b';
289.                                  sendbuf[2] = 'c';
290.                                  sendbuf[3] = 'd';
291.                                  sendbuf[4] = 'e';
292.                                  sendbuf[5] = 'f';
293.                                  sendbuf[6] = 'g';
294.                                  sendbuf[7] = 'h';
295.                                 
296.                                  /* 测试发现只能使用获取的内存 */
297.                                  tcp_send (socket_tcp, sendbuf, maxlen);
298.                             }
299.                            
300.                        }while(ulCount > 0);
301.                        break;
302.                   
303.                     /* 其他的键值不处理 */
304.                    default:                    
305.                        break;
306.               }
307.          }
308.      }
309. }

复制代码

13.7.2 STM32F429开发板实验


配套例子：
        V6-1008_RL-TCPnet实验_TCP服务器（裸机）
实验目的：
        1.     学习RL-TCPnet的TCP服务器创建和数据收发。
实验内容：
        1.      强烈推荐将网线接到路由器或者交换机上面测试，因为已经使能了DHCP，可以自动获取IP地址。
        2.      创建了一个TCP Server，而且使能了局域网域名NetBIOS，用户只需在电脑端ping armfly就可以获得板子的IP地址，端口号1001。
        3.      用户可以在电脑端用网络调试软件创建TCP Client连接此服务器端。
        4.      按键K1按下，发送8字节的数据给TCPClient。
        5.      按键K2按下，发送1024字节的数据给TCPClient。
        6.      按键K3按下，发送5MB字节的数据给TCPClient。
实验操作：
        详见本章节13.6小节。
配置向导文件设置（Net_Config.c）：
        详见本章节13.3小节。
调试文件设置（Net_Debug.c）：
        详见本章节13.4小节。
程序设计：
u  主函数初始化
        在main.c文件实现：

1. /*
2. *********************************************************************************************************
3. *    函 数 名: main
4. *    功能说明: 标准c程序入口。
5. *    形    参: 无
6. *    返 回 值: 无
7. *********************************************************************************************************
8. */
9. int main (void)
10. {   
11.      /* 初始化外设 */
12.      bsp_Init();
14.      /* 进入RL-TCPnet测试函数 */
15.      TCPnetTest();
16. }

复制代码

u  硬件外设初始化
       硬件外设的初始化是在 bsp.c 文件实现：

1. /*
2. *********************************************************************************************************
3. *    函 数 名: bsp_Init
4. *    功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
5. *    形    参：无
6. *    返 回 值: 无
7. *********************************************************************************************************
8. */
9. void bsp_Init(void)
10. {
11.      /*
12.          由于ST固件库的启动文件已经执行了CPU系统时钟的初始化，所以不必再次重复配置系统时钟。
13.          启动文件配置了CPU主时钟频率、内部Flash访问速度和可选的外部SRAM FSMC初始化。
15.          系统时钟缺省配置为168MHz，如果需要更改，可以修改 system_stm32f4xx.c 文件
16.      */
17.      /* 优先级分组设置为4，可配置0-15级抢占式优先级，0级子优先级，即不存在子优先级。*/
18.      NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);
20.      bsp_InitUart();    /* 初始化串口 */
21.      bsp_InitKey();     /* 初始化按键变量（必须在 bsp_InitTimer() 之前调用） */
22.      bsp_InitLed();     /* 初始LED指示灯端口 */
23.      bsp_InitTimer();   /* 初始化滴答定时器 */
24. }

复制代码

u  RL-TCPnet功能测试
        这里专门创建了一个app_tcpnet_lib.c文件用于RL-TCPnet功能的测试，主要功能是创建了一个TCP Server。

1. /*
2. *********************************************************************************************************
3. *                                      用于本文件的调试
4. *********************************************************************************************************
5. */
6. #if 1
7.      #define printf_debug printf
8. #else
9.      #define printf_debug(...)
10. #endif
13. /*
14. *********************************************************************************************************
15. *                                      用于本文件的调试
16. *********************************************************************************************************
17. */
18. #define PORT_NUM       1001    /* TCP服务器监听端口号 */
21. /*
22. *********************************************************************************************************
23. *                                         变量
24. *********************************************************************************************************
25. */
26. uint8_t socket_tcp;
29. /*
30. *********************************************************************************************************
31. *    函 数 名: tcp_callback
32. *    功能说明: TCP Socket的回调函数
33. *    形    参: soc  TCP Socket类型
34. *             evt  事件类型
35. *             ptr  事件类型是TCP_EVT_DATA，ptr指向的缓冲区记录着接收到的TCP数据，其余事件记录IP地址
36. *             par  事件类型是TCP_EVT_DATA，记录接收到的数据个数，其余事件记录端口号
37. *    返 回 值:
38. *********************************************************************************************************
39. */
40. U16 tcp_callback (U8 soc, U8 evt, U8 *ptr, U16 par)
41. {
42.      char buf[50];
43.      uint16_t i;
44.    
45.      /* 确保是socket_tcp的回调 */
46.      if (soc != socket_tcp)
47.      {
48.          return (0);
49.      }
51.      switch (evt)
52.      {
53.          /*
54.               远程客户端连接消息
55.              1、数组ptr存储远程设备的IP地址，par中存储端口号。
56.              2、返回数值1允许连接，返回数值0禁止连接。
57.          */
58.          case TCP_EVT_CONREQ:
59.               sprintf(buf, "远程客户端请求连接IP: %d.%d.%d.%d", ptr[0], ptr[1], ptr[2], ptr[3]);
60.               printf_debug("IP:%s  port:%d\\r\\n", buf, par);
61.               return (1);
62.         
63.          /* 连接终止 */
64.          case TCP_EVT_ABORT:
65.               break;
66.         
67.          /* Socket远程连接已经建立 */
68.          case TCP_EVT_CONNECT:
69.               printf_debug("Socket is connected to remote peer\\r\\n");
70.               break;
71.         
72.          /* 连接断开 */
73.          case TCP_EVT_CLOSE:
74.               printf_debug("Connection has been closed\\r\\n");
75.               break;
76.         
77.          /* 发送的数据收到远程设备应答 */
78.          case TCP_EVT_ACK:
79.               break;
80.         
81.           /* 接收到TCP数据帧，ptr指向数据地址，par记录数据长度，单位字节 */
82.          case TCP_EVT_DATA:
83.               printf_debug("Data length = %d\\r\\n", par);
84.               for(i = 0; i < par; i++)
85.               {
86.                    printf_debug("ptr[%d] = %d\\r\\n", i, ptr[i]);
87.               }
88.               break;
89.      }
90.    
91.      return (0);
92. }
94. /*
95. *********************************************************************************************************
96. *    函 数 名: TCP_StatusCheck
97. *    功能说明: 检测TCP的连接状态，主要用于网线插拔的判断
98. *    形    参: 无
99. *    返 回 值: __TRUE  连接
100. *             __FALSE 断开
101. *********************************************************************************************************
102. */
103. uint8_t TCP_StatusCheck(void)
104. {
105.      uint8_t res;
106.    
107.      switch (tcp_get_state(socket_tcp))
108.      {
109.          case TCP_STATE_FREE:
110.          case TCP_STATE_CLOSED:
111.               res = tcp_listen (socket_tcp, PORT_NUM);
112.               printf_debug("tcp listen res = %d\\r\\n", res);
113.               break;
114.         
115.          case TCP_STATE_LISTEN:
116.               break;
117.         
118.          case TCP_STATE_CONNECT:
119.               return (__TRUE);
120.             
121.          default:
122.               break;
123.      }
124.    
125.      return (__FALSE);
126. }
128. /*
129. *********************************************************************************************************
130. *    函 数 名: tcpnet_poll
131. *    功能说明: 使用TCPnet必须要一直调用的函数
132. *    形    参: 无
133. *    返 回 值: 无
134. *********************************************************************************************************
135. */
136. void tcpnet_poll(void)
137. {
138.      if(bsp_CheckTimer(0))
139.      {
140.          /* 此函数坚决不可以放在中断里面跑 */
141.          timer_tick ();
142.      }
143.    
144.      main_TcpNet ();
145. }
147. /*
148. *********************************************************************************************************
149. *    函 数 名: TCPnetTest
150. *    功能说明: TCPnet应用
151. *    形    参: 无
152. *    返 回 值: 无
153. *********************************************************************************************************
154. */
155. void TCPnetTest(void)
156. {
157.      int32_t ulCount;
158.      uint8_t *sendbuf;
159.      uint8_t tcp_status;
160.      uint16_t maxlen;
161.      uint8_t res;
162.      uint8_t ucKeyCode;
163.    
164.    
165.      /* 初始化网络协议栈 */
166.      init_TcpNet ();
168.      /*
169.         创建TCP Socket并创建监听，客户端连接服务器后，10秒内无数据通信将断开连接。
170.         但是由于这里使能了TCP_TYPE_KEEP_ALIVE，会一直保持连接，不受10秒的时间限制。
171.      */
172.     socket_tcp = tcp_get_socket (TCP_TYPE_SERVER | TCP_TYPE_KEEP_ALIVE, 0, 10, tcp_callback);
173.      if(socket_tcp != 0)
174.      {
175.          res = tcp_listen (socket_tcp, PORT_NUM);
176.          printf_debug("tcp listen res = %d\\r\\n", res);
177.      }
179.      /* 创建一个周期是100ms的软定时器 */
180.     bsp_StartAutoTimer(0, 100);
181.    
182.      while (1)
183.      {
184.          /* TCP轮询 */
185.          tcpnet_poll();
186.         
187.           /* 用于网线插拔的处理 */
188.          tcp_status = TCP_StatusCheck();
189.         
190.           /* 按键消息的处理 */
191.          ucKeyCode = bsp_GetKey();
192.          if ((ucKeyCode != KEY_NONE)&&(tcp_status == __TRUE))
193.          {
194.               switch (ucKeyCode)
195.               {
196.                    /* K1键按下，给远程TCP客户端发送8字节数据 */
197.                    case KEY_DOWN_K1:            
198.                        printf_debug("tcp_get_state(socket_tcp) = %d\\r\\n", tcp_get_state(socket_tcp));
199.                        ulCount = 8;
200.                        do
201.                        {
202.                             tcpnet_poll();
203.                             if (tcp_check_send (socket_tcp) == __TRUE)
204.                             {
205.                                  maxlen = tcp_max_dsize (socket_tcp);
206.                                  ulCount -= maxlen;
207.                                 
208.                                  if(ulCount < 0)
209.                                  {
210.                                      /* 这么计算没问题的 */
211.                                      maxlen = ulCount + maxlen;
212.                                  }
213.                                 
214.                                  sendbuf = tcp_get_buf(maxlen);
215.                                  sendbuf[0] = '1';
216.                                  sendbuf[1] = '2';
217.                                  sendbuf[2] = '3';
218.                                  sendbuf[3] = '4';
219.                                  sendbuf[4] = '5';
220.                                  sendbuf[5] = '6';
221.                                  sendbuf[6] = '7';
222.                                  sendbuf[7] = '8';
223.                                 
224.                                  /* 测试发现只能使用获取的内存 */
225.                                  tcp_send (socket_tcp, sendbuf, maxlen);
226.                             }
227.                            
228.                        }while(ulCount > 0);
229.                        break;
231.                    /* K2键按下，给远程TCP客户端发送1024字节的数据 */
232.                    case KEY_DOWN_K2:     
233.                        printf_debug("tcp_get_state(socket_tcp) = %d\\r\\n", tcp_get_state(socket_tcp));
234.                        ulCount = 1024;
235.                        do
236.                        {
237.                             tcpnet_poll();
238.                             if (tcp_check_send (socket_tcp) == __TRUE)
239.                             {
240.                                  maxlen = tcp_max_dsize (socket_tcp);
241.                                  ulCount -= maxlen;
242.                                 
243.                                  if(ulCount < 0)
244.                                  {
245.                                      /* 这么计算没问题的 */
246.                                      maxlen = ulCount + maxlen;
247.                                  }
248.                                 
249.                                  /* 这里仅初始化了每次所发送数据包的前8个字节 */
250.                                  sendbuf = tcp_get_buf(maxlen);
251.                                  sendbuf[0] = 'a';
252.                                  sendbuf[1] = 'b';
253.                                  sendbuf[2] = 'c';
254.                                  sendbuf[3] = 'd';
255.                                  sendbuf[4] = 'e';
256.                                  sendbuf[5] = 'f';
257.                                  sendbuf[6] = 'g';
258.                                  sendbuf[7] = 'h';
259.                                 
260.                                  /* 测试发现只能使用获取的内存 */
261.                                  tcp_send (socket_tcp, sendbuf, maxlen);
262.                             }
263.                            
264.                        }while(ulCount > 0);                     
265.                        break;
266.                      
267.                    /* K3键按下，给远程TCP客户端发送5MB数据 */
268.                    case KEY_DOWN_K3:            
269.                        printf_debug("tcp_get_state(socket_tcp) = %d\\r\\n", tcp_get_state(socket_tcp));
270.                        ulCount = 5*1024*1024;
271.                        do
272.                        {
273.                             tcpnet_poll();
274.                             if (tcp_check_send (socket_tcp) == __TRUE)
275.                             {
276.                                  maxlen = tcp_max_dsize (socket_tcp);
277.                                  ulCount -= maxlen;
278.                                 
279.                                  if(ulCount < 0)
280.                                  {
281.                                      /* 这么计算没问题的 */
282.                                      maxlen = ulCount + maxlen;
283.                                  }
284.                                 
285.                                  /* 这里仅初始化了每次所发送数据包的前8个字节 */
286.                                  sendbuf = tcp_get_buf(maxlen);
287.                                  sendbuf[0] = 'a';
288.                                  sendbuf[1] = 'b';
289.                                  sendbuf[2] = 'c';
290.                                  sendbuf[3] = 'd';
291.                                  sendbuf[4] = 'e';
292.                                  sendbuf[5] = 'f';
293.                                  sendbuf[6] = 'g';
294.                                  sendbuf[7] = 'h';
295.                                 
296.                                  /* 测试发现只能使用获取的内存 */
297.                                  tcp_send (socket_tcp, sendbuf, maxlen);
298.                             }
299.                            
300.                        }while(ulCount > 0);
301.                        break;
302.                   
303.                     /* 其他的键值不处理 */
304.                    default:                    
305.                        break;
306.               }
307.          }
308.      }
309. }

复制代码

席萌0209

13.8 实验例程说明（RTX）



13.8.1 STM32F407开发板实验


配套例子：
    V5-1009_RL-TCPnet实验_TCP服务器（RTX）
实验目的：
    1.     学习RL-TCPnet的TCP服务器创建和数据收发。
实验内容：
    1.      强烈推荐将网线接到路由器或者交换机上面测试，因为已经使能了DHCP，可以自动获取IP地址。
    2.      创建了一个TCP Server，而且使能了局域网域名NetBIOS，用户只需在电脑端ping armfly就可以获得板子的IP地址，端口号1001。
    3.      用户可以在电脑端用网络调试软件创建TCP Client连接此服务器端。
    4.      按键K1按下，发送8字节的数据给TCPClient。
    5.      按键K2按下，发送1024字节的数据给TCPClient。
    6.      按键K3按下，发送5MB字节的数据给TCPClient。
实验操作：
    详见本章节13.6小节。
配置向导文件设置（Net_Config.c）：
    详见本章节13.3小节。
调试文件设置（Net_Debug.c）：
    详见本章节13.4小节。
RTX配置：
    RTX配置向导详情如下：

u  Task Configuration
（1）Number of concurrent running tasks
    允许创建6个任务，实际创建了如下5个任务：
    AppTaskUserIF任务 ：按键消息处理。
    AppTaskLED任务    ：LED闪烁。
    AppTaskMsgPro任务 ：按键检测。
    AppTaskTCPMain任务：RL-TCPnet测试任务。
    AppTaskStart任务  ：启动任务，也是最高优先级任务，这里实现RL-TCPnet的时间基准更新。
（2）Number of tasks with user-provided stack
    创建的5个任务都是采用自定义堆栈方式。
（3）Run in privileged mode
    设置任务运行在非特权级模式。
RTX任务调试信息：

程序设计：
u  任务栈大小分配：
    staticuint64_t AppTaskUserIFStk[1024/8];   /* 任务栈 */
    staticuint64_t AppTaskLEDStk[1024/8];      /* 任务栈 */
    staticuint64_t AppTaskMsgProStk[1024/8];  /* 任务栈 */
    staticuint64_t AppTaskTCPMainStk[2048/8]; /* 任务栈 */
    staticuint64_t AppTaskStartStk[1024/8];     /* 任务栈 */
    将任务栈定义成uint64_t类型可以保证任务栈是8字节对齐的，8字节对齐的含义就是数组的首地址对8求余等于0。如果不做8字节对齐的话，部分C语言库函数、浮点运算和uint64_t类型数据运算会出问题。
u  系统栈大小分配：

u  RTX初始化：

1. /*
2. *********************************************************************************************************
3. *    函 数 名: main
4. *    功能说明: 标准c程序入口。
5. *    形    参: 无
6. *    返 回 值: 无
7. *********************************************************************************************************
8. */
9. int main (void)
10. {   
11.      /* 初始化外设 */
12.      bsp_Init();
13.    
14.      /* 创建启动任务 */
15.      os_sys_init_user (AppTaskStart,              /* 任务函数 */
16.                        5,                         /* 任务优先级 */
17.                        &AppTaskStartStk,          /* 任务栈 */
18.                        sizeof(AppTaskStartStk));  /* 任务栈大小，单位字节数 */
19.      while(1);
20. }

复制代码

u  硬件外设初始化
    硬件外设的初始化是在 bsp.c 文件实现：

1. /*
2. *********************************************************************************************************
3. *    函 数 名: bsp_Init
4. *    功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
5. *    形    参：无
6. *    返 回 值: 无
7. *********************************************************************************************************
8. */
9. void bsp_Init(void)
10. {
11.      /*
12.          由于ST固件库的启动文件已经执行了CPU系统时钟的初始化，所以不必再次重复配置系统时钟。
13.          启动文件配置了CPU主时钟频率、内部Flash访问速度和可选的外部SRAM FSMC初始化。
15.          系统时钟缺省配置为168MHz，如果需要更改，可以修改 system_stm32f4xx.c 文件
16.      */
17.      /* 优先级分组设置为4，可配置0-15级抢占式优先级，0级子优先级，即不存在子优先级。*/
18.      NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);
20.      bsp_InitDWT();     /* 初始化DWT */
21.      bsp_InitUart();    /* 初始化串口 */
22.      bsp_InitKey();    /* 初始化按键变量（必须在 bsp_InitTimer() 之前调用） */
23.      bsp_InitLed();    /* 初始LED指示灯端口 */
24. }

复制代码

u  RTX任务创建：

1. /*
2. *********************************************************************************************************
3. *    函 数 名: AppTaskCreate
4. *    功能说明: 创建应用任务
5. *    形    参: 无
6. *    返 回 值: 无
7. *********************************************************************************************************
8. */
9. static void AppTaskCreate (void)
10. {
11.      HandleTaskUserIF = os_tsk_create_user(AppTaskUserIF,             /* 任务函数 */
12.                                            1,                         /* 任务优先级 */
13.                                            &AppTaskUserIFStk,         /* 任务栈 */
14.                                            sizeof(AppTaskUserIFStk)); /* 任务栈大小，单位字节数 */
15.    
16.      HandleTaskLED = os_tsk_create_user(AppTaskLED,              /* 任务函数 */
17.                                         2,                       /* 任务优先级 */
18.                                         &AppTaskLEDStk,          /* 任务栈 */
19.                                         sizeof(AppTaskLEDStk));  /* 任务栈大小，单位字节数 */
20.    
21.      HandleTaskMsgPro = os_tsk_create_user(AppTaskMsgPro,             /* 任务函数 */
22.                                            3,                         /* 任务优先级 */
23.                                            &AppTaskMsgProStk,         /* 任务栈 */
24.                                            sizeof(AppTaskMsgProStk)); /* 任务栈大小，单位字节数 */
25.    
26.     HandleTaskTCPMain = os_tsk_create_user(AppTaskTCPMain,             /* 任务函数 */
27.                                            4,                         /* 任务优先级 */
28.                                            &AppTaskTCPMainStk,         /* 任务栈 */
29.                                            sizeof(AppTaskTCPMainStk)); /* 任务栈大小，单位字节数 */
30. }

复制代码

u  五个RTX任务的实现：

1. /*
2. *********************************************************************************************************
3. *    函 数 名: AppTaskUserIF
4. *    功能说明: 按键消息处理     
5. *    形    参: 无
6. *    返 回 值: 无
7. *   优 先 级: 1  (数值越小优先级越低，这个跟uCOS相反)
8. *********************************************************************************************************
9. */
10. __task void AppTaskUserIF(void)
11. {
12.      uint8_t ucKeyCode;
14.     while(1)
15.     {
16.          ucKeyCode = bsp_GetKey();
17.         
18.          if (ucKeyCode != KEY_NONE)
19.          {
20.               switch (ucKeyCode)
21.               {
22.                    /* K1键按下，直接发送事件标志给任务AppTaskTCPMain，设置bit0 */
23.                    case KEY_DOWN_K1:
24.                        printf("K1键按下，直接发送事件标志给任务AppTaskTCPMain，bit0被设置\\r\\n");
25.                        os_evt_set (KEY1_BIT0, HandleTaskTCPMain);                     
26.                        break;  
28.                    /* K2键按下，直接发送事件标志给任务AppTaskTCPMain，设置bit1 */
29.                    case KEY_DOWN_K2:
30.                        printf("K2键按下，直接发送事件标志给任务AppTaskTCPMain，bit1被设置\\r\\n");
31.                        os_evt_set (KEY2_BIT1, HandleTaskTCPMain);
32.                        break;
33.                   
34.                    /* K3键按下，直接发送事件标志给任务AppTaskTCPMain，设置bit2 */
35.                    case KEY_DOWN_K3:
36.                        printf("K3键按下，直接发送事件标志给任务AppTaskTCPMain，bit2被设置\\r\\n");
37.                        os_evt_set (KEY3_BIT2, HandleTaskTCPMain);
38.                        break;
40.                    /* 其他的键值不处理 */
41.                    default:                    
42.                        break;
43.               }
44.          }
45.         
46.          os_dly_wait(20);
47.      }
48. }
50. /*
51. *********************************************************************************************************
52. *    函 数 名: AppTaskLED
53. *    功能说明: LED闪烁。
54. *    形    参: 无
55. *    返 回 值: 无
56. *   优 先 级: 2
57. *********************************************************************************************************
58. */
59. __task void AppTaskLED(void)
60. {
61.      const uint16_t usFrequency = 500; /* 延迟周期 */
62.    
63.      /* 设置延迟周期 */
64.      os_itv_set(usFrequency);
65.    
66.     while(1)
67.     {
68.          bsp_LedToggle(2);
70.          /* os_itv_wait是绝对延迟，os_dly_wait是相对延迟。*/
71.          os_itv_wait();
72.     }
73. }
75. /*
76. *********************************************************************************************************
77. *    函 数 名: AppTaskMsgPro
78. *    功能说明: 按键检测
79. *    形    参: 无
80. *    返 回 值: 无
81. *   优 先 级: 3
82. *********************************************************************************************************
83. */
84. __task void AppTaskMsgPro(void)
85. {
86.     while(1)
87.     {
88.          bsp_KeyScan();
89.          os_dly_wait(10);
90.     }
91. }
93. /*
94. *********************************************************************************************************
95. *    函 数 名: AppTaskTCPMain
96. *    功能说明: RL-TCPnet测试任务
97. *    形    参: 无
98. *    返 回 值: 无
99. *   优 先 级: 4
100. *********************************************************************************************************
101. */
102. __task void AppTaskTCPMain(void)
103. {
104.      while (1)
105.      {
106.          TCPnetTest();
107.      }
108. }
110. /*
111. *********************************************************************************************************
112. *    函 数 名: AppTaskStart
113. *    功能说明: 启动任务，也是最高优先级任务，这里实现RL-TCPnet的时间基准更新。
114. *    形    参: 无
115. *    返 回 值: 无
116. *   优 先 级: 5
117. *********************************************************************************************************
118. */
119. __task void AppTaskStart(void)
120. {
121.      /* 初始化RL-TCPnet */
122.      init_TcpNet ();
123.    
124.      /* 创建任务 */
125.      AppTaskCreate();
126.    
127.      os_itv_set (100);
128.    
129.     while(1)
130.     {
131.          os_itv_wait ();
132.         
133.          /* RL-TCPnet时间基准更新函数 */
134.          timer_tick ();
135.     }
136. }

复制代码

u  RL-TCPnet功能测试
    这里专门创建了一个app_tcpnet_lib.c文件用于RL-TCPnet功能的测试，主要功能是创建了一个TCP Server。

1. #include "includes.h"
5. /*
6. *********************************************************************************************************
7. *                                      用于本文件的调试
8. *********************************************************************************************************
9. */
10. #if 1
11.      #define printf_debug printf
12. #else
13.      #define printf_debug(...)
14. #endif
17. /*
18. *********************************************************************************************************
19. *                                      用于本文件的调试
20. *********************************************************************************************************
21. */
22. #define PORT_NUM       1001    /* TCP服务器监听端口号 */
25. /*
26. *********************************************************************************************************
27. *                                         变量
28. *********************************************************************************************************
29. */
30. uint8_t socket_tcp;
33. /*
34. *********************************************************************************************************
35. *    函 数 名: tcp_callback
36. *    功能说明: TCP Socket的回调函数
37. *    形    参: soc  TCP Socket类型
38. *             evt  事件类型
39. *             ptr  事件类型是TCP_EVT_DATA，ptr指向的缓冲区记录着接收到的TCP数据，其余事件记录IP地址
40. *             par  事件类型是TCP_EVT_DATA，记录接收到的数据个数，其余事件记录端口号
41. *    返 回 值:
42. *********************************************************************************************************
43. */
44. U16 tcp_callback (U8 soc, U8 evt, U8 *ptr, U16 par)
45. {
46.      char buf[50];
47.      uint16_t i;
48.    
49.      /* 确保是socket_tcp的回调 */
50.      if (soc != socket_tcp)
51.      {
52.          return (0);
53.      }
55.      switch (evt)
56.      {
57.          /*
58.               远程客户端连接消息
59.              1、数组ptr存储远程设备的IP地址，par中存储端口号。
60.              2、返回数值1允许连接，返回数值0禁止连接。
61.          */
62.          case TCP_EVT_CONREQ:
63.               sprintf(buf, "远程客户端请求连接IP: %d.%d.%d.%d", ptr[0], ptr[1], ptr[2], ptr[3]);
64.               printf_debug("IP:%s  port:%d\\r\\n", buf, par);
65.               return (1);
66.         
67.           /* 连接终止 */
68.          case TCP_EVT_ABORT:
69.               break;
70.         
71.          /* Socket远程连接已经建立 */
72.          case TCP_EVT_CONNECT:
73.               printf_debug("Socket is connected to remote peer\\r\\n");
74.               break;
75.         
76.          /* 连接断开 */
77.          case TCP_EVT_CLOSE:
78.               printf_debug("Connection has been closed\\r\\n");
79.               break;
80.         
81.          /* 发送的数据收到远程设备应答 */
82.          case TCP_EVT_ACK:
83.               break;
84.         
85.          /* 接收到TCP数据帧，ptr指向数据地址，par记录数据长度，单位字节 */
86.          case TCP_EVT_DATA:
87.               printf_debug("Data length = %d\\r\\n", par);
88.               for(i = 0; i < par; i++)
89.               {
90.                    printf_debug("ptr[%d] = %d\\r\\n", i, ptr[i]);
91.               }
92.               break;
93.      }
94.    
95.      return (0);
96. }
98. /*
99. *********************************************************************************************************
100. *    函 数 名: TCP_StatusCheck
101. *    功能说明: 检测TCP的连接状态，主要用于网线插拔的判断
102. *    形    参: 无
103. *    返 回 值: __TRUE  连接
104. *             __FALSE 断开
105. *********************************************************************************************************
106. */
107. uint8_t TCP_StatusCheck(void)
108. {
109.      uint8_t res;
110.    
111.      switch (tcp_get_state(socket_tcp))
112.      {
113.          case TCP_STATE_FREE:
114.          case TCP_STATE_CLOSED:
115.               res = tcp_listen (socket_tcp, PORT_NUM);
116.               printf_debug("tcp listen res = %d\\r\\n", res);
117.               break;
118.         
119.          case TCP_STATE_LISTEN:
120.               break;
121.         
122.          case TCP_STATE_CONNECT:
123.               return (__TRUE);
124.             
125.          default:
126.               break;
127.      }
128.    
129.      return (__FALSE);
130. }
132. /*
133. *********************************************************************************************************
134. *    函 数 名: TCPnetTest
135. *    功能说明: TCPnet应用
136. *    形    参: 无
137. *    返 回 值: 无
138. *********************************************************************************************************
139. */
140. void TCPnetTest(void)
141. {
142.      int32_t iCount;
143.      uint8_t *sendbuf;
144.      uint8_t tcp_status;
145.      uint16_t maxlen;
146.      uint8_t res;
147.      OS_RESULT xResult;
148.      const uint16_t usMaxBlockTime = 2; /* 延迟周期 */
150.      /*
151.         创建TCP Socket并创建监听，客户端连接服务器后，10秒内无数据通信将断开连接。
152.         但是由于这里使能了TCP_TYPE_KEEP_ALIVE，会一直保持连接，不受10秒的时间限制。
153.      */
154.     socket_tcp = tcp_get_socket (TCP_TYPE_SERVER|TCP_TYPE_KEEP_ALIVE, 0, 10, tcp_callback);
155.      if(socket_tcp != 0)
156.      {
157.          res = tcp_listen (socket_tcp, PORT_NUM);
158.          printf_debug("tcp listen res = %d\\r\\n", res);
159.      }
160.    
161.      while (1)
162.      {
163.          /* RL-TCPnet处理函数 */
164.          main_TcpNet();
165.         
166.          /* 用于网线插拔的处理 */
167.          tcp_status = TCP_StatusCheck();
168.         
169.          /* 按键消息的处理 */
170.          if((os_evt_wait_or(0xFFFF, usMaxBlockTime) == OS_R_EVT)&&(tcp_status == __TRUE))
171.          {
172.               xResult = os_evt_get ();
173.               switch (xResult)
174.               {
175.                    /* 接收到K1键按下，给远程TCP客户端发送8字节数据 */
176.                    case KEY1_BIT0:              
177.                        printf_debug("tcp_get_state(socket_tcp) = %d\\r\\n", tcp_get_state(socket_tcp));
178.                        iCount = 8;
179.                        do
180.                        {
181.                             main_TcpNet();
182.                             if (tcp_check_send (socket_tcp) == __TRUE)
183.                             {
184.                                  maxlen = tcp_max_dsize (socket_tcp);
185.                                  iCount -= maxlen;
186.                                 
187.                                  if(iCount < 0)
188.                                  {
189.                                       /* 这么计算没问题的 */
190.                                      maxlen = iCount + maxlen;
191.                                  }
192.                                 
193.                                  sendbuf = tcp_get_buf(maxlen);
194.                                  sendbuf[0] = '1';
195.                                  sendbuf[1] = '2';
196.                                  sendbuf[2] = '3';
197.                                  sendbuf[3] = '4';
198.                                  sendbuf[4] = '5';
199.                                  sendbuf[5] = '6';
200.                                  sendbuf[6] = '7';
201.                                  sendbuf[7] = '8';
202.                                 
203.                                  /* 测试发现只能使用获取的内存 */
204.                                  tcp_send (socket_tcp, sendbuf, maxlen);
205.                             }
206.                            
207.                        }while(iCount > 0);
208.                        break;
210.                    /* 接收到K2键按下，给远程TCP客户端发送1024字节的数据 */
211.                    case KEY2_BIT1:      
212.                        printf_debug("tcp_get_state(socket_tcp) = %d\\r\\n", tcp_get_state(socket_tcp));
213.                        iCount = 1024;
214.                        do
215.                        {
216.                             main_TcpNet();
217.                             if (tcp_check_send (socket_tcp) == __TRUE)
218.                             {
219.                                  maxlen = tcp_max_dsize (socket_tcp);
220.                                  iCount -= maxlen;
221.                               
222.                                  if(iCount < 0)
223.                                  {
224.                                       /* 这么计算没问题的 */
225.                                      maxlen = iCount + maxlen;
226.                                  }
227.                                 
228.                                  /* 这里仅初始化了每次所发送数据包的前8个字节 */
229.                                  sendbuf = tcp_get_buf(maxlen);
230.                                  sendbuf[0] = 'a';
231.                                  sendbuf[1] = 'b';
232.                                  sendbuf[2] = 'c';
233.                                  sendbuf[3] = 'd';
234.                                  sendbuf[4] = 'e';
235.                                  sendbuf[5] = 'f';
236.                                  sendbuf[6] = 'g';
237.                                  sendbuf[7] = 'h';
238.                                 
239.                                  /* 测试发现只能使用获取的内存 */
240.                                  tcp_send (socket_tcp, sendbuf, maxlen);
241.                             }
242.                            
243.                        }while(iCount > 0);                     
244.                         break;
245.                      
246.                    /* 接收到K3键按下，给远程TCP客户端发送5MB数据 */
247.                    case KEY3_BIT2:              
248.                        printf_debug("tcp_get_state(socket_tcp) = %d\\r\\n", tcp_get_state(socket_tcp));
249.                        iCount = 5*1024*1024;
250.                        do
251.                        {
252.                             main_TcpNet();
253.                             if (tcp_check_send (socket_tcp) == __TRUE)
254.                             {
255.                                  maxlen = tcp_max_dsize (socket_tcp);
256.                                  iCount -= maxlen;
257.                                 
258.                                  if(iCount < 0)
259.                                  {
260.                                      /* 这么计算没问题的 */
261.                                       maxlen = iCount + maxlen;
262.                                  }
263.                                 
264.                                  /* 这里仅初始化了每次所发送数据包的前8个字节 */
265.                                  sendbuf = tcp_get_buf(maxlen);
266.                                  sendbuf[0] = 'a';
267.                                  sendbuf[1] = 'b';
268.                                  sendbuf[2] = 'c';
269.                                  sendbuf[3] = 'd';
270.                                  sendbuf[4] = 'e';
271.                                  sendbuf[5] = 'f';
272.                                  sendbuf[6] = 'g';
273.                                  sendbuf[7] = 'h';
274.                                 
275.                                  /* 测试发现只能使用获取的内存 */
276.                                  tcp_send (socket_tcp, sendbuf, maxlen);
277.                             }
278.                            
279.                        }while(iCount > 0);
280.                        break;
281.                   
282.                     /* 其他的键值不处理 */
283.                    default:                    
284.                        break;
285.               }
286.          }
287.      }
288. }

复制代码

13.8.2 STM32F429开发板实验


配套例子：
    V6-1009_RL-TCPnet实验_TCP服务器（RTX）
实验目的：
    1.     学习RL-TCPnet的TCP服务器创建和数据收发。
实验内容：
    1.      强烈推荐将网线接到路由器或者交换机上面测试，因为已经使能了DHCP，可以自动获取IP地址。
    2.      创建了一个TCP Server，而且使能了局域网域名NetBIOS，用户只需在电脑端ping armfly就可以获得板子的IP地址，端口号1001。
    3.      用户可以在电脑端用网络调试软件创建TCP Client连接此服务器端。
    4.      按键K1按下，发送8字节的数据给TCPClient。
    5.      按键K2按下，发送1024字节的数据给TCPClient。
    6.      按键K3按下，发送5MB字节的数据给TCPClient。
实验操作：
    详见本章节13.6小节。
配置向导文件设置（Net_Config.c）：
    详见本章节13.3小节。
调试文件设置（Net_Debug.c）：
    详见本章节13.4小节。
RTX配置：
    RTX配置向导详情如下：

u  Task Configuration
（1）Number of concurrent running tasks
    允许创建6个任务，实际创建了如下5个任务：
    AppTaskUserIF任务   ：按键消息处理。
    AppTaskLED任务     ：LED闪烁。
    AppTaskMsgPro任务 ：按键检测。
    AppTaskTCPMain任务：RL-TCPnet测试任务。
    AppTaskStart任务  ：启动任务，也是最高优先级任务，这里实现RL-TCPnet的时间基准更新。
（2）Number of tasks with user-provided stack
    创建的5个任务都是采用自定义堆栈方式。
（3）Run in privileged mode
    设置任务运行在非特权级模式。
RTX任务调试信息：

程序设计：
u  任务栈大小分配：
    staticuint64_t AppTaskUserIFStk[1024/8];   /* 任务栈 */
    staticuint64_t AppTaskLEDStk[1024/8];      /* 任务栈 */
    staticuint64_t AppTaskMsgProStk[1024/8];  /* 任务栈 */
    staticuint64_t AppTaskTCPMainStk[2048/8]; /* 任务栈 */
    staticuint64_t AppTaskStartStk[1024/8];     /* 任务栈 */
    将任务栈定义成uint64_t类型可以保证任务栈是8字节对齐的，8字节对齐的含义就是数组的首地址对8求余等于0。如果不做8字节对齐的话，部分C语言库函数、浮点运算和uint64_t类型数据运算会出问题。
u  系统栈大小分配：

u  RTX初始化：

1. /*
2. *********************************************************************************************************
3. *    函 数 名: main
4. *    功能说明: 标准c程序入口。
5. *    形    参: 无
6. *    返 回 值: 无
7. *********************************************************************************************************
8. */
9. int main (void)
10. {   
11.      /* 初始化外设 */
12.      bsp_Init();
13.    
14.      /* 创建启动任务 */
15.      os_sys_init_user (AppTaskStart,              /* 任务函数 */
16.                        5,                         /* 任务优先级 */
17.                        &AppTaskStartStk,          /* 任务栈 */
18.                        sizeof(AppTaskStartStk));  /* 任务栈大小，单位字节数 */
19.      while(1);
20. }

复制代码

u  硬件外设初始化
    硬件外设的初始化是在 bsp.c 文件实现：

1. /*
2. *********************************************************************************************************
3. *    函 数 名: bsp_Init
4. *    功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
5. *    形    参：无
6. *    返 回 值: 无
7. *********************************************************************************************************
8. */
9. void bsp_Init(void)
10. {
11.      /*
12.          由于ST固件库的启动文件已经执行了CPU系统时钟的初始化，所以不必再次重复配置系统时钟。
13.          启动文件配置了CPU主时钟频率、内部Flash访问速度和可选的外部SRAM FSMC初始化。
15.          系统时钟缺省配置为168MHz，如果需要更改，可以修改 system_stm32f4xx.c 文件
16.      */
17.      /* 优先级分组设置为4，可配置0-15级抢占式优先级，0级子优先级，即不存在子优先级。*/
18.      NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);
20.      SystemCoreClockUpdate();    /* 根据PLL配置更新系统时钟频率变量 SystemCoreClock */
22.      bsp_InitDWT();      /* 初始化DWT */
23.      bsp_InitUart();     /* 初始化串口 */
24.      bsp_InitKey();     /* 初始化按键变量（必须在 bsp_InitTimer() 之前调用） */
26.      bsp_InitExtIO();    /* FMC总线上扩展了32位输出IO, 操作LED等外设必须初始化 */
27.      bsp_InitLed();      /* 初始LED指示灯端口 */
28. }

复制代码

u  RTX任务创建：

1. /*
2. *********************************************************************************************************
3. *    函 数 名: AppTaskCreate
4. *    功能说明: 创建应用任务
5. *    形    参: 无
6. *    返 回 值: 无
7. *********************************************************************************************************
8. */
9. static void AppTaskCreate (void)
10. {
11.      HandleTaskUserIF = os_tsk_create_user(AppTaskUserIF,             /* 任务函数 */
12.                                            1,                         /* 任务优先级 */
13.                                            &AppTaskUserIFStk,         /* 任务栈 */
14.                                            sizeof(AppTaskUserIFStk)); /* 任务栈大小，单位字节数 */
15.    
16.      HandleTaskLED = os_tsk_create_user(AppTaskLED,              /* 任务函数 */
17.                                         2,                       /* 任务优先级 */
18.                                         &AppTaskLEDStk,          /* 任务栈 */
19.                                         sizeof(AppTaskLEDStk));  /* 任务栈大小，单位字节数 */
20.    
21.      HandleTaskMsgPro = os_tsk_create_user(AppTaskMsgPro,             /* 任务函数 */
22.                                            3,                         /* 任务优先级 */
23.                                            &AppTaskMsgProStk,         /* 任务栈 */
24.                                            sizeof(AppTaskMsgProStk)); /* 任务栈大小，单位字节数 */
25.    
26.     HandleTaskTCPMain = os_tsk_create_user(AppTaskTCPMain,             /* 任务函数 */
27.                                            4,                         /* 任务优先级 */
28.                                            &AppTaskTCPMainStk,         /* 任务栈 */
29.                                            sizeof(AppTaskTCPMainStk)); /* 任务栈大小，单位字节数 */
30. }

复制代码

u  五个RTX任务的实现：

1. /*
2. *********************************************************************************************************
3. *    函 数 名: AppTaskUserIF
4. *    功能说明: 按键消息处理     
5. *    形    参: 无
6. *    返 回 值: 无
7. *   优 先 级: 1  (数值越小优先级越低，这个跟uCOS相反)
8. *********************************************************************************************************
9. */
10. __task void AppTaskUserIF(void)
11. {
12.      uint8_t ucKeyCode;
14.     while(1)
15.     {
16.          ucKeyCode = bsp_GetKey();
17.         
18.          if (ucKeyCode != KEY_NONE)
19.          {
20.               switch (ucKeyCode)
21.               {
22.                    /* K1键按下，直接发送事件标志给任务AppTaskTCPMain，设置bit0 */
23.                    case KEY_DOWN_K1:
24.                        printf("K1键按下，直接发送事件标志给任务AppTaskTCPMain，bit0被设置\\r\\n");
25.                        os_evt_set (KEY1_BIT0, HandleTaskTCPMain);                     
26.                        break;  
28.                    /* K2键按下，直接发送事件标志给任务AppTaskTCPMain，设置bit1 */
29.                    case KEY_DOWN_K2:
30.                        printf("K2键按下，直接发送事件标志给任务AppTaskTCPMain，bit1被设置\\r\\n");
31.                        os_evt_set (KEY2_BIT1, HandleTaskTCPMain);
32.                        break;
33.                   
34.                    /* K3键按下，直接发送事件标志给任务AppTaskTCPMain，设置bit2 */
35.                    case KEY_DOWN_K3:
36.                        printf("K3键按下，直接发送事件标志给任务AppTaskTCPMain，bit2被设置\\r\\n");
37.                        os_evt_set (KEY3_BIT2, HandleTaskTCPMain);
38.                        break;
40.                    /* 其他的键值不处理 */
41.                    default:                    
42.                        break;
43.               }
44.          }
45.         
46.          os_dly_wait(20);
47.      }
48. }
50. /*
51. *********************************************************************************************************
52. *    函 数 名: AppTaskLED
53. *    功能说明: LED闪烁。
54. *    形    参: 无
55. *    返 回 值: 无
56. *   优 先 级: 2
57. *********************************************************************************************************
58. */
59. __task void AppTaskLED(void)
60. {
61.      const uint16_t usFrequency = 500; /* 延迟周期 */
62.    
63.      /* 设置延迟周期 */
64.      os_itv_set(usFrequency);
65.    
66.     while(1)
67.     {
68.          bsp_LedToggle(2);
70.          /* os_itv_wait是绝对延迟，os_dly_wait是相对延迟。*/
71.          os_itv_wait();
72.     }
73. }
75. /*
76. *********************************************************************************************************
77. *    函 数 名: AppTaskMsgPro
78. *    功能说明: 按键检测
79. *    形    参: 无
80. *    返 回 值: 无
81. *   优 先 级: 3
82. *********************************************************************************************************
83. */
84. __task void AppTaskMsgPro(void)
85. {
86.     while(1)
87.     {
88.          bsp_KeyScan();
89.          os_dly_wait(10);
90.     }
91. }
93. /*
94. *********************************************************************************************************
95. *    函 数 名: AppTaskTCPMain
96. *    功能说明: RL-TCPnet测试任务
97. *    形    参: 无
98. *    返 回 值: 无
99. *   优 先 级: 4
100. *********************************************************************************************************
101. */
102. __task void AppTaskTCPMain(void)
103. {
104.      while (1)
105.      {
106.          TCPnetTest();
107.      }
108. }
110. /*
111. *********************************************************************************************************
112. *    函 数 名: AppTaskStart
113. *    功能说明: 启动任务，也是最高优先级任务，这里实现RL-TCPnet的时间基准更新。
114. *    形    参: 无
115. *    返 回 值: 无
116. *   优 先 级: 5
117. *********************************************************************************************************
118. */
119. __task void AppTaskStart(void)
120. {
121.      /* 初始化RL-TCPnet */
122.      init_TcpNet ();
123.    
124.      /* 创建任务 */
125.      AppTaskCreate();
126.    
127.      os_itv_set (100);
128.    
129.     while(1)
130.     {
131.          os_itv_wait ();
132.         
133.          /* RL-TCPnet时间基准更新函数 */
134.           timer_tick ();
135.     }
136. }

复制代码

u  RL-TCPnet功能测试
    这里专门创建了一个app_tcpnet_lib.c文件用于RL-TCPnet功能的测试，主要功能是创建了一个TCP Server。

1. #include "includes.h"
5. /*
6. *********************************************************************************************************
7. *                                      用于本文件的调试
8. *********************************************************************************************************
9. */
10. #if 1
11.      #define printf_debug printf
12. #else
13.      #define printf_debug(...)
14. #endif
17. /*
18. *********************************************************************************************************
19. *                                      用于本文件的调试
20. *********************************************************************************************************
21. */
22. #define PORT_NUM       1001    /* TCP服务器监听端口号 */
25. /*
26. *********************************************************************************************************
27. *                                         变量
28. *********************************************************************************************************
29. */
30. uint8_t socket_tcp;
33. /*
34. *********************************************************************************************************
35. *    函 数 名: tcp_callback
36. *    功能说明: TCP Socket的回调函数
37. *    形    参: soc  TCP Socket类型
38. *             evt  事件类型
39. *             ptr  事件类型是TCP_EVT_DATA，ptr指向的缓冲区记录着接收到的TCP数据，其余事件记录IP地址
40. *             par  事件类型是TCP_EVT_DATA，记录接收到的数据个数，其余事件记录端口号
41. *    返 回 值:
42. *********************************************************************************************************
43. */
44. U16 tcp_callback (U8 soc, U8 evt, U8 *ptr, U16 par)
45. {
46.      char buf[50];
47.      uint16_t i;
48.    
49.      /* 确保是socket_tcp的回调 */
50.      if (soc != socket_tcp)
51.      {
52.          return (0);
53.      }
55.      switch (evt)
56.      {
57.          /*
58.               远程客户端连接消息
59.              1、数组ptr存储远程设备的IP地址，par中存储端口号。
60.              2、返回数值1允许连接，返回数值0禁止连接。
61.          */
62.          case TCP_EVT_CONREQ:
63.               sprintf(buf, "远程客户端请求连接IP: %d.%d.%d.%d", ptr[0], ptr[1], ptr[2], ptr[3]);
64.               printf_debug("IP:%s  port:%d\\r\\n", buf, par);
65.               return (1);
66.         
67.           /* 连接终止 */
68.          case TCP_EVT_ABORT:
69.               break;
70.         
71.          /* Socket远程连接已经建立 */
72.          case TCP_EVT_CONNECT:
73.               printf_debug("Socket is connected to remote peer\\r\\n");
74.               break;
75.         
76.          /* 连接断开 */
77.          case TCP_EVT_CLOSE:
78.               printf_debug("Connection has been closed\\r\\n");
79.               break;
80.         
81.          /* 发送的数据收到远程设备应答 */
82.          case TCP_EVT_ACK:
83.               break;
84.         
85.          /* 接收到TCP数据帧，ptr指向数据地址，par记录数据长度，单位字节 */
86.          case TCP_EVT_DATA:
87.               printf_debug("Data length = %d\\r\\n", par);
88.               for(i = 0; i < par; i++)
89.               {
90.                    printf_debug("ptr[%d] = %d\\r\\n", i, ptr[i]);
91.               }
92.               break;
93.      }
94.    
95.      return (0);
96. }
98. /*
99. *********************************************************************************************************
100. *    函 数 名: TCP_StatusCheck
101. *    功能说明: 检测TCP的连接状态，主要用于网线插拔的判断
102. *    形    参: 无
103. *    返 回 值: __TRUE  连接
104. *             __FALSE 断开
105. *********************************************************************************************************
106. */
107. uint8_t TCP_StatusCheck(void)
108. {
109.      uint8_t res;
110.    
111.      switch (tcp_get_state(socket_tcp))
112.      {
113.          case TCP_STATE_FREE:
114.          case TCP_STATE_CLOSED:
115.               res = tcp_listen (socket_tcp, PORT_NUM);
116.               printf_debug("tcp listen res = %d\\r\\n", res);
117.               break;
118.         
119.          case TCP_STATE_LISTEN:
120.               break;
121.         
122.          case TCP_STATE_CONNECT:
123.               return (__TRUE);
124.             
125.          default:
126.               break;
127.      }
128.    
129.      return (__FALSE);
130. }
132. /*
133. *********************************************************************************************************
134. *    函 数 名: TCPnetTest
135. *    功能说明: TCPnet应用
136. *    形    参: 无
137. *    返 回 值: 无
138. *********************************************************************************************************
139. */
140. void TCPnetTest(void)
141. {
142.      int32_t iCount;
143.      uint8_t *sendbuf;
144.      uint8_t tcp_status;
145.      uint16_t maxlen;
146.      uint8_t res;
147.      OS_RESULT xResult;
148.      const uint16_t usMaxBlockTime = 2; /* 延迟周期 */
150.      /*
151.         创建TCP Socket并创建监听，客户端连接服务器后，10秒内无数据通信将断开连接。
152.         但是由于这里使能了TCP_TYPE_KEEP_ALIVE，会一直保持连接，不受10秒的时间限制。
153.      */
154.     socket_tcp = tcp_get_socket (TCP_TYPE_SERVER|TCP_TYPE_KEEP_ALIVE, 0, 10, tcp_callback);
155.      if(socket_tcp != 0)
156.      {
157.          res = tcp_listen (socket_tcp, PORT_NUM);
158.          printf_debug("tcp listen res = %d\\r\\n", res);
159.      }
160.    
161.      while (1)
162.      {
163.          /* RL-TCPnet处理函数 */
164.          main_TcpNet();
165.         
166.          /* 用于网线插拔的处理 */
167.          tcp_status = TCP_StatusCheck();
168.         
169.          /* 按键消息的处理 */
170.          if((os_evt_wait_or(0xFFFF, usMaxBlockTime) == OS_R_EVT)&&(tcp_status == __TRUE))
171.          {
172.               xResult = os_evt_get ();
173.               switch (xResult)
174.               {
175.                    /* 接收到K1键按下，给远程TCP客户端发送8字节数据 */
176.                    case KEY1_BIT0:              
177.                        printf_debug("tcp_get_state(socket_tcp) = %d\\r\\n", tcp_get_state(socket_tcp));
178.                        iCount = 8;
179.                        do
180.                        {
181.                             main_TcpNet();
182.                             if (tcp_check_send (socket_tcp) == __TRUE)
183.                             {
184.                                  maxlen = tcp_max_dsize (socket_tcp);
185.                                  iCount -= maxlen;
186.                                 
187.                                  if(iCount < 0)
188.                                  {
189.                                       /* 这么计算没问题的 */
190.                                      maxlen = iCount + maxlen;
191.                                  }
192.                                 
193.                                  sendbuf = tcp_get_buf(maxlen);
194.                                  sendbuf[0] = '1';
195.                                  sendbuf[1] = '2';
196.                                  sendbuf[2] = '3';
197.                                  sendbuf[3] = '4';
198.                                  sendbuf[4] = '5';
199.                                  sendbuf[5] = '6';
200.                                  sendbuf[6] = '7';
201.                                  sendbuf[7] = '8';
202.                                 
203.                                  /* 测试发现只能使用获取的内存 */
204.                                  tcp_send (socket_tcp, sendbuf, maxlen);
205.                             }
206.                            
207.                        }while(iCount > 0);
208.                        break;
210.                    /* 接收到K2键按下，给远程TCP客户端发送1024字节的数据 */
211.                    case KEY2_BIT1:      
212.                        printf_debug("tcp_get_state(socket_tcp) = %d\\r\\n", tcp_get_state(socket_tcp));
213.                        iCount = 1024;
214.                        do
215.                        {
216.                             main_TcpNet();
217.                             if (tcp_check_send (socket_tcp) == __TRUE)
218.                             {
219.                                  maxlen = tcp_max_dsize (socket_tcp);
220.                                  iCount -= maxlen;
221.                                 
222.                                  if(iCount < 0)
223.                                  {
224.                                       /* 这么计算没问题的 */
225.                                       maxlen = iCount + maxlen;
226.                                  }
227.                                 
228.                                  /* 这里仅初始化了每次所发送数据包的前8个字节 */
229.                                  sendbuf = tcp_get_buf(maxlen);
230.                                  sendbuf[0] = 'a';
231.                                  sendbuf[1] = 'b';
232.                                  sendbuf[2] = 'c';
233.                                  sendbuf[3] = 'd';
234.                                  sendbuf[4] = 'e';
235.                                  sendbuf[5] = 'f';
236.                                  sendbuf[6] = 'g';
237.                                  sendbuf[7] = 'h';
238.                                 
239.                                  /* 测试发现只能使用获取的内存 */
240.                                  tcp_send (socket_tcp, sendbuf, maxlen);
241.                             }
242.                            
243.                        }while(iCount > 0);                     
244.                        break;
245.                      
246.                    /* 接收到K3键按下，给远程TCP客户端发送5MB数据 */
247.                    case KEY3_BIT2:              
248.                        printf_debug("tcp_get_state(socket_tcp) = %d\\r\\n", tcp_get_state(socket_tcp));
249.                        iCount = 5*1024*1024;
250.                        do
251.                        {
252.                             main_TcpNet();
253.                             if (tcp_check_send (socket_tcp) == __TRUE)
254.                             {
255.                                  maxlen = tcp_max_dsize (socket_tcp);
256.                                  iCount -= maxlen;
257.                                 
258.                                  if(iCount < 0)
259.                                  {
260.                                      /* 这么计算没问题的 */
261.                                       maxlen = iCount + maxlen;
262.                                  }
263.                                 
264.                                  /* 这里仅初始化了每次所发送数据包的前8个字节 */
265.                                  sendbuf = tcp_get_buf(maxlen);
266.                                  sendbuf[0] = 'a';
267.                                  sendbuf[1] = 'b';
268.                                  sendbuf[2] = 'c';
269.                                  sendbuf[3] = 'd';
270.                                  sendbuf[4] = 'e';
271.                                  sendbuf[5] = 'f';
272.                                  sendbuf[6] = 'g';
273.                                  sendbuf[7] = 'h';
274.                                 
275.                                  /* 测试发现只能使用获取的内存 */
276.                                  tcp_send (socket_tcp, sendbuf, maxlen);
277.                             }
278.                            
279.                        }while(iCount > 0);
280.                        break;
281.                   
282.                     /* 其他的键值不处理 */
283.                    default:                    
284.                        break;
285.               }
286.          }
287.      }
288. }

复制代码

席萌0209

13.9 总结

        本章节就为大家讲解这么多，希望大家多做测试，争取可以熟练掌握这些API函数的使用。