【RL-TCPnet网络教程】第15章 RL-TCPnet之创建多个TCP连接

席萌0209

第15章      RL-TCPnet之创建多个TCP连接

        本章节为大家讲解RL-TCPnet的TCP多客户端实现，因为多客户端在实际项目中用到的地方还挺多，所以我们也专门开启一个章节做讲解。另外，学习本章节前，务必要优先学习第14章TCP客户端。学会创建一个TCP客户端了，创建多个客户端是一样的。
        本章教程含STM32F407开发板和STM32F429开发板。
15.1 初学者重要提示
15.2 创建多个TCP客户端连接服务器
15.3 TCP配置说明（Net_Config.c）
15.4 TCP调试说明（Net_Debug.c）
15.5 TCP客户端的实现方法
15.6 网络调试助手创建TCP服务器的方法
15.7 实验例程说明（裸机）
15.8 实验例程说明（RTX）
15.9      总结



15.1  初学者重要提示

1、学习本章节前，务必保证已经学习了第12章的TCP基础知识和第14章的TCP客户端。
2、相比前面章节的TCP服务器，TCP客户端的测试要稍麻烦些，例子中默认访问的TCP服务器端IP地址是192.168.1.2，端口号1001。大家测试时要根据自己电脑的实际IP地址设置app_tcpnet_lib.c文件中远程IP和端口。具体测试方法详看本章节的15.6小节。

15.2  创建多个TCP客户端连接服务器


    本章节为大家讲解一个多TCP客户端连接服务器的实例，因为实际项目中，这种情况还比较多，所以也作为一期教程进行专门的讲解。
    有了上期教程的基础，本期教程也比较好实现，用户仅需多创建几个TCP客户端，并配置Net_Config.c中可以创建的TCP Socket个数即可。本章节配套的例子是创建了三个TCP客户端跟电脑端的服务器连接通信。

15.3  TCP配置说明（Net_Config.c）


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

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

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。

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

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

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

TCP Sockets
        TCP Sockets配置，打上对勾就使能了此项功能
（1）Number of TCP Sockets
        用于配置可创建的TCP Sockets数量，由于要创建三个TCP客户端，这里配置为4，可以创建4个Socket。
（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接收窗口大小。

15.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

15.5 TCP客户端的实现方法


         有了本章节15.3小节的配置后，剩下的问题就是TCP客户端的创建和TCP客户端数据收发的实现。

15.5.1 创建三个TCP客户端


        TCP服务器的创建比较简单，调用函数tcp_get_socket即可（此函数的使用方法和注意事项在上一章的14.2.1小节有讲解），为了更好的管理这三个TCP客户端，专门为每个TCP客户端单独做一个C文件：

app_tcpclient1.c，app_tcpclient2.c和app_tcpclient3.c分别是TCP客户端1,2和3。下面以TCP客户端1为例说明，即app_tcpclient1.c文件：

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

复制代码

在这个文件中，专门对TCP客户端的创建进行了封装，这样仅需调用函数TcpConnect_Client1就可以创建TCP客户端了。此函数是在app_tcpnet_lib.c文件中被调用的，通过按下按键K1进行调用：

1. /*
2. *********************************************************************************************************
3. *                                      外部变量和函数调用
4. *********************************************************************************************************
5. */
6. extern uint8_t socket_tcp1;
7. extern void TcpConnect_Client1(uint8_t *_remip, uint16_t _remport, uint16_t _localport);
9. extern uint8_t socket_tcp2;
10. extern void TcpConnect_Client2(uint8_t *_remip, uint16_t _remport, uint16_t _localport);
12. extern uint8_t socket_tcp3;
13. extern void TcpConnect_Client3(uint8_t *_remip, uint16_t _remport, uint16_t _localport);
16. /*
17. *********************************************************************************************************
18. *                              宏定义，远程服务器的IP和端口
19. *********************************************************************************************************
20. */
21. /* 要访问的远程服务器IP和端口配置，也就是电脑端调试助手设置的IP和端口号 */
22. #define IP1            192
23. #define IP2            168
24. #define IP3            1
25. #define IP4            2
27. #define PORT_NUM         1001
29. /* 这个是本地端口 */
30. #define LocalPort_NUM1    1024
31. #define LocalPort_NUM2    1025
32. #define LocalPort_NUM3    1026
35. /*
36. *********************************************************************************************************
37. *                                         变量
38. *********************************************************************************************************
39. */
40. uint8_t Rem_IP[4] = {IP1,IP2,IP3,IP4};
42. /* TCP状态的返回值 */
43. const char * ReVal_Table[]=
44. {
45.      "0: TCP_STATE_FREE",                                       
46.      "1: TCP_STATE_CLOSED",
47.      "2: TCP_STATE_LISTEN",
48.      "3: TCP_STATE_SYN_REC",
49.      "4: TCP_STATE_SYN_SENT",                                         
50.      "5: TCP_STATE_FINW1",
51.      "6: TCP_STATE_FINW2",
52.      "7: TCP_STATE_CLOSING",
53.      "8: TCP_STATE_LAST_ACK",                                         
54.      "9: TCP_STATE_TWAIT",
55.      "10: TCP_STATE_CONNECT",
56.      "11: 连接还未创建",
57. };
59. /*
60. *********************************************************************************************************
61. *    函 数 名: tcpnet_poll
62. *    功能说明: 使用TCPnet必须要一直调用的函数
63. *    形    参: 无
64. *    返 回 值: 无
65. *********************************************************************************************************
66. */
67. void tcpnet_poll(void)
68. {
69.      if(bsp_CheckTimer(0))
70.      {
71.          bsp_LedToggle(2);
72.         
73.          /* 此函数坚决不可以放在中断里面跑 */
74.          timer_tick ();
75.      }
76.    
77.      main_TcpNet ();
78. }
80. /*
81. *********************************************************************************************************
82. *    函 数 名: TCPnetTest
83. *    功能说明: TCPnet应用
84. *    形    参: 无
85. *    返 回 值: 无
86. *********************************************************************************************************
87. */
88. void TCPnetTest(void)
89. {
90.      int32_t iCount;
91.      uint8_t *sendbuf;
92.      uint16_t maxlen;
93.      uint8_t ucKeyCode;
94.      uint8_t TcpState;
95.    
96.    
97.      /* 初始化网络协议栈 */
98.      init_TcpNet ();
99.    
100.      /* 创建一个周期是100ms的软定时器 */
101.     bsp_StartAutoTimer(0, 100);
103.      while (1)
104.      {
105.           /* TCP轮询 */
106.          tcpnet_poll();
108.          /* 按键消息的处理 */
109.          ucKeyCode = bsp_GetKey();
110.          if (ucKeyCode != KEY_NONE)
111.          {
112.               switch (ucKeyCode)
113.               {
114.                    /* K1键按下，TCP客户端1建立连接 */
115.                    case KEY_DOWN_K1:     
116.                        TcpState = tcp_get_state(socket_tcp1); //--------------（1）
117.                   
118.                         /*
119.                           TCP_STATE_CONNECT是最后一个状态，未创建连接的话，会返回数值255，这里就是专门处理
120.                           这种状态，将其设置下一个TCP_STATE_CONNECT+1，即我们这里自定义了一个未创建连接的
121.                           状态。
122.                        */
123.                        if(TcpState > TCP_STATE_CONNECT)  //--------------（2）
124.                        {
125.                             TcpState = TCP_STATE_CONNECT + 1;
126.                        }
127.                        printf_debug("TCP客户端1状态 = %s\\r\\n", ReVal_Table[TcpState]);
128.                   
129.                        if(TcpState != TCP_STATE_CONNECT) //--------------（3）
130.                        {
131.                             TcpConnect_Client1(Rem_IP, PORT_NUM, LocalPort_NUM1);
132.                        }
133.                        break;
134.                      
135.                    /* 其他的键值不处理 */
136.                    default:                    
137.                        break;
138.               }
139.          }
140.      }
141. }

复制代码

1.     优先检查TCP Socket的状态。
2.     TCP_STATE_CONNECT的状态定义在RTL.h文件：

1. /* TCP States */
2. #define TCP_STATE_FREE     0      /* Entry is free and unused                */
3. #define TCP_STATE_CLOSED   1      /* Entry allocated, socket still closed    */
4. #define TCP_STATE_LISTEN   2      /* Socket waiting for incoming connection  */
5. #define TCP_STATE_SYN_REC  3      /* SYN frame received                      */
6. #define TCP_STATE_SYN_SENT 4      /* SYN packet sent to establish a connect. */
7. #define TCP_STATE_FINW1    5      /* Tcp_close started FIN packet was sent   */
8. #define TCP_STATE_FINW2    6      /* Our FIN ack-ed, waiting for remote FIN  */
9. #define TCP_STATE_CLOSING  7      /* Received FIN independently of our FIN   */
10. #define TCP_STATE_LAST_ACK 8      /* Waiting for last ACK for our FIN        */
11. #define TCP_STATE_TWAIT    9      /* Timed waiting for 2MSL                  */
12. #define TCP_STATE_CONNECT  10     /* TCP Connection established              */

复制代码

        从上面的定义中可以看出TCP_STATE_CONNECT是定义在了最后一个状态。由于未建立TCP连接的话，函数tcp_get_state返回的数值是255，这11种状态中未定义，所以专门再定义一个状态，表示未创建。数值比TCP_STATE_CONNECT大1，用在我们自己定义的数组ReVal_Table中。
3.     未建立连接的话，调用函数TcpConnect_Client1创建连接。

15.5.2 TCP数据发送


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

1. /*
2. *********************************************************************************************************
3. *                                      外部变量和函数调用
4. *********************************************************************************************************
5. */
6. extern uint8_t socket_tcp1;
7. extern void TcpConnect_Client1(uint8_t *_remip, uint16_t _remport, uint16_t _localport);
9. extern uint8_t socket_tcp2;
10. extern void TcpConnect_Client2(uint8_t *_remip, uint16_t _remport, uint16_t _localport);
12. extern uint8_t socket_tcp3;
13. extern void TcpConnect_Client3(uint8_t *_remip, uint16_t _remport, uint16_t _localport);
16. /*
17. *********************************************************************************************************
18. *                              宏定义，远程服务器的IP和端口
19. *********************************************************************************************************
20. */
21. /* 要访问的远程服务器IP和端口配置，也就是电脑端调试助手设置的IP和端口号 */
22. #define IP1            192
23. #define IP2            168
24. #define IP3            1
25. #define IP4            2
27. #define PORT_NUM         1001
29. /* 这个是本地端口 */
30. #define LocalPort_NUM1    1024
31. #define LocalPort_NUM2    1025
32. #define LocalPort_NUM3    1026
35. /*
36. *********************************************************************************************************
37. *                                         变量
38. *********************************************************************************************************
39. */
40. uint8_t Rem_IP[4] = {IP1,IP2,IP3,IP4};
42. /* TCP状态的返回值 */
43. const char * ReVal_Table[]=
44. {
45.      "0: TCP_STATE_FREE",                                       
46.      "1: TCP_STATE_CLOSED",
47.      "2: TCP_STATE_LISTEN",
48.      "3: TCP_STATE_SYN_REC",
49.      "4: TCP_STATE_SYN_SENT",                                         
50.      "5: TCP_STATE_FINW1",
51.      "6: TCP_STATE_FINW2",
52.      "7: TCP_STATE_CLOSING",
53.      "8: TCP_STATE_LAST_ACK",                                         
54.      "9: TCP_STATE_TWAIT",
55.      "10: TCP_STATE_CONNECT",
56.      "11: 连接还未创建",
57. };
59. /*
60. *********************************************************************************************************
61. *    函 数 名: tcpnet_poll
62. *    功能说明: 使用TCPnet必须要一直调用的函数
63. *    形    参: 无
64. *    返 回 值: 无
65. *********************************************************************************************************
66. */
67. void tcpnet_poll(void)
68. {
69.      if(bsp_CheckTimer(0))
70.      {
71.          bsp_LedToggle(2);
72.         
73.          /* 此函数坚决不可以放在中断里面跑 */
74.          timer_tick ();//--------------（1）
75.      }
76.    
77.      main_TcpNet ();//--------------（2）
78. }
80. /*
81. *********************************************************************************************************
82. *    函 数 名: TCPnetTest
83. *    功能说明: TCPnet应用
84. *    形    参: 无
85. *    返 回 值: 无
86. *********************************************************************************************************
87. */
88. void TCPnetTest(void)
89. {
90.      int32_t iCount;
91.      uint8_t *sendbuf;
92.      uint16_t maxlen;
93.      uint8_t ucKeyCode;
94.      uint8_t TcpState;
95.    
96.    
97.      /* 初始化网络协议栈 */
98.      init_TcpNet ();
99.    
100.      /* 创建一个周期是100ms的软定时器 */
101.     bsp_StartAutoTimer(0, 100);
103.      while (1)
104.      {
105.          /* TCP轮询 */
106.          tcpnet_poll();
108.          /* 按键消息的处理 */
109.          ucKeyCode = bsp_GetKey();
110.          if (ucKeyCode != KEY_NONE)
111.          {
112.               switch (ucKeyCode)
113.               {
114.                    /* K1键按下，TCP客户端1建立连接 */
115.                    case KEY_DOWN_K1:     
116.                        TcpState = tcp_get_state(socket_tcp1);
117.                   
118.                         /*
119.                           TCP_STATE_CONNECT是最后一个状态，未创建连接的话，会返回数值255，这里就是专门处理
120.                           这种状态，将其设置下一个TCP_STATE_CONNECT+1，即我们这里自定义了一个未创建连接的
121.                           状态。
122.                        */
123.                        if(TcpState > TCP_STATE_CONNECT)
124.                        {
125.                             TcpState = TCP_STATE_CONNECT + 1;
126.                        }
127.                        printf_debug("TCP客户端1状态 = %s\\r\\n", ReVal_Table[TcpState]);
128.                   
129.                        if(TcpState != TCP_STATE_CONNECT)
130.                        {
131.                             TcpConnect_Client1(Rem_IP, PORT_NUM, LocalPort_NUM1);
132.                        }
133.                        break;
134.                                              
135.                   
136.                    /* 摇杆上键按下，TCP客户端1向TCP服务器发送4096字节数据 */
137.                    case JOY_DOWN_U:
138.                        TcpState = tcp_get_state(socket_tcp1);
139.                        printf_debug("TCP客户端1状态 = %s\\r\\n", ReVal_Table[TcpState]);                  
140.                        iCount = 4096; //--------------（3）
141.                        /* 保证已经建立连接了才可以发送数据 */
142.                        if(TcpState == TCP_STATE_CONNECT)
143.                        {
144.                             do   //--------------（4）
145.                             {
146.                                  tcpnet_poll();
147.                                  if (tcp_check_send (socket_tcp1) == __TRUE)
148.                                  {
149.                                      maxlen = tcp_max_dsize (socket_tcp1);
150.                                      iCount -= maxlen;
151.                                     
152.                                      if(iCount < 0)
153.                                      {
154.                                           /* 这么计算没问题的 */
155.                                           maxlen = iCount + maxlen;
156.                                      }
157.                                     
158.                                      /* 这里仅初始化了每次所发送数据包的前8个字节 */
159.                                      sendbuf = tcp_get_buf(maxlen);
160.                                      sendbuf[0] = 'a';
161.                                      sendbuf[1] = 'b';
162.                                      sendbuf[2] = 'c';
163.                                      sendbuf[3] = 'd';
164.                                      sendbuf[4] = 'e';
165.                                      sendbuf[5] = 'f';
166.                                      sendbuf[6] = 'g';
167.                                       sendbuf[7] = 'h';
168.                                     
169.                                       /* 测试发现只能使用获取的内存 */
170.                                      tcp_send (socket_tcp1, sendbuf, maxlen);
171.                                  }
172.                                 
173.                             }while(iCount > 0);        
174.                        }      
175.                        break;
176.                                              
177.                    /* 其他的键值不处理 */
178.                    default:                    
179.                        break;
180.               }
181.          }
182.      }
183. }

复制代码

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

说完了裸机方式，下面说说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 voidAppTaskTCPMain(void)
11. {
12.      while (1)
13.      {
14.          TCPnetTest();
15.      }
16. }

复制代码

函数TCPnetTest的具体实现如下：

1. /*
2. *********************************************************************************************************
3. *                              宏定义，远程服务器的IP和端口
4. *********************************************************************************************************
5. */
6. /* 要访问的远程服务器IP和端口配置，也就是电脑端调试助手设置的IP和端口号 */
7. #define IP1            192
8. #define IP2            168
9. #define IP3            1
10. #define IP4            2
12. #define PORT_NUM         1001
14. /* 这个是本地端口 */
15. #define LocalPort_NUM1    1024
16. #define LocalPort_NUM2    1025
17. #define LocalPort_NUM3    1026
20. /*
21. *********************************************************************************************************
22. *                                         变量
23. *********************************************************************************************************
24. */
25. uint8_t Rem_IP[4] = {IP1,IP2,IP3,IP4};
27. /* TCP状态的返回值 */
28. const char * ReVal_Table[]=
29. {
30.      "0: TCP_STATE_FREE",                                       
31.      "1: TCP_STATE_CLOSED",
32.      "2: TCP_STATE_LISTEN",
33.      "3: TCP_STATE_SYN_REC",
34.      "4: TCP_STATE_SYN_SENT",                                         
35.      "5: TCP_STATE_FINW1",
36.      "6: TCP_STATE_FINW2",
37.      "7: TCP_STATE_CLOSING",
38.      "8: TCP_STATE_LAST_ACK",                                         
39.      "9: TCP_STATE_TWAIT",
40.      "10: TCP_STATE_CONNECT",
41.      "11: 连接还未创建",
42. };
44. /*
45. *********************************************************************************************************
46. *    函 数 名: TCPnetTest
47. *    功能说明: TCPnet应用
48. *    形    参: 无
49. *    返 回 值: 无
50. *********************************************************************************************************
51. */
52. void TCPnetTest(void)
53. {
54.      int32_t iCount;
55.      uint8_t *sendbuf;
56.      uint16_t maxlen;
57.      uint8_t TcpState;
58.      OS_RESULT xResult;
59.      const uint16_t usMaxBlockTime = 2; /* 延迟周期 */
61.    
62.      while (1)
63.      {
64.          /* RL-TCPnet处理函数 */
65.          main_TcpNet();//--------------（1）
66.    
67.          /* 按键消息的处理 */
68.          if(os_evt_wait_or(0xFFFF, usMaxBlockTime) == OS_R_EVT) //--------------（2）
69.          {
70.               xResult = os_evt_get ();
71.               switch (xResult)
72.               {
73.                    /* 接收到K1键按下，TCP客户端1建立连接 */
74.                    case KEY1_BIT0:              
75.                        TcpState = tcp_get_state(socket_tcp1);
76.                   
77.                         /*
78.                           TCP_STATE_CONNECT是最后一个状态，未创建连接的话，会返回数值255，这里就是专门处理
79.                           这种状态，将其设置下一个TCP_STATE_CONNECT+1，即我们这里自定义了一个未创建连接的
80.                           状态。
81.                        */
82.                        if(TcpState > TCP_STATE_CONNECT)
83.                        {
84.                             TcpState = TCP_STATE_CONNECT + 1;
85.                        }
86.                        printf_debug("TCP客户端1状态 = %s\\r\\n", ReVal_Table[TcpState]);
87.                   
88.                        if(TcpState != TCP_STATE_CONNECT)
89.                        {
90.                             TcpConnect_Client1(Rem_IP, PORT_NUM, LocalPort_NUM1);
91.                        }
92.                        break;
93.                   
94.                    /* 接收到摇杆上键按下，TCP客户端1向TCP服务器发送4096字节数据 */
95.                    case JOY_U_BIT3:            
96.                        TcpState = tcp_get_state(socket_tcp1);
97.                        printf_debug("TCP客户端1状态 = %s\\r\\n", ReVal_Table[TcpState]);                  
98.                        iCount = 4096; //--------------（3）
99.                        /* 保证已经建立连接了才可以发送数据 */
100.                        if(TcpState == TCP_STATE_CONNECT) //--------------（4）
101.                        {
102.                             do   //--------------（5）
103.                             {
104.                                  main_TcpNet();
105.                                  if (tcp_check_send (socket_tcp1) == __TRUE)
106.                                  {
107.                                      maxlen = tcp_max_dsize (socket_tcp1);
108.                                      iCount -= maxlen;
109.                                     
110.                                      if(iCount < 0)
111.                                      {
112.                                           /* 这么计算没问题的 */
113.                                           maxlen = iCount + maxlen;
114.                                      }
115.                                     
116.                                       /* 这里仅初始化了每次所发送数据包的前8个字节 */
117.                                      sendbuf = tcp_get_buf(maxlen);
118.                                      sendbuf[0] = 'a';
119.                                      sendbuf[1] = 'b';
120.                                      sendbuf[2] = 'c';
121.                                      sendbuf[3] = 'd';
122.                                      sendbuf[4] = 'e';
123.                                      sendbuf[5] = 'f';
124.                                      sendbuf[6] = 'g';
125.                                      sendbuf[7] = 'h';
126.                                     
127.                                       /* 测试发现只能使用获取的内存 */
128.                                      tcp_send (socket_tcp1, sendbuf, maxlen);
129.                                  }
130.                                 
131.                             }while(iCount > 0);        
132.                        }      
133.                        break;               
134.                   
135.                    /* 其他的键值不处理 */
136.                    default:                    
137.                        break;
138.               }
139.          }
140.      }
141. }

复制代码

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

15.5.3 TCP数据接收


       TCP数据接收主要是通过函数tcp_get_socket的回调函数实现（裸机，RTX，uCOS-III和FreeRTOS是一样的），下面以TCP客户端1的数据接收为例进行说明：

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. *    返 回 值: 主要是TCP_EVT_CONREQ事件使用，返回数值1允许连接，返回数值0禁止连接。
10. *********************************************************************************************************
11. */
12. static U16 tcp_callback1 (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_tcp1)
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_debug1("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_debug1("Socket is connected to remote peer\\r\\n");
42.               break;
43.         
44.           /* 连接断开 */
45.          case TCP_EVT_CLOSE:
46.               printf_debug1("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_debug1("TCP客户端1接收到数据长度 = %d\\r\\n", par);
56.               for(i = 0; i < par; i++)
57.               {
58.                    printf_debug1("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

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


    我们这里使用下面这款调试助手，任何其它网络调试助手均可，不限制：http://www.armbbs.cn/forum.php?mod=viewthread&tid=1568 。
重要提示，操作的过程中务必要优先在电脑端创建TCP服务器并开启，然后再操作板子进行连接。因为本章节配套的实例在按键按下后调用函数tcp_connect只进行一次连接，如果在Net_Config.c文件中配置的重连次数范围内无法连接上，就不会再进行连接了，需要再次点击按键进行连接。

15.6.1 获取板子IP地址


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

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

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

获得IP地址是192.168.1.6。

15.6.2 获取电脑的IP地址


    获取电脑IP地址的方法很多，可以在网上邻居获取，也可以通过输入命令ipconfig获取，方法跟上面15.6.1小节中的方式一样：
（1）WIN+R组合键打开“运行”窗口，输入cmd。

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

（3）输入ipconfig后，回车。

获得电脑的IP地址是192.168.1.2。

15.6.3 在程序中配置要访问的远程IP地址和端口


    据前面15.6.2小节获取的电脑端IP地址，需要大家配置程序中app_tcpnet_lib.c文件开头的宏定义，其中IP地址填前面获取的192.168.1.2，大家要根据电脑实际的IP地址填写。而端口号，我们这里随意配置一个即可，配置为1001，后面电脑端使用网络调试助手创建TCP服务器时，务必要跟这个端口号统一：

1. /*
2. *********************************************************************************************************
3. *                              宏定义，远程服务器的IP和端口
4. *********************************************************************************************************
5. */
6. /* 要访问的远程服务器IP和端口配置，也就是电脑端调试助手设置的IP和端口号 */
7. #define IP1            192
8. #define IP2            168
9. #define IP3            1
10. #define IP4            2
12. #define PORT_NUM         1001

复制代码

15.6.4 网络调试助手创建TCP服务器

1、打开调试助手，点击左上角创建服务器：

2、弹出如下界面，指定IP设置为192.168.1.2，一定要跟15.6.2小节中获得的电脑IP地址一致，端口号1001，最后点击确定：

3、确定后的界面效果如下：

4、然后点击启动服务器：

如果开发板下载了TCP客户端的程序，并且开发板已经上电，按下板子上面的K1按键，可以看到客户端连接已经加入：

跟我们在程序中设置的设置的端口号，即app_tcpnet_lib.c文件开头的宏定义：#define LocalPort_NUM1    1024 是一致的。IP地址也跟15.6.1小节中获取的IP地址也是一致的。同样的方法，按下K2按键，可以看到TCP客户端2也加入了连接，端口号是1025：

按下K3按键，可以看到TCP客户端3也加入了连接，端口号1026：

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

15.6.5 TCP客户端发送数据


    板子和网络调试助手建立连接后就可以互相收发数据了。对于发送数据，三个TCP客户端都可以给服务器发送数据。
1、摇杆上键按下，TCP客户端1发送4096字节，每次发送数据包的前8个字节设置了字符a到字符h，后面都未做设置。

2、摇杆左键按下，TCP客户端2发送4096字节，每次发送数据包的前8个字节设置了字符a到字符h，后面都未做设置。

3、摇杆右键按下，TCP客户端3发送4096字节，每次发送数据包的前8个字节设置了字符a到字符h，后面都未做设置。

15.6.6 TCP客户端接收数据


    TCP服务器接收数据的测试也比较方便，我们这里通过网络调试助手给板子发送1到5，共5个字符。
1、 TCP客户端1数据接收测试。

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

字符1对应的ASCII值就是49，其它字符数值依次增加。测试也是没问题的。
2、TCP客户端2数据接收测试。

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

字符1对应的ASCII值就是49，其它字符数值依次增加。测试也是没问题的。
3、TCP客户端3数据接收测试。

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

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

席萌0209

15.7 实验例程说明（裸机）



15.7.1 STM32F407开发板实验


配套例子：
    V5-1016_RL-TCPnet实验_多个TCP客户端连接（裸机）
实验目的：
    1.     学习RL-TCPnet的多个TCP客户端创建和数据收发。
实验内容：
    1.      强烈推荐将网线接到路由器或者交换机上面测试，因为已经使能了DHCP，可以自动获取IP地址。
    2.      客户端的例子相比服务器的例子稍麻烦些，因为客户端的例子需要用户知道电脑端IP和端口号。并根据实际情况设置IP和端口号的宏定义，这个配置在文件app_tcpnet_lib.c开头，测试的时候板子要连接这个IP和端口（下面是默认配置，一定要根据实际情况重新配置，如果不会配置，看本例程对应的教程即可）：
        #define IP1            192
        #define IP2            168
        #define IP3            1
        #define IP4            2                 
        #define PORT_NUM       1001
    3.      本例程可以创建三个TCP Client，而且使能了局域网域名NetBIOS，用户只需在电脑端ping armfly就可以获得板子的IP地址，三个TCP Client的端口号分别是1024,1025和1026。
    4.      用户可以在电脑端用网络调试软件创建TCP Server跟这三个客户端建立连接。执行下面5--10步的操作时，优先将电脑端的TCP Server建立起来！
    5.      按键K1按下，创建TCP客户端1，并跟电脑端的TCP服务器建立连接。
    6.      按键K2按下，创建TCP客户端2，并跟电脑端的TCP服务器建立连接。
    7.      按键K3按下，创建TCP客户端3，并跟电脑端的TCP服务器建立连接。
    8.      摇杆上键按下，TCP客户端1给电脑端的TCP服务器发送4096字节数据。
    9.      摇杆左键按下，TCP客户端2给电脑端的TCP服务器发送4096字节数据。
    10.   摇杆右键按下，TCP客户端3给电脑端的TCP服务器发送4096字节数据。
实验操作：
    详见本章节15.6小节。
配置向导文件设置（Net_Config.c）：
    详见本章节15.3小节。
调试文件设置（Net_Debug.c）：
    详见本章节15.4小节。
程序设计：
主函数初始化
    在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. }

复制代码

硬件外设初始化
    硬件外设的初始化是在 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. }

复制代码

三个TCP客户端的实现
    三个TCP客户端实现都是一样的，我们这里仅以客户端1为例进行说明：

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

复制代码

RL-TCPnet功能测试
    这里专门创建了一个app_tcpnet_lib.c文件用于RL-TCPnet功能的测试。

1. #include "bsp.h"      
2. #include <RTL.h>
3. #include <stdio.h>
4. #include <Net_Config.h>
8. /*
9. *********************************************************************************************************
10. *                                      用于本文件的调试
11. *********************************************************************************************************
12. */
13. #if 1
14.      #define printf_debug printf
15. #else
16.      #define printf_debug(...)
17. #endif
20. /*
21. *********************************************************************************************************
22. *                                      外部变量和函数调用
23. *********************************************************************************************************
24. */
25. extern uint8_t socket_tcp1;
26. extern void TcpConnect_Client1(uint8_t *_remip, uint16_t _remport, uint16_t _localport);
28. extern uint8_t socket_tcp2;
29. extern void TcpConnect_Client2(uint8_t *_remip, uint16_t _remport, uint16_t _localport);
31. extern uint8_t socket_tcp3;
32. extern void TcpConnect_Client3(uint8_t *_remip, uint16_t _remport, uint16_t _localport);
35. /*
36. *********************************************************************************************************
37. *                              宏定义，远程服务器的IP和端口
38. *********************************************************************************************************
39. */
40. /* 要访问的远程服务器IP和端口配置，也就是电脑端调试助手设置的IP和端口号 */
41. #define IP1            192
42. #define IP2            168
43. #define IP3            1
44. #define IP4            2
46. #define PORT_NUM         1001
48. /* 这个是本地端口 */
49. #define LocalPort_NUM1    1024
50. #define LocalPort_NUM2    1025
51. #define LocalPort_NUM3    1026
54. /*
55. *********************************************************************************************************
56. *                                         变量
57. *********************************************************************************************************
58. */
59. uint8_t Rem_IP[4] = {IP1,IP2,IP3,IP4};
61. /* TCP状态的返回值 */
62. const char * ReVal_Table[]=
63. {
64.      "0: TCP_STATE_FREE",                                       
65.      "1: TCP_STATE_CLOSED",
66.      "2: TCP_STATE_LISTEN",
67.      "3: TCP_STATE_SYN_REC",
68.      "4: TCP_STATE_SYN_SENT",                                         
69.      "5: TCP_STATE_FINW1",
70.      "6: TCP_STATE_FINW2",
71.      "7: TCP_STATE_CLOSING",
72.      "8: TCP_STATE_LAST_ACK",                                         
73.      "9: TCP_STATE_TWAIT",
74.      "10: TCP_STATE_CONNECT",
75.      "11: 连接还未创建",
76. };
78. /*
79. *********************************************************************************************************
80. *    函 数 名: tcpnet_poll
81. *    功能说明: 使用TCPnet必须要一直调用的函数
82. *    形    参: 无
83. *    返 回 值: 无
84. *********************************************************************************************************
85. */
86. void tcpnet_poll(void)
87. {
88.      if(bsp_CheckTimer(0))
89.      {
90.          bsp_LedToggle(2);
91.         
92.          /* 此函数坚决不可以放在中断里面跑 */
93.          timer_tick ();
94.      }
95.    
96.      main_TcpNet ();
97. }
99. /*
100. *********************************************************************************************************
101. *    函 数 名: TCPnetTest
102. *    功能说明: TCPnet应用
103. *    形    参: 无
104. *    返 回 值: 无
105. *********************************************************************************************************
106. */
107. void TCPnetTest(void)
108. {
109.      int32_t iCount;
110.      uint8_t *sendbuf;
111.      uint16_t maxlen;
112.      uint8_t ucKeyCode;
113.      uint8_t TcpState;
114.    
115.    
116.      /* 初始化网络协议栈 */
117.      init_TcpNet ();
118.    
119.      /* 创建一个周期是100ms的软定时器 */
120.     bsp_StartAutoTimer(0, 100);
122.      while (1)
123.      {
124.           /* TCP轮询 */
125.          tcpnet_poll();
127.           /* 按键消息的处理 */
128.          ucKeyCode = bsp_GetKey();
129.          if (ucKeyCode != KEY_NONE)
130.          {
131.               switch (ucKeyCode)
132.               {
133.                    /* K1键按下，TCP客户端1建立连接 */
134.                    case KEY_DOWN_K1:     
135.                        TcpState = tcp_get_state(socket_tcp1);
136.                   
137.                         /*
138.                           TCP_STATE_CONNECT是最后一个状态，未创建连接的话，会返回数值255，这里就是专门处理
139.                           这种状态，将其设置下一个TCP_STATE_CONNECT+1，即我们这里自定义了一个未创建连接的
140.                           状态。
141.                        */
142.                        if(TcpState > TCP_STATE_CONNECT)
143.                        {
144.                             TcpState = TCP_STATE_CONNECT + 1;
145.                        }
146.                        printf_debug("TCP客户端1状态 = %s\\r\\n", ReVal_Table[TcpState]);
147.                   
148.                        if(TcpState != TCP_STATE_CONNECT)
149.                        {
150.                             TcpConnect_Client1(Rem_IP, PORT_NUM, LocalPort_NUM1);
151.                        }
152.                        break;
153.                      
154.                    /* K2键按下，TCP客户端2建立连接 */
155.                    case KEY_DOWN_K2:     
156.                        TcpState = tcp_get_state(socket_tcp2);
157.                   
158.                         /*
159.                           TCP_STATE_CONNECT是最后一个状态，未创建连接的话，会返回数值255，这里就是专门处理
160.                           这种状态，将其设置下一个TCP_STATE_CONNECT+1，即我们这里自定义了一个未创建连接的
161.                           状态。
162.                        */
163.                        if(TcpState > TCP_STATE_CONNECT)
164.                        {
165.                             TcpState = TCP_STATE_CONNECT + 1;
166.                        }
167.                        printf_debug("TCP客户端2状态 = %s\\r\\n", ReVal_Table[TcpState]);
168.                   
169.                        if(TcpState != TCP_STATE_CONNECT)
170.                        {
171.                             TcpConnect_Client2(Rem_IP, PORT_NUM, LocalPort_NUM2);
172.                        }   
173.                        break;
174.                      
175.                    /* K3键按下，TCP客户端3建立连接 */
176.                    case KEY_DOWN_K3:            
177.                        TcpState = tcp_get_state(socket_tcp3);
178.                   
179.                         /*
180.                           TCP_STATE_CONNECT是最后一个状态，未创建连接的话，会返回数值255，这里就是专门处理
181.                           这种状态，将其设置下一个TCP_STATE_CONNECT+1，即我们这里自定义了一个未创建连接的
182.                           状态。
183.                        */
184.                        if(TcpState > TCP_STATE_CONNECT)
185.                        {
186.                             TcpState = TCP_STATE_CONNECT + 1;
187.                        }
188.                   
189.                        printf_debug("TCP客户端3状态 = %s\\r\\n", ReVal_Table[TcpState]);
190.                   
191.                        if(TcpState != TCP_STATE_CONNECT)
192.                        {
193.                             TcpConnect_Client3(Rem_IP, PORT_NUM, LocalPort_NUM3);
194.                        }   
195.                        break;
196.                      
197.                   
198.                    /* 摇杆上键按下，TCP客户端1向TCP服务器发送4096字节数据 */
199.                    case JOY_DOWN_U:
200.                        TcpState = tcp_get_state(socket_tcp1);
201.                        printf_debug("TCP客户端1状态 = %s\\r\\n", ReVal_Table[TcpState]);                  
202.                        iCount = 4096;
203.                        /* 保证已经建立连接了才可以发送数据 */
204.                        if(TcpState == TCP_STATE_CONNECT)
205.                        {
206.                             do
207.                             {
208.                                  tcpnet_poll();
209.                                  if (tcp_check_send (socket_tcp1) == __TRUE)
210.                                  {
211.                                      maxlen = tcp_max_dsize (socket_tcp1);
212.                                      iCount -= maxlen;
213.                                     
214.                                      if(iCount < 0)
215.                                       {
216.                                           /* 这么计算没问题的 */
217.                                           maxlen = iCount + maxlen;
218.                                      }
219.                                     
220.                                      /* 这里仅初始化了每次所发送数据包的前8个字节 */
221.                                      sendbuf = tcp_get_buf(maxlen);
222.                                      sendbuf[0] = 'a';
223.                                      sendbuf[1] = 'b';
224.                                      sendbuf[2] = 'c';
225.                                      sendbuf[3] = 'd';
226.                                      sendbuf[4] = 'e';
227.                                      sendbuf[5] = 'f';
228.                                      sendbuf[6] = 'g';
229.                                      sendbuf[7] = 'h';
230.                                     
231.                                       /* 测试发现只能使用获取的内存 */
232.                                      tcp_send (socket_tcp1, sendbuf, maxlen);
233.                                  }
234.                                 
235.                             }while(iCount > 0);        
236.                        }      
237.                        break;
238.                      
239.                    /* 摇杆左键按下，TCP客户端2向TCP服务器发送4096字节数据 */
240.                    case JOY_DOWN_L:
241.                        TcpState = tcp_get_state(socket_tcp2);
242.                        printf_debug("TCP客户端2状态 = %s\\r\\n", ReVal_Table[TcpState]);                  
243.                        iCount = 4096;
244.                        /* 保证已经建立连接了才可以发送数据 */
245.                        if(TcpState == TCP_STATE_CONNECT)
246.                        {
247.                             do
248.                             {
249.                                  tcpnet_poll();
250.                                  if (tcp_check_send (socket_tcp2) == __TRUE)
251.                                  {
252.                                      maxlen = tcp_max_dsize (socket_tcp2);
253.                                      iCount -= maxlen;
254.                                     
255.                                      if(iCount < 0)
256.                                       {
257.                                           /* 这么计算没问题的 */
258.                                           maxlen = iCount + maxlen;
259.                                      }
260.                                     
261.                                       /* 这里仅初始化了每次所发送数据包的前8个字节 */
262.                                      sendbuf = tcp_get_buf(maxlen);
263.                                      sendbuf[0] = 'a';
264.                                      sendbuf[1] = 'b';
265.                                      sendbuf[2] = 'c';
266.                                      sendbuf[3] = 'd';
267.                                      sendbuf[4] = 'e';
268.                                      sendbuf[5] = 'f';
269.                                      sendbuf[6] = 'g';
270.                                      sendbuf[7] = 'h';
271.                                     
272.                                      /* 测试发现只能使用获取的内存 */
273.                                      tcp_send (socket_tcp2, sendbuf, maxlen);
274.                                  }
275.                                 
276.                             }while(iCount > 0);        
277.                        }      
278.                        break;
279.                   
280.                    /* 摇杆右键按下，TCP客户端3向TCP服务器发送4096字节数据 */
281.                    case JOY_DOWN_R:
282.                        TcpState = tcp_get_state(socket_tcp3);
283.                        printf_debug("TCP客户端3状态 = %s\\r\\n", ReVal_Table[TcpState]);                  
284.                        iCount = 4096;
285.                        /* 保证已经建立连接了才可以发送数据 */
286.                        if(TcpState == TCP_STATE_CONNECT)
287.                        {
288.                             do
289.                             {
290.                                  tcpnet_poll();
291.                                  if (tcp_check_send (socket_tcp3) == __TRUE)
292.                                  {
293.                                      maxlen = tcp_max_dsize (socket_tcp3);
294.                                      iCount -= maxlen;
295.                                     
296.                                      if(iCount < 0)
297.                                      {
298.                                           /* 这么计算没问题的 */
299.                                           maxlen = iCount + maxlen;
300.                                      }
301.                                     
302.                                       /* 这里仅初始化了每次所发送数据包的前8个字节 */
303.                                      sendbuf = tcp_get_buf(maxlen);
304.                                      sendbuf[0] = 'a';
305.                                      sendbuf[1] = 'b';
306.                                      sendbuf[2] = 'c';
307.                                      sendbuf[3] = 'd';
308.                                      sendbuf[4] = 'e';
309.                                      sendbuf[5] = 'f';
310.                                      sendbuf[6] = 'g';
311.                                      sendbuf[7] = 'h';
312.                                     
313.                                       /* 测试发现只能使用获取的内存 */
314.                                      tcp_send (socket_tcp3, sendbuf, maxlen);
315.                                  }
316.                                 
317.                             }while(iCount > 0);        
318.                        }      
319.                        break;
320.                      
321.                   /* 其他的键值不处理 */
322.                    default:                    
323.                        break;
324.               }
325.          }
326.      }
327. }

复制代码

15.7.2 STM32F429开发板实验


配套例子：
    V6-1016_RL-TCPnet实验_多个TCP客户端连接（裸机）
实验目的：
    1.     学习RL-TCPnet的多个TCP客户端创建和数据收发。
实验内容：
    1.      强烈推荐将网线接到路由器或者交换机上面测试，因为已经使能了DHCP，可以自动获取IP地址。
    2.      客户端的例子相比服务器的例子稍麻烦些，因为客户端的例子需要用户知道电脑端IP和端口号。并根据实际情况设置IP和端口号的宏定义，这个配置在文件app_tcpnet_lib.c开头，测试的时候板子要连接这个IP和端口（下面是默认配置，一定要根据实际情况重新配置，如果不会配置，看本例程对应的教程即可）：
        #define IP1            192
        #define IP2            168
        #define IP3            1
        #define IP4            2               
        #define PORT_NUM       1001
    3.      本例程可以创建三个TCP Client，而且使能了局域网域名NetBIOS，用户只需在电脑端ping armfly就可以获得板子的IP地址，三个TCP Client的端口号分别是1024,1025和1026。
    4.      用户可以在电脑端用网络调试软件创建TCP Server跟这三个客户端建立连接。执行下面5--10步的操作时，优先将电脑端的TCP Server建立起来！
    5.      按键K1按下，创建TCP客户端1，并跟电脑端的TCP服务器建立连接。
    6.      按键K2按下，创建TCP客户端2，并跟电脑端的TCP服务器建立连接。
    7.      按键K3按下，创建TCP客户端3，并跟电脑端的TCP服务器建立连接。
    8.      摇杆上键按下，TCP客户端1给电脑端的TCP服务器发送4096字节数据。
    9.      摇杆左键按下，TCP客户端2给电脑端的TCP服务器发送4096字节数据。
    10.   摇杆右键按下，TCP客户端3给电脑端的TCP服务器发送4096字节数据。
实验操作：
    详见本章节15.6小节。
配置向导文件设置（Net_Config.c）：
    详见本章节15.3小节。
调试文件设置（Net_Debug.c）：
    详见本章节15.4小节。
程序设计：
主函数初始化
    在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. }

复制代码

硬件外设初始化
    硬件外设的初始化是在 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. }

复制代码

三个TCP客户端的实现
    三个TCP客户端实现都是一样的，我们这里仅以客户端1为例进行说明：

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

复制代码

RL-TCPnet功能测试
    这里专门创建了一个app_tcpnet_lib.c文件用于RL-TCPnet功能的测试。

1. #include "bsp.h"      
2. #include <RTL.h>
3. #include <stdio.h>
4. #include <Net_Config.h>
8. /*
9. *********************************************************************************************************
10. *                                      用于本文件的调试
11. *********************************************************************************************************
12. */
13. #if 1
14.      #define printf_debug printf
15. #else
16.      #define printf_debug(...)
17. #endif
20. /*
21. *********************************************************************************************************
22. *                                      外部变量和函数调用
23. *********************************************************************************************************
24. */
25. extern uint8_t socket_tcp1;
26. extern void TcpConnect_Client1(uint8_t *_remip, uint16_t _remport, uint16_t _localport);
28. extern uint8_t socket_tcp2;
29. extern void TcpConnect_Client2(uint8_t *_remip, uint16_t _remport, uint16_t _localport);
31. extern uint8_t socket_tcp3;
32. extern void TcpConnect_Client3(uint8_t *_remip, uint16_t _remport, uint16_t _localport);
35. /*
36. *********************************************************************************************************
37. *                              宏定义，远程服务器的IP和端口
38. *********************************************************************************************************
39. */
40. /* 要访问的远程服务器IP和端口配置，也就是电脑端调试助手设置的IP和端口号 */
41. #define IP1            192
42. #define IP2            168
43. #define IP3            1
44. #define IP4            2
46. #define PORT_NUM         1001
48. /* 这个是本地端口 */
49. #define LocalPort_NUM1    1024
50. #define LocalPort_NUM2    1025
51. #define LocalPort_NUM3    1026
54. /*
55. *********************************************************************************************************
56. *                                         变量
57. *********************************************************************************************************
58. */
59. uint8_t Rem_IP[4] = {IP1,IP2,IP3,IP4};
61. /* TCP状态的返回值 */
62. const char * ReVal_Table[]=
63. {
64.      "0: TCP_STATE_FREE",                                       
65.      "1: TCP_STATE_CLOSED",
66.      "2: TCP_STATE_LISTEN",
67.      "3: TCP_STATE_SYN_REC",
68.      "4: TCP_STATE_SYN_SENT",                                         
69.      "5: TCP_STATE_FINW1",
70.      "6: TCP_STATE_FINW2",
71.      "7: TCP_STATE_CLOSING",
72.      "8: TCP_STATE_LAST_ACK",                                         
73.      "9: TCP_STATE_TWAIT",
74.      "10: TCP_STATE_CONNECT",
75.      "11: 连接还未创建",
76. };
78. /*
79. *********************************************************************************************************
80. *    函 数 名: tcpnet_poll
81. *    功能说明: 使用TCPnet必须要一直调用的函数
82. *    形    参: 无
83. *    返 回 值: 无
84. *********************************************************************************************************
85. */
86. void tcpnet_poll(void)
87. {
88.      if(bsp_CheckTimer(0))
89.      {
90.          bsp_LedToggle(2);
91.         
92.          /* 此函数坚决不可以放在中断里面跑 */
93.          timer_tick ();
94.      }
95.    
96.      main_TcpNet ();
97. }
99. /*
100. *********************************************************************************************************
101. *    函 数 名: TCPnetTest
102. *    功能说明: TCPnet应用
103. *    形    参: 无
104. *    返 回 值: 无
105. *********************************************************************************************************
106. */
107. void TCPnetTest(void)
108. {
109.      int32_t iCount;
110.      uint8_t *sendbuf;
111.      uint16_t maxlen;
112.      uint8_t ucKeyCode;
113.      uint8_t TcpState;
114.    
115.    
116.      /* 初始化网络协议栈 */
117.      init_TcpNet ();
118.    
119.      /* 创建一个周期是100ms的软定时器 */
120.     bsp_StartAutoTimer(0, 100);
122.      while (1)
123.      {
124.           /* TCP轮询 */
125.          tcpnet_poll();
127.           /* 按键消息的处理 */
128.          ucKeyCode = bsp_GetKey();
129.          if (ucKeyCode != KEY_NONE)
130.          {
131.               switch (ucKeyCode)
132.               {
133.                    /* K1键按下，TCP客户端1建立连接 */
134.                    case KEY_DOWN_K1:     
135.                        TcpState = tcp_get_state(socket_tcp1);
136.                   
137.                         /*
138.                           TCP_STATE_CONNECT是最后一个状态，未创建连接的话，会返回数值255，这里就是专门处理
139.                           这种状态，将其设置下一个TCP_STATE_CONNECT+1，即我们这里自定义了一个未创建连接的
140.                           状态。
141.                        */
142.                        if(TcpState > TCP_STATE_CONNECT)
143.                        {
144.                             TcpState = TCP_STATE_CONNECT + 1;
145.                        }
146.                        printf_debug("TCP客户端1状态 = %s\\r\\n", ReVal_Table[TcpState]);
147.                   
148.                        if(TcpState != TCP_STATE_CONNECT)
149.                        {
150.                             TcpConnect_Client1(Rem_IP, PORT_NUM, LocalPort_NUM1);
151.                        }
152.                        break;
153.                      
154.                    /* K2键按下，TCP客户端2建立连接 */
155.                    case KEY_DOWN_K2:     
156.                        TcpState = tcp_get_state(socket_tcp2);
157.                   
158.                         /*
159.                           TCP_STATE_CONNECT是最后一个状态，未创建连接的话，会返回数值255，这里就是专门处理
160.                           这种状态，将其设置下一个TCP_STATE_CONNECT+1，即我们这里自定义了一个未创建连接的
161.                           状态。
162.                        */
163.                        if(TcpState > TCP_STATE_CONNECT)
164.                        {
165.                             TcpState = TCP_STATE_CONNECT + 1;
166.                        }
167.                        printf_debug("TCP客户端2状态 = %s\\r\\n", ReVal_Table[TcpState]);
168.                   
169.                        if(TcpState != TCP_STATE_CONNECT)
170.                        {
171.                             TcpConnect_Client2(Rem_IP, PORT_NUM, LocalPort_NUM2);
172.                        }   
173.                        break;
174.                      
175.                    /* K3键按下，TCP客户端3建立连接 */
176.                    case KEY_DOWN_K3:            
177.                        TcpState = tcp_get_state(socket_tcp3);
178.                   
179.                         /*
180.                           TCP_STATE_CONNECT是最后一个状态，未创建连接的话，会返回数值255，这里就是专门处理
181.                           这种状态，将其设置下一个TCP_STATE_CONNECT+1，即我们这里自定义了一个未创建连接的
182.                           状态。
183.                        */
184.                        if(TcpState > TCP_STATE_CONNECT)
185.                        {
186.                             TcpState = TCP_STATE_CONNECT + 1;
187.                        }
188.                   
189.                        printf_debug("TCP客户端3状态 = %s\\r\\n", ReVal_Table[TcpState]);
190.                   
191.                        if(TcpState != TCP_STATE_CONNECT)
192.                        {
193.                             TcpConnect_Client3(Rem_IP, PORT_NUM, LocalPort_NUM3);
194.                        }   
195.                        break;
196.                      
197.                   
198.                    /* 摇杆上键按下，TCP客户端1向TCP服务器发送4096字节数据 */
199.                    case JOY_DOWN_U:
200.                        TcpState = tcp_get_state(socket_tcp1);
201.                        printf_debug("TCP客户端1状态 = %s\\r\\n", ReVal_Table[TcpState]);                  
202.                        iCount = 4096;
203.                        /* 保证已经建立连接了才可以发送数据 */
204.                        if(TcpState == TCP_STATE_CONNECT)
205.                        {
206.                             do
207.                             {
208.                                  tcpnet_poll();
209.                                  if (tcp_check_send (socket_tcp1) == __TRUE)
210.                                  {
211.                                      maxlen = tcp_max_dsize (socket_tcp1);
212.                                      iCount -= maxlen;
213.                                     
214.                                       if(iCount < 0)
215.                                      {
216.                                           /* 这么计算没问题的 */
217.                                           maxlen = iCount + maxlen;
218.                                      }
219.                                     
220.                                      /* 这里仅初始化了每次所发送数据包的前8个字节 */
221.                                      sendbuf = tcp_get_buf(maxlen);
222.                                      sendbuf[0] = 'a';
223.                                      sendbuf[1] = 'b';
224.                                      sendbuf[2] = 'c';
225.                                      sendbuf[3] = 'd';
226.                                      sendbuf[4] = 'e';
227.                                      sendbuf[5] = 'f';
228.                                      sendbuf[6] = 'g';
229.                                      sendbuf[7] = 'h';
230.                                     
231.                                       /* 测试发现只能使用获取的内存 */
232.                                      tcp_send (socket_tcp1, sendbuf, maxlen);
233.                                  }
234.                                 
235.                             }while(iCount > 0);        
236.                        }      
237.                        break;
238.                      
239.                    /* 摇杆左键按下，TCP客户端2向TCP服务器发送4096字节数据 */
240.                    case JOY_DOWN_L:
241.                        TcpState = tcp_get_state(socket_tcp2);
242.                        printf_debug("TCP客户端2状态 = %s\\r\\n", ReVal_Table[TcpState]);                  
243.                        iCount = 4096;
244.                        /* 保证已经建立连接了才可以发送数据 */
245.                        if(TcpState == TCP_STATE_CONNECT)
246.                        {
247.                             do
248.                             {
249.                                  tcpnet_poll();
250.                                  if (tcp_check_send (socket_tcp2) == __TRUE)
251.                                  {
252.                                      maxlen = tcp_max_dsize (socket_tcp2);
253.                                      iCount -= maxlen;
254.                                     
255.                                      if(iCount < 0)
256.                                      {
257.                                           /* 这么计算没问题的 */
258.                                           maxlen = iCount + maxlen;
259.                                      }
260.                                     
261.                                       /* 这里仅初始化了每次所发送数据包的前8个字节 */
262.                                      sendbuf = tcp_get_buf(maxlen);
263.                                      sendbuf[0] = 'a';
264.                                      sendbuf[1] = 'b';
265.                                      sendbuf[2] = 'c';
266.                                      sendbuf[3] = 'd';
267.                                      sendbuf[4] = 'e';
268.                                      sendbuf[5] = 'f';
269.                                      sendbuf[6] = 'g';
270.                                      sendbuf[7] = 'h';
271.                                     
272.                                      /* 测试发现只能使用获取的内存 */
273.                                      tcp_send (socket_tcp2, sendbuf, maxlen);
274.                                  }
275.                                 
276.                             }while(iCount > 0);        
277.                        }      
278.                        break;
279.                   
280.                    /* 摇杆右键按下，TCP客户端3向TCP服务器发送4096字节数据 */
281.                    case JOY_DOWN_R:
282.                        TcpState = tcp_get_state(socket_tcp3);
283.                        printf_debug("TCP客户端3状态 = %s\\r\\n", ReVal_Table[TcpState]);                  
284.                        iCount = 4096;
285.                        /* 保证已经建立连接了才可以发送数据 */
286.                        if(TcpState == TCP_STATE_CONNECT)
287.                        {
288.                             do
289.                             {
290.                                  tcpnet_poll();
291.                                  if (tcp_check_send (socket_tcp3) == __TRUE)
292.                                  {
293.                                      maxlen = tcp_max_dsize (socket_tcp3);
294.                                      iCount -= maxlen;
295.                                     
296.                                       if(iCount < 0)
297.                                      {
298.                                           /* 这么计算没问题的 */
299.                                           maxlen = iCount + maxlen;
300.                                      }
301.                                     
302.                                       /* 这里仅初始化了每次所发送数据包的前8个字节 */
303.                                      sendbuf = tcp_get_buf(maxlen);
304.                                      sendbuf[0] = 'a';
305.                                      sendbuf[1] = 'b';
306.                                      sendbuf[2] = 'c';
307.                                      sendbuf[3] = 'd';
308.                                      sendbuf[4] = 'e';
309.                                      sendbuf[5] = 'f';
310.                                      sendbuf[6] = 'g';
311.                                      sendbuf[7] = 'h';
312.                                     
313.                                       /* 测试发现只能使用获取的内存 */
314.                                      tcp_send (socket_tcp3, sendbuf, maxlen);
315.                                  }
316.                                 
317.                             }while(iCount > 0);        
318.                        }      
319.                        break;
320.                      
321.                    /* 其他的键值不处理 */
322.                    default:                    
323.                        break;
324.               }
325.          }
326.      }
327. }

复制代码

席萌0209

15.8 实验例程说明（RTX）



15.8.1 STM32F407开发板实验


配套例子：
    V5-1017_RL-TCPnet实验_多个TCP客户端连接（RTX）
实验目的：
    1.     学习RL-TCPnet的多个TCP客户端创建和数据收发。
实验内容：
    1.      强烈推荐将网线接到路由器或者交换机上面测试，因为已经使能了DHCP，可以自动获取IP地址。
    2.      客户端的例子相比服务器的例子稍麻烦些，因为客户端的例子需要用户知道电脑端IP和端口号。并根据实际情况设置IP和端口号的宏定义，这个配置在文件app_tcpnet_lib.c开头，测试的时候板子要连接这个IP和端口（下面是默认配置，一定要根据实际情况重新配置，如果不会配置，看本例程对应的教程即可）：
        #define IP1            192
        #define IP2            168
        #define IP3            1
        #define IP4            2                 
        #define PORT_NUM       1001
    3.      本例程可以创建三个TCP Client，而且使能了局域网域名NetBIOS，用户只需在电脑端ping armfly就可以获得板子的IP地址，三个TCP Client的端口号分别是1024,1025和1026。
    4.      用户可以在电脑端用网络调试软件创建TCP Server跟这三个客户端建立连接。执行下面5--10步的操作时，优先将电脑端的TCP Server建立起来！
    5.      按键K1按下，创建TCP客户端1，并跟电脑端的TCP服务器建立连接。
    6.      按键K2按下，创建TCP客户端2，并跟电脑端的TCP服务器建立连接。
    7.      按键K3按下，创建TCP客户端3，并跟电脑端的TCP服务器建立连接。
    8.      摇杆上键按下，TCP客户端1给电脑端的TCP服务器发送4096字节数据。
    9.      摇杆左键按下，TCP客户端2给电脑端的TCP服务器发送4096字节数据。
    10.   摇杆右键按下，TCP客户端3给电脑端的TCP服务器发送4096字节数据。
实验操作：
    详见本章节15.6小节。
配置向导文件设置（Net_Config.c）：
    详见本章节15.3小节。
调试文件设置（Net_Debug.c）：
    详见本章节15.4小节。
RTX配置：
    RTX配置向导详情如下：

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任务调试信息：

程序设计：
任务栈大小分配：
    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类型数据运算会出问题。
系统栈大小分配：

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. }

复制代码

硬件外设初始化
    硬件外设的初始化是在 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. }

复制代码

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. }

复制代码

五个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;
39.                   
40.                    /* 摇杆上键按下，直接发送事件标志给任务AppTaskTCPMain，设置bit3 */
41.                    case JOY_DOWN_U:
42.                        printf("摇杆上键按下，直接发送事件标志给任务AppTaskTCPMain，设置bit3\\r\\n");
43.                        os_evt_set (JOY_U_BIT3, HandleTaskTCPMain);
44.                        break;
45.                   
46.                    /* 摇杆左键按下，直接发送事件标志给任务AppTaskTCPMain，设置bit4 */
47.                    case JOY_DOWN_L:
48.                        printf("摇杆左键按下，直接发送事件标志给任务AppTaskTCPMain，设置bit4\\r\\n");
49.                        os_evt_set (JOY_L_BIT4, HandleTaskTCPMain);
50.                        break;
51.                   
52.                    /* 摇杆右键按下，直接发送事件标志给任务AppTaskTCPMain，设置bit5 */
53.                    case JOY_DOWN_R:
54.                        printf("摇杆右键按下，直接发送事件标志给任务AppTaskTCPMain，设置bit5\\r\\n");
55.                        os_evt_set (JOY_R_BIT5, HandleTaskTCPMain);
56.                        break;
58.                    /* 其他的键值不处理 */
59.                    default:                    
60.                        break;
61.               }
62.          }
63.         
64.          os_dly_wait(20);
65.      }
66. }
68. /*
69. *********************************************************************************************************
70. *    函 数 名: AppTaskLED
71. *    功能说明: LED闪烁。
72. *    形    参: 无
73. *    返 回 值: 无
74. *   优 先 级: 2
75. *********************************************************************************************************
76. */
77. __task void AppTaskLED(void)
78. {
79.      const uint16_t usFrequency = 500; /* 延迟周期 */
80.    
81.      /* 设置延迟周期 */
82.      os_itv_set(usFrequency);
83.    
84.     while(1)
85.     {
86.          bsp_LedToggle(2);
88.          /* os_itv_wait是绝对延迟，os_dly_wait是相对延迟。*/
89.          os_itv_wait();
90.     }
91. }
93. /*
94. *********************************************************************************************************
95. *    函 数 名: AppTaskMsgPro
96. *    功能说明: 按键检测
97. *    形    参: 无
98. *    返 回 值: 无
99. *   优 先 级: 3
100. *********************************************************************************************************
101. */
102. __task void AppTaskMsgPro(void)
103. {
104.     while(1)
105.     {
106.          bsp_KeyScan();
107.          os_dly_wait(10);
108.     }
109. }
111. /*
112. *********************************************************************************************************
113. *    函 数 名: AppTaskTCPMain
114. *    功能说明: RL-TCPnet测试任务
115. *    形    参: 无
116. *    返 回 值: 无
117. *   优 先 级: 4
118. *********************************************************************************************************
119. */
120. __task void AppTaskTCPMain(void)
121. {
122.      while (1)
123.      {
124.          TCPnetTest();
125.      }
126. }
128. /*
129. *********************************************************************************************************
130. *    函 数 名: AppTaskStart
131. *    功能说明: 启动任务，也是最高优先级任务，这里实现RL-TCPnet的时间基准更新。
132. *    形    参: 无
133. *    返 回 值: 无
134. *   优 先 级: 5
135. *********************************************************************************************************
136. */
137. __task void AppTaskStart(void)
138. {
139.      /* 初始化RL-TCPnet */
140.      init_TcpNet ();
141.    
142.      /* 创建任务 */
143.      AppTaskCreate();
144.    
145.      os_itv_set (100);
146.    
147.     while(1)
148.     {
149.          os_itv_wait ();
150.         
151.          /* RL-TCPnet时间基准更新函数 */
152.          timer_tick ();
153.     }
154. }

复制代码

三个TCP客户端的实现
    三个TCP客户端实现都是一样的，我们这里仅以客户端1为例进行说明：

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

复制代码

RL-TCPnet功能测试
    这里专门创建了一个app_tcpnet_lib.c文件用于RL-TCPnet功能的测试。

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. extern uint8_t socket_tcp1;
23. extern void TcpConnect_Client1(uint8_t *_remip, uint16_t _remport, uint16_t _localport);
25. extern uint8_t socket_tcp2;
26. extern void TcpConnect_Client2(uint8_t *_remip, uint16_t _remport, uint16_t _localport);
28. extern uint8_t socket_tcp3;
29. extern void TcpConnect_Client3(uint8_t *_remip, uint16_t _remport, uint16_t _localport);
32. /*
33. *********************************************************************************************************
34. *                              宏定义，远程服务器的IP和端口
35. *********************************************************************************************************
36. */
37. /* 要访问的远程服务器IP和端口配置，也就是电脑端调试助手设置的IP和端口号 */
38. #define IP1            192
39. #define IP2            168
40. #define IP3            1
41. #define IP4            2
43. #define PORT_NUM         1001
45. /* 这个是本地端口 */
46. #define LocalPort_NUM1    1024
47. #define LocalPort_NUM2    1025
48. #define LocalPort_NUM3    1026
51. /*
52. *********************************************************************************************************
53. *                                         变量
54. *********************************************************************************************************
55. */
56. uint8_t Rem_IP[4] = {IP1,IP2,IP3,IP4};
58. /* TCP状态的返回值 */
59. const char * ReVal_Table[]=
60. {
61.      "0: TCP_STATE_FREE",                                       
62.      "1: TCP_STATE_CLOSED",
63.      "2: TCP_STATE_LISTEN",
64.      "3: TCP_STATE_SYN_REC",
65.      "4: TCP_STATE_SYN_SENT",                                         
66.      "5: TCP_STATE_FINW1",
67.      "6: TCP_STATE_FINW2",
68.      "7: TCP_STATE_CLOSING",
69.      "8: TCP_STATE_LAST_ACK",                                         
70.      "9: TCP_STATE_TWAIT",
71.      "10: TCP_STATE_CONNECT",
72.      "11: 连接还未创建",
73. };
75. /*
76. *********************************************************************************************************
77. *    函 数 名: TCPnetTest
78. *    功能说明: TCPnet应用
79. *    形    参: 无
80. *    返 回 值: 无
81. *********************************************************************************************************
82. */
83. void TCPnetTest(void)
84. {
85.      int32_t iCount;
86.      uint8_t *sendbuf;
87.      uint16_t maxlen;
88.      uint8_t TcpState;
89.      OS_RESULT xResult;
90.      const uint16_t usMaxBlockTime = 2; /* 延迟周期 */
92.    
93.      while (1)
94.      {
95.          /* RL-TCPnet处理函数 */
96.          main_TcpNet();
97.    
98.           /* 按键消息的处理 */
99.          if(os_evt_wait_or(0xFFFF, usMaxBlockTime) == OS_R_EVT)
100.          {
101.               xResult = os_evt_get ();
102.               switch (xResult)
103.               {
104.                    /* 接收到K1键按下，TCP客户端1建立连接 */
105.                    case KEY1_BIT0:              
106.                        TcpState = tcp_get_state(socket_tcp1);
107.                   
108.                        /*
109.                           TCP_STATE_CONNECT是最后一个状态，未创建连接的话，会返回数值255，这里就是专门处理
110.                           这种状态，将其设置下一个TCP_STATE_CONNECT+1，即我们这里自定义了一个未创建连接的
111.                           状态。
112.                        */
113.                        if(TcpState > TCP_STATE_CONNECT)
114.                        {
115.                             TcpState = TCP_STATE_CONNECT + 1;
116.                        }
117.                        printf_debug("TCP客户端1状态 = %s\\r\\n", ReVal_Table[TcpState]);
118.                   
119.                        if(TcpState != TCP_STATE_CONNECT)
120.                        {
121.                             TcpConnect_Client1(Rem_IP, PORT_NUM, LocalPort_NUM1);
122.                        }
123.                        break;
125.                    /* 接收到K2键按下，TCP客户端2建立连接 */
126.                    case KEY2_BIT1:      
127.                        TcpState = tcp_get_state(socket_tcp2);
128.                   
129.                         /*
130.                           TCP_STATE_CONNECT是最后一个状态，未创建连接的话，会返回数值255，这里就是专门处理
131.                           这种状态，将其设置下一个TCP_STATE_CONNECT+1，即我们这里自定义了一个未创建连接的
132.                           状态。
133.                        */
134.                        if(TcpState > TCP_STATE_CONNECT)
135.                        {
136.                             TcpState = TCP_STATE_CONNECT + 1;
137.                        }
138.                        printf_debug("TCP客户端2状态 = %s\\r\\n", ReVal_Table[TcpState]);
139.                   
140.                        if(TcpState != TCP_STATE_CONNECT)
141.                        {
142.                             TcpConnect_Client2(Rem_IP, PORT_NUM, LocalPort_NUM2);
143.                        }   
144.                        break;
145.                      
146.                    /* 接收到K3键按下，TCP客户端3建立连接 */
147.                    case KEY3_BIT2:              
148.                        TcpState = tcp_get_state(socket_tcp3);
149.                   
150.                        /*
151.                           TCP_STATE_CONNECT是最后一个状态，未创建连接的话，会返回数值255，这里就是专门处理
152.                           这种状态，将其设置下一个TCP_STATE_CONNECT+1，即我们这里自定义了一个未创建连接的
153.                           状态。
154.                        */
155.                        if(TcpState > TCP_STATE_CONNECT)
156.                        {
157.                             TcpState = TCP_STATE_CONNECT + 1;
158.                        }
159.                   
160.                        printf_debug("TCP客户端3状态 = %s\\r\\n", ReVal_Table[TcpState]);
161.                   
162.                        if(TcpState != TCP_STATE_CONNECT)
163.                        {
164.                             TcpConnect_Client3(Rem_IP, PORT_NUM, LocalPort_NUM3);
165.                        }   
166.                        break;
167.                   
168.                   
169.                    /* 接收到摇杆上键按下，TCP客户端1向TCP服务器发送4096字节数据 */
170.                    case JOY_U_BIT3:            
171.                        TcpState = tcp_get_state(socket_tcp1);
172.                        printf_debug("TCP客户端1状态 = %s\\r\\n", ReVal_Table[TcpState]);                  
173.                        iCount = 4096;
174.                        /* 保证已经建立连接了才可以发送数据 */
175.                        if(TcpState == TCP_STATE_CONNECT)
176.                        {
177.                             do
178.                             {
179.                                  main_TcpNet();
180.                                  if (tcp_check_send (socket_tcp1) == __TRUE)
181.                                  {
182.                                      maxlen = tcp_max_dsize (socket_tcp1);
183.                                      iCount -= maxlen;
184.                                     
185.                                      if(iCount < 0)
186.                                      {
187.                                           /* 这么计算没问题的 */
188.                                           maxlen = iCount + maxlen;
189.                                      }
190.                                     
191.                                       /* 这里仅初始化了每次所发送数据包的前8个字节 */
192.                                      sendbuf = tcp_get_buf(maxlen);
193.                                      sendbuf[0] = 'a';
194.                                      sendbuf[1] = 'b';
195.                                      sendbuf[2] = 'c';
196.                                      sendbuf[3] = 'd';
197.                                      sendbuf[4] = 'e';
198.                                      sendbuf[5] = 'f';
199.                                      sendbuf[6] = 'g';
200.                                      sendbuf[7] = 'h';
201.                                     
202.                                      /* 测试发现只能使用获取的内存 */
203.                                      tcp_send (socket_tcp1, sendbuf, maxlen);
204.                                  }
205.                                 
206.                             }while(iCount > 0);        
207.                        }      
208.                        break;
209.                   
210.                    /* 接收到摇杆左键按下，TCP客户端2向TCP服务器发送4096字节数据 */
211.                    case JOY_L_BIT4:            
212.                        TcpState = tcp_get_state(socket_tcp2);
213.                        printf_debug("TCP客户端2状态 = %s\\r\\n", ReVal_Table[TcpState]);                  
214.                        iCount = 4096;
215.                        /* 保证已经建立连接了才可以发送数据 */
216.                        if(TcpState == TCP_STATE_CONNECT)
217.                        {
218.                             do
219.                             {
220.                                  main_TcpNet();
221.                                  if (tcp_check_send (socket_tcp2) == __TRUE)
222.                                  {
223.                                      maxlen = tcp_max_dsize (socket_tcp2);
224.                                      iCount -= maxlen;
225.                                     
226.                                      if(iCount < 0)
227.                                      {
228.                                           /* 这么计算没问题的 */
229.                                           maxlen = iCount + maxlen;
230.                                      }
231.                                     
232.                                       /* 这里仅初始化了每次所发送数据包的前8个字节 */
233.                                      sendbuf = tcp_get_buf(maxlen);
234.                                      sendbuf[0] = 'a';
235.                                      sendbuf[1] = 'b';
236.                                      sendbuf[2] = 'c';
237.                                      sendbuf[3] = 'd';
238.                                      sendbuf[4] = 'e';
239.                                      sendbuf[5] = 'f';
240.                                      sendbuf[6] = 'g';
241.                                      sendbuf[7] = 'h';
242.                                     
243.                                      /* 测试发现只能使用获取的内存 */
244.                                      tcp_send (socket_tcp2, sendbuf, maxlen);
245.                                  }
246.                                 
247.                             }while(iCount > 0);        
248.                        }      
249.                        break;
250.                   
251.                    /* 接收到摇杆右键按下，TCP客户端3向TCP服务器发送4096字节数据 */
252.                    case JOY_R_BIT5:            
253.                        TcpState = tcp_get_state(socket_tcp3);
254.                        printf_debug("TCP客户端3状态 = %s\\r\\n", ReVal_Table[TcpState]);                  
255.                        iCount = 4096;
256.                        /* 保证已经建立连接了才可以发送数据 */
257.                        if(TcpState == TCP_STATE_CONNECT)
258.                        {
259.                             do
260.                             {
261.                                  main_TcpNet();
262.                                  if (tcp_check_send (socket_tcp3) == __TRUE)
263.                                  {
264.                                      maxlen = tcp_max_dsize (socket_tcp3);
265.                                      iCount -= maxlen;
266.                                     
267.                                      if(iCount < 0)
268.                                      {
269.                                           /* 这么计算没问题的 */
270.                                           maxlen = iCount + maxlen;
271.                                      }
272.                                     
273.                                       /* 这里仅初始化了每次所发送数据包的前8个字节 */
274.                                      sendbuf = tcp_get_buf(maxlen);
275.                                      sendbuf[0] = 'a';
276.                                      sendbuf[1] = 'b';
277.                                      sendbuf[2] = 'c';
278.                                      sendbuf[3] = 'd';
279.                                      sendbuf[4] = 'e';
280.                                      sendbuf[5] = 'f';
281.                                      sendbuf[6] = 'g';
282.                                      sendbuf[7] = 'h';
283.                                     
284.                                       /* 测试发现只能使用获取的内存 */
285.                                      tcp_send (socket_tcp3, sendbuf, maxlen);
286.                                  }
287.                                 
288.                             }while(iCount > 0);        
289.                        }      
290.                        break;
291.                   
292.                    /* 其他的键值不处理 */
293.                    default:                    
294.                        break;
295.               }
296.          }
297.      }
298. }

复制代码

席萌0209

15.8.2 STM32F429开发板实验


配套例子：
    V6-1017_RL-TCPnet实验_多个TCP客户端连接（RTX）
实验目的：
    1.     学习RL-TCPnet的多个TCP客户端创建和数据收发。
实验内容：
    1.      强烈推荐将网线接到路由器或者交换机上面测试，因为已经使能了DHCP，可以自动获取IP地址。
    2.      客户端的例子相比服务器的例子稍麻烦些，因为客户端的例子需要用户知道电脑端IP和端口号。并根据实际情况设置IP和端口号的宏定义，这个配置在文件app_tcpnet_lib.c开头，测试的时候板子要连接这个IP和端口（下面是默认配置，一定要根据实际情况重新配置，如果不会配置，看本例程对应的教程即可）：
        #define IP1            192
        #define IP2            168
        #define IP3            1
        #define IP4            2               
        #define PORT_NUM       1001
    3.      本例程可以创建三个TCP Client，而且使能了局域网域名NetBIOS，用户只需在电脑端ping armfly就可以获得板子的IP地址，三个TCP Client的端口号分别是1024,1025和1026。
    4.      用户可以在电脑端用网络调试软件创建TCP Server跟这三个客户端建立连接。执行下面5--10步的操作时，优先将电脑端的TCP Server建立起来！
    5.      按键K1按下，创建TCP客户端1，并跟电脑端的TCP服务器建立连接。
    6.      按键K2按下，创建TCP客户端2，并跟电脑端的TCP服务器建立连接。
    7.      按键K3按下，创建TCP客户端3，并跟电脑端的TCP服务器建立连接。
    8.      摇杆上键按下，TCP客户端1给电脑端的TCP服务器发送4096字节数据。
    9.      摇杆左键按下，TCP客户端2给电脑端的TCP服务器发送4096字节数据。
    10.   摇杆右键按下，TCP客户端3给电脑端的TCP服务器发送4096字节数据。
实验操作：
    详见本章节15.6小节。
配置向导文件设置（Net_Config.c）：
    详见本章节15.3小节。
调试文件设置（Net_Debug.c）：
    详见本章节15.4小节。        
RTX配置：
    RTX配置向导详情如下：

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任务调试信息：

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

RTX初始化：

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

复制代码

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

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

复制代码

RTX任务创建：

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

复制代码

五个RTX任务的实现：

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

复制代码

三个TCP客户端的实现
    三个TCP客户端实现都是一样的，我们这里仅以客户端1为例进行说明：

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

复制代码

RL-TCPnet功能测试
    这里专门创建了一个app_tcpnet_lib.c文件用于RL-TCPnet功能的测试。

1. [size=3]#include "includes.h"[/size]
5. [size=3]/*[/size]
6. [size=3]*********************************************************************************************************[/size]
7. [size=3]* 用于本文件的调试[/size]
8. [size=3]*********************************************************************************************************[/size]
9. [size=3]*/[/size]
10. [size=3]#if 1[/size]
11. [size=3]#define printf_debug printf[/size]
12. [size=3]#else[/size]
13. [size=3]#define printf_debug(...)[/size]
14. [size=3]#endif[/size]
17. [size=3]/*[/size]
18. [size=3]*********************************************************************************************************[/size]
19. [size=3]* 外部变量和函数调用[/size]
20. [size=3]*********************************************************************************************************[/size]
21. [size=3]*/[/size]
22. [size=3]extern uint8_t socket_tcp1;[/size]
23. [size=3]extern void TcpConnect_Client1(uint8_t *_remip, uint16_t _remport, uint16_t _localport);[/size]
25. [size=3]extern uint8_t socket_tcp2;[/size]
26. [size=3]extern void TcpConnect_Client2(uint8_t *_remip, uint16_t _remport, uint16_t _localport);[/size]
28. [size=3]extern uint8_t socket_tcp3;[/size]
29. [size=3]extern void TcpConnect_Client3(uint8_t *_remip, uint16_t _remport, uint16_t _localport);[/size]
32. [size=3]/*[/size]
33. [size=3]*********************************************************************************************************[/size]
34. [size=3]* 宏定义，远程服务器的IP和端口[/size]
35. [size=3]*********************************************************************************************************[/size]
36. [size=3]*/[/size]
37. [size=3]/* 要访问的远程服务器IP和端口配置，也就是电脑端调试助手设置的IP和端口号 */[/size]
38. [size=3]#define IP1 192[/size]
39. [size=3]#define IP2 168[/size]
40. [size=3]#define IP3 1[/size]
41. [size=3]#define IP4 2[/size]
43. [size=3]#define PORT_NUM 1001[/size]
45. [size=3]/* 这个是本地端口 */[/size]
46. [size=3]#define LocalPort_NUM1 1024[/size]
47. [size=3]#define LocalPort_NUM2 1025[/size]
48. [size=3]#define LocalPort_NUM3 1026[/size]
51. [size=3]/*[/size]
52. [size=3]*********************************************************************************************************[/size]
53. [size=3]* 变量[/size]
54. [size=3]*********************************************************************************************************[/size]
55. [size=3]*/[/size]
56. [size=3]uint8_t Rem_IP[4] = {IP1,IP2,IP3,IP4};[/size]
58. [size=3]/* TCP状态的返回值 */[/size]
59. [size=3]const char * ReVal_Table[]=[/size]
60. [size=3]{[/size]
61. [size=3]"0: TCP_STATE_FREE",[/size]
62. [size=3]"1: TCP_STATE_CLOSED",[/size]
63. [size=3]"2: TCP_STATE_LISTEN",[/size]
64. [size=3]"3: TCP_STATE_SYN_REC",[/size]
65. [size=3]"4: TCP_STATE_SYN_SENT",[/size]
66. [size=3]"5: TCP_STATE_FINW1",[/size]
67. [size=3]"6: TCP_STATE_FINW2",[/size]
68. [size=3]"7: TCP_STATE_CLOSING",[/size]
69. [size=3]"8: TCP_STATE_LAST_ACK",[/size]
70. [size=3]"9: TCP_STATE_TWAIT",[/size]
71. [size=3]"10: TCP_STATE_CONNECT",[/size]
72. [size=3]"11: 连接还未创建",[/size]
73. [size=3]};[/size]
75. [size=3]/*[/size]
76. [size=3]*********************************************************************************************************[/size]
77. [size=3]* 函 数 名: TCPnetTest[/size]
78. [size=3]* 功能说明: TCPnet应用[/size]
79. [size=3]* 形 参: 无[/size]
80. [size=3]* 返 回 值: 无[/size]
81. [size=3]*********************************************************************************************************[/size]
82. [size=3]*/[/size]
83. [size=3]void TCPnetTest(void)[/size]
84. [size=3]{[/size]
85. [size=3]int32_t iCount;[/size]
86. [size=3]uint8_t *sendbuf;[/size]
87. [size=3]uint16_t maxlen;[/size]
88. [size=3]uint8_t TcpState;[/size]
89. [size=3]OS_RESULT xResult;[/size]
90. [size=3]const uint16_t usMaxBlockTime = 2; /* 延迟周期 */[/size]
93. [size=3]while (1)[/size]
94. [size=3]{[/size]
95. [size=3]/* RL-TCPnet处理函数 */[/size]
96. [size=3]main_TcpNet();[/size]
98. [size=3]/* 按键消息的处理 */[/size]
99. [size=3]if(os_evt_wait_or(0xFFFF, usMaxBlockTime) == OS_R_EVT)[/size]
100. [size=3]{[/size]
101. [size=3]xResult = os_evt_get ();[/size]
102. [size=3]switch (xResult)[/size]
103. [size=3]{[/size]
104. [size=3]/* 接收到K1键按下，TCP客户端1建立连接 */[/size]
105. [size=3]case KEY1_BIT0:[/size]
106. [size=3]TcpState = tcp_get_state(socket_tcp1);[/size]
108. [size=3]/*[/size]
109. [size=3]TCP_STATE_CONNECT是最后一个状态，未创建连接的话，会返回数值255，这里就是专门处理[/size]
110. [size=3]这种状态，将其设置下一个TCP_STATE_CONNECT+1，即我们这里自定义了一个未创建连接的[/size]
111. [size=3]状态。[/size]
112. [size=3]*/[/size]
113. [size=3]if(TcpState > TCP_STATE_CONNECT)[/size]
114. [size=3]{[/size]
115. [size=3]TcpState = TCP_STATE_CONNECT + 1;[/size]
116. [size=3]}[/size]
117. [size=3]printf_debug("TCP客户端1状态 = %s\\r\\n", ReVal_Table[TcpState]);[/size]
119. [size=3]if(TcpState != TCP_STATE_CONNECT)[/size]
120. [size=3]{[/size]
121. [size=3]TcpConnect_Client1(Rem_IP, PORT_NUM, LocalPort_NUM1);[/size]
122. [size=3]}[/size]
123. [size=3]break;[/size]
125. [size=3]/* 接收到K2键按下，TCP客户端2建立连接 */[/size]
126. [size=3]case KEY2_BIT1:[/size]
127. [size=3]TcpState = tcp_get_state(socket_tcp2);[/size]
129. [size=3]/*[/size]
130. [size=3]TCP_STATE_CONNECT是最后一个状态，未创建连接的话，会返回数值255，这里就是专门处理[/size]
131. [size=3]这种状态，将其设置下一个TCP_STATE_CONNECT+1，即我们这里自定义了一个未创建连接的[/size]
132. [size=3]状态。[/size]
133. [size=3]*/[/size]
134. [size=3]if(TcpState > TCP_STATE_CONNECT)[/size]
135. [size=3]{[/size]
136. [size=3]TcpState = TCP_STATE_CONNECT + 1;[/size]
137. [size=3]}[/size]
138. [size=3]printf_debug("TCP客户端2状态 = %s\\r\\n", ReVal_Table[TcpState]);[/size]
140. [size=3]if(TcpState != TCP_STATE_CONNECT)[/size]
141. [size=3]{[/size]
142. [size=3]TcpConnect_Client2(Rem_IP, PORT_NUM, LocalPort_NUM2);[/size]
143. [size=3]}[/size]
144. [size=3]break;[/size]
146. [size=3]/* 接收到K3键按下，TCP客户端3建立连接 */[/size]
147. [size=3]case KEY3_BIT2:[/size]
148. [size=3]TcpState = tcp_get_state(socket_tcp3);[/size]
150. [size=3]/*[/size]
151. [size=3]TCP_STATE_CONNECT是最后一个状态，未创建连接的话，会返回数值255，这里就是专门处理[/size]
152. [size=3]这种状态，将其设置下一个TCP_STATE_CONNECT+1，即我们这里自定义了一个未创建连接的[/size]
153. [size=3]状态。[/size]
154. [size=3]*/[/size]
155. [size=3]if(TcpState > TCP_STATE_CONNECT)[/size]
156. [size=3]{[/size]
157. [size=3]TcpState = TCP_STATE_CONNECT + 1;[/size]
158. [size=3]}[/size]
160. [size=3]printf_debug("TCP客户端3状态 = %s\\r\\n", ReVal_Table[TcpState]);[/size]
162. [size=3]if(TcpState != TCP_STATE_CONNECT)[/size]
163. [size=3]{[/size]
164. [size=3]TcpConnect_Client3(Rem_IP, PORT_NUM, LocalPort_NUM3);[/size]
165. [size=3]}[/size]
166. [size=3]break;[/size]
169. [size=3]/* 接收到摇杆上键按下，TCP客户端1向TCP服务器发送4096字节数据 */[/size]
170. [size=3]case JOY_U_BIT3:[/size]
171. [size=3]TcpState = tcp_get_state(socket_tcp1);[/size]
172. [size=3]printf_debug("TCP客户端1状态 = %s\\r\\n", ReVal_Table[TcpState]);[/size]
173. [size=3]iCount = 4096;[/size]
174. [size=3]/* 保证已经建立连接了才可以发送数据 */[/size]
175. [size=3]if(TcpState == TCP_STATE_CONNECT)[/size]
176. [size=3]{[/size]
177. [size=3]do[/size]
178. [size=3]{[/size]
179. [size=3]main_TcpNet();[/size]
180. [size=3]if (tcp_check_send (socket_tcp1) == __TRUE)[/size]
181. [size=3]{[/size]
182. [size=3]maxlen = tcp_max_dsize (socket_tcp1);[/size]
183. [size=3]iCount -= maxlen;[/size]
185. [size=3]if(iCount < 0)[/size]
186. [size=3]{[/size]
187. [size=3]/* 这么计算没问题的 */[/size]
188. [size=3]maxlen = iCount + maxlen;[/size]
189. [size=3]}[/size]
191. [size=3]/* 这里仅初始化了每次所发送数据包的前8个字节 */[/size]
192. [size=3]sendbuf = tcp_get_buf(maxlen);[/size]
193. [size=3]sendbuf[0] = 'a';[/size]
194. [size=3]sendbuf[1] = 'b';[/size]
195. [size=3]sendbuf[2] = 'c';[/size]
196. [size=3]sendbuf[3] = 'd';[/size]
197. [size=3]sendbuf[4] = 'e';[/size]
198. [size=3]sendbuf[5] = 'f';[/size]
199. [size=3]sendbuf[6] = 'g';[/size]
200. [size=3]sendbuf[7] = 'h';[/size]
202. [size=3]/* 测试发现只能使用获取的内存 */[/size]
203. [size=3]tcp_send (socket_tcp1, sendbuf, maxlen);[/size]
204. [size=3]}[/size]
206. [size=3]}while(iCount > 0);[/size]
207. [size=3]}[/size]
208. [size=3]break;[/size]
210. [size=3]/* 接收到摇杆左键按下，TCP客户端2向TCP服务器发送4096字节数据 */[/size]
211. [size=3]case JOY_L_BIT4:[/size]
212. [size=3]TcpState = tcp_get_state(socket_tcp2);[/size]
213. [size=3]printf_debug("TCP客户端2状态 = %s\\r\\n", ReVal_Table[TcpState]);[/size]
214. [size=3]iCount = 4096;[/size]
215. [size=3]/* 保证已经建立连接了才可以发送数据 */[/size]
216. [size=3]if(TcpState == TCP_STATE_CONNECT)[/size]
217. [size=3]{[/size]
218. [size=3]do[/size]
219. [size=3]{[/size]
220. [size=3]main_TcpNet();[/size]
221. [size=3]if (tcp_check_send (socket_tcp2) == __TRUE)[/size]
222. [size=3]{[/size]
223. [size=3]maxlen = tcp_max_dsize (socket_tcp2);[/size]
224. [size=3]iCount -= maxlen;[/size]
226. [size=3]if(iCount < 0)[/size]
227. [size=3]{[/size]
228. [size=3]/* 这么计算没问题的 */[/size]
229. [size=3]maxlen = iCount + maxlen;[/size]
230. [size=3]}[/size]
232. [size=3]/* 这里仅初始化了每次所发送数据包的前8个字节 */[/size]
233. [size=3]sendbuf = tcp_get_buf(maxlen);[/size]
234. [size=3]sendbuf[0] = 'a';[/size]
235. [size=3]sendbuf[1] = 'b';[/size]
236. [size=3]sendbuf[2] = 'c';[/size]
237. [size=3]sendbuf[3] = 'd';[/size]
238. [size=3]sendbuf[4] = 'e';[/size]
239. [size=3]sendbuf[5] = 'f';[/size]
240. [size=3]sendbuf[6] = 'g';[/size]
241. [size=3]sendbuf[7] = 'h';[/size]
243. [size=3]/* 测试发现只能使用获取的内存 */[/size]
244. [size=3]tcp_send (socket_tcp2, sendbuf, maxlen);[/size]
245. [size=3]}[/size]
247. [size=3]}while(iCount > 0);[/size]
248. [size=3]}[/size]
249. [size=3]break;[/size]
251. [size=3]/* 接收到摇杆右键按下，TCP客户端3向TCP服务器发送4096字节数据 */[/size]
252. [size=3]case JOY_R_BIT5:[/size]
253. [size=3]TcpState = tcp_get_state(socket_tcp3);[/size]
254. [size=3]printf_debug("TCP客户端3状态 = %s\\r\\n", ReVal_Table[TcpState]);[/size]
255. [size=3]iCount = 4096;[/size]
256. [size=3]/* 保证已经建立连接了才可以发送数据 */[/size]
257. [size=3]if(TcpState == TCP_STATE_CONNECT)[/size]
258. [size=3]{[/size]
259. [size=3]do[/size]
260. [size=3]{[/size]
261. [size=3]main_TcpNet();[/size]
262. [size=3]if (tcp_check_send (socket_tcp3) == __TRUE)[/size]
263. [size=3]{[/size]
264. [size=3]maxlen = tcp_max_dsize (socket_tcp3);[/size]
265. [size=3]iCount -= maxlen;[/size]
267. [size=3]if(iCount < 0)[/size]
268. [size=3]{[/size]
269. [size=3]/* 这么计算没问题的 */[/size]
270. [size=3]maxlen = iCount + maxlen;[/size]
271. [size=3]}[/size]
273. [size=3]/* 这里仅初始化了每次所发送数据包的前8个字节 */[/size]
274. [size=3]sendbuf = tcp_get_buf(maxlen);[/size]
275. [size=3]sendbuf[0] = 'a';[/size]
276. [size=3]sendbuf[1] = 'b';[/size]
277. [size=3]sendbuf[2] = 'c';[/size]
278. [size=3]sendbuf[3] = 'd';[/size]
279. [size=3]sendbuf[4] = 'e';[/size]
280. [size=3]sendbuf[5] = 'f';[/size]
281. [size=3]sendbuf[6] = 'g';[/size]
282. [size=3]sendbuf[7] = 'h';[/size]
284. [size=3]/* 测试发现只能使用获取的内存 */[/size]
285. [size=3]tcp_send (socket_tcp3, sendbuf, maxlen);[/size]
286. [size=3]}[/size]
288. [size=3]}while(iCount > 0);[/size]
289. [size=3]}[/size]
290. [size=3]break;[/size]
292. [size=3]/* 其他的键值不处理 */[/size]
293. [size=3]default:[/size]
294. [size=3]break;[/size]
295. [size=3]}[/size]
296. [size=3]}[/size]
297. [size=3]}[/size]
298. [size=3]}[/size]

复制代码