lwip tcp同一端口支持多个连接

最新推荐文章于 2025-07-26 10:14:31 发布
原创 最新推荐文章于 2025-07-26 10:14:31 发布 · 607 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#tcp/ip #单片机 #网络协议

lwip对于同一端口支持多个连接，只需在上位机进行连接时，即accept 能连接到即可，直接上代码：

#ifndef _SOCKET_APP_H
#define _SOCKET_APP_H


#include "global_includes.h"


#define INVALID_SOCKET -1


void socket_app_init(void);
void socket_app_pool(void);
bool socket_upload_txdata(uint8* buf, uint16 len);


#endif

#include "socket_app.h"
#include "sys_info.h"
#include "user_info.h"
#include "sys_timer.h"
#include "rtx_data_analy.h"
#include "hmi_app_pool.h"
#include "lwip/sockets.h"

#if UDP_MULTSERVER
#include "mult_app.h"
#endif

static struct sys_data_info* net_sys_info = NULL;

#define TCP_SPLICE_ENABLE  0

#define TCP_MAX_CONNECTION        2  // 2  UDP_MULTSERVER
#define TCP_UNVALID_FD            -1

#define NET_TXBUF_SIZE         1500
#define NET_RXBUF_SIZE         1500


uint8 net_rxbuf[NET_RXBUF_SIZE];
uint8 net_txbuf[NET_TXBUF_SIZE];

struct sockaddr_in  tcp_local_addr;
struct sockaddr_in  local_addr;
struct sockaddr_in remote_addr_temp;

enum
{
  TCP_STATE_IDLE = 0,
  TCP_STATE_HEAD,
  TCP_STATE_DATA,
  TCP_STATE_ANALYDATA,
};

#define NET_TCP_RXBUFSIZE 1500
#define NET_TCP_TXBUFSIZE 1500
#define NET_TCP_HEADLEN   4
uint8 net_tcp_rxbuf[NET_TCP_RXBUFSIZE];
uint16 net_tcp_lenoffset;
uint16 net_tcp_rxitem = 0;
uint16 net_tcp_packetlen = 0;
uint8  net_tcp_state  = 0;

#define TCP_CLOSE(len,tcp_sockfd)            {if(len<=0){close(tcp_sockfd);tcp_sockfd = TCP_UNVALID_FD;net_sys_info->debug_view_info->tcpupenable = false;}}

#if UDP_MULTSERVER
static int32 udp_multsockfd[UDP_MULTSERVER];

/****************************************************************************************
*函数名称: net_udpmult_init
*
*函数说明: 多UDP端口初始化
****************************************************************************************/
void net_udpmult_init(void)
{
  uint8 i;

  uint8  optval = 1;

  for(i = 0; i < UDP_MULTSERVER; i++)
  {
    udp_multsockfd[i]    =   -1;
    while(1)
    {
      rt_thread_delay(RT_TICK_PER_SECOND / 20);
      memset(&local_addr, 0, sizeof(struct sockaddr_in));

      local_addr.sin_family       = AF_INET;
      local_addr.sin_port         = htons(NET_PORT + i);//本地端口

      local_addr.sin_addr.s_addr  = INADDR_ANY;
      udp_multsockfd[i]                = socket(AF_INET, SOCK_DGRAM, 0);
      if(udp_multsockfd[i] <= 0)
      {
        continue;
      }
      setsockopt(udp_multsockfd[i], SOL_SOCKET, SO_BROADCAST, (void*)&optval, sizeof(optval));

      if(bind(udp_multsockfd[i], (struct sockaddr*)&local_addr, sizeof(local_addr)) < 0)
      {
        continue;
      }
      break;
    }
  }
}

void net_udpmult_pool(void)
{
  uint8 i;
  uint32 len = 0;;
  int rxlen  = 0;
  int txlen  = 0;
  int16 ret;
  fd_set readset;
  fd_set writeset;
  struct timeval tv;

  len = sizeof(struct sockaddr_in);

  for(i = 0; i < UDP_MULTSERVER; i++)
  {
    tv.tv_sec = 0;
    tv.tv_usec = 0;
    FD_ZERO(&readset);
    FD_ZERO(&writeset);

    FD_SET(udp_multsockfd[i], &readset);
    FD_SET(udp_multsockfd[i], &writeset);

    ret = select(udp_multsockfd[i] + 1, &readset, 0, 0, &tv);
    if(ret > 0)  //说明有就绪的文件描述符
    {
      if(FD_ISSET(udp_multsockfd[i], &readset))  //判断是否为读取的文件描述符集
      {
        rxlen = recvfrom(udp_multsockfd[i], net_rxbuf, NET_RXBUF_SIZE, 0, (struct sockaddr*)&remote_addr_temp, (socklen_t*)&len);  //接收数据

        if(rxlen)
        {
          if(lwip_recvbroad() !=  0)
          {
            remote_addr_temp.sin_addr.s_addr   =       INADDR_BROADCAST;
          }
          net_sys_info->debug_view_info->sockfd = udp_multsockfd[i];
          net_sys_info->debug_view_info->remote_udp_sockaddr  = remote_addr_temp;
          net_sys_info->debug_view_info->trans_type = TRANS_TYPE_UDP;

          txlen = net_rxdata_analy(net_rxbuf, rxlen, net_txbuf, NET_TXBUF_SIZE, EXTERNAL);
          if(txlen)
          {
            txlen = sendto(udp_multsockfd[i], net_txbuf, txlen, 0, (struct sockaddr*)&remote_addr_temp, sizeof(struct sockaddr_in));
            hmi_busy_set(HMI_IO_BUSY);
            if(txlen)
            {
              net_sys_info->temp_information->trans_count++;
            }
          }
          else
          {
#if !SYS_BOOT_DEVICE
            mult_write(net_rxbuf, rxlen, (NET_PORT + i), udp_multsockfd[i], &remote_addr_temp);
#endif
          }
        }
      }
    }
  }
}

#endif

#if TCP_SERVER

#define ACCEPT_SOCK_MAX    8
int tcp_listenfd[TCP_MAX_CONNECTION];
int tcp_connectfd[TCP_MAX_CONNECTION][ACCEPT_SOCK_MAX];
static int32       tcp_sockfd = -1;
/****************************************************************************************
*函数名称: net_tcp_pool
*
*函数说明: 网络tcp数据包处理函数
****************************************************************************************/
const int i32NetPort[TCP_MAX_CONNECTION] =
{
  7000,
  502
};

void net_tcp_init(void)
{
  uint8 i;
  uint8 j;

  for(i = 0; i < TCP_MAX_CONNECTION; i++)
  {
    for(j = 0; j < ACCEPT_SOCK_MAX; j++)
    {
      tcp_connectfd[i][j] = TCP_UNVALID_FD;
    }


    while(1)
    {
      rt_thread_delay(RT_TICK_PER_SECOND / 20);

      tcp_local_addr.sin_family = AF_INET;
      tcp_local_addr.sin_port = htons(i32NetPort[i]);
      tcp_local_addr.sin_len = sizeof(tcp_local_addr);
      tcp_local_addr.sin_addr.s_addr = INADDR_ANY;

      tcp_listenfd[i] = socket(AF_INET, SOCK_STREAM, 0);
      if(tcp_listenfd[i] <= 0)
      {
        continue;
      }

      if(bind(tcp_listenfd[i], (struct sockaddr*) &tcp_local_addr, sizeof(tcp_local_addr)) < 0)
      {
        continue ;
      }
      if(listen(tcp_listenfd[i], TCP_MAX_CONNECTION) < 0)
      {
        continue;
      }
      break;
    }
  }
}

/****************************************************************************************
*函数名称: net_tcp_pool
*
*函数说明: 网络tcp数据包处理函数
****************************************************************************************/
#if 0
void net_tcp_pool(void)
{
  static uint32 len = 0;;
  static int rxlen  = 0;
  static int txlen  = 0;
  static int16 ret;
  static uint8 i;
  static fd_set readset;
  static fd_set writeset;

  struct timeval tv;
  tv.tv_sec = 0;
  tv.tv_usec = 0;
  len = sizeof(struct sockaddr_in);

  for(i = 0; i < TCP_MAX_CONNECTION; i++)
  {
    rxlen = 0;
    FD_ZERO(&readset);
    FD_ZERO(&writeset);
    FD_SET(tcp_listenfd[i], &readset);
    FD_SET(tcp_listenfd[i], &writeset);
    ret = select(tcp_listenfd[i] + 1, &readset, &writeset, 0, &tv);
    if(ret  > 0)
    {
      if(FD_ISSET(tcp_listenfd[i], &readset))
      {
        tcp_sockfd = accept(tcp_listenfd[i], (struct sockaddr*)&remote_addr_temp, (socklen_t*)&len);
        if(tcp_sockfd > 0)
        {
//          if(tcp_connectfd[i]  !=  INVALID_SOCKET)
//          {
//            close(tcp_connectfd[i]);
//            tcp_connectfd[i] = INVALID_SOCKET;
//          }
          tcp_connectfd[i] = tcp_sockfd;
          net_sys_info->debug_view_info->tcp_sockfd = tcp_connectfd[i];
          net_sys_info->debug_view_info->sockfd     = tcp_connectfd[i];
          net_tcp_state                         = TCP_STATE_IDLE;

          int flag = 1;
          /* set option at TCP level */ /* name of option */ /* the cast is historical cruft */ /* length of option value */
          ret = setsockopt(tcp_sockfd, IPPROTO_TCP, TCP_NODELAY, (void*) &flag,                     sizeof(int));

        }
      }
    }
    if(tcp_connectfd[i]  !=  TCP_UNVALID_FD)
    {
      FD_ZERO(&readset);
      FD_ZERO(&writeset);
      FD_SET(tcp_connectfd[i], &readset);
      FD_SET(tcp_connectfd[i], &writeset);
      ret = select(tcp_connectfd[i] + 1, &readset, &writeset, 0, &tv);
      if(ret  > 0)
      {
        if(FD_ISSET(tcp_connectfd[i], &readset)  && FD_ISSET(tcp_connectfd[i], &writeset))
        {
          rxlen = recv(tcp_connectfd[i], net_rxbuf, NET_RXBUF_SIZE, 0);
          if(rxlen <= 0)
          {
            close(tcp_connectfd[i]);
            tcp_connectfd[i] = TCP_UNVALID_FD;
            net_sys_info->debug_view_info->sockfd = TCP_UNVALID_FD;
            net_sys_info->debug_view_info->tcp_sockfd = TCP_UNVALID_FD;
          }
          else
          {
            txlen = net_rxdata_analy(net_rxbuf, rxlen, net_txbuf, NET_TXBUF_SIZE, EXTERNAL);
            if(txlen)
            {
              txlen = send(tcp_connectfd[i], net_txbuf, txlen, 0);
              hmi_busy_set(HMI_IO_BUSY);

              TCP_CLOSE(txlen, tcp_connectfd[i]);
            }
            hmi_busy_set(HMI_IO_BUSY);
          }
        }
      }
    }
  }
}
#else
void net_tcp_pool(void)
{
  static uint32 len = 0;;
  static int rxlen  = 0;
  static int txlen  = 0;
  static int16 ret;
  static uint8 i;
  static uint8 j;
  static fd_set readset;
  static fd_set writeset;
  static uint8 byport_ix = 0;

  struct timeval tv;
  tv.tv_sec = 0;
  tv.tv_usec = 0;
  len = sizeof(struct sockaddr_in);

  for(i = 0; i < TCP_MAX_CONNECTION; i++)
  {
    rxlen = 0;
    FD_ZERO(&readset);
    FD_ZERO(&writeset);
    FD_SET(tcp_listenfd[i], &readset);
    FD_SET(tcp_listenfd[i], &writeset);
    ret = select(tcp_listenfd[i] + 1, &readset, &writeset, 0, &tv);
    if(ret  > 0)
    {
      if(FD_ISSET(tcp_listenfd[i], &readset))
      {
        tcp_sockfd = accept(tcp_listenfd[i], (struct sockaddr*)&remote_addr_temp, (socklen_t*)&len);
        if(tcp_sockfd > 0)
        {
          // if(tcp_connectfd[i]  !=  INVALID_SOCKET)
          // {
          //   close(tcp_connectfd[i]);
          //   tcp_connectfd[i] = INVALID_SOCKET;
          // }
          for(j = 0; j < ACCEPT_SOCK_MAX; j++)
          {
            if(tcp_connectfd[i][j]  ==  INVALID_SOCKET)
            {
              break;
            }
          }
          // j = (j == ACCEPT_SOCK_MAX) ? 0 : j;
          if(j == ACCEPT_SOCK_MAX)
          {
            j = byport_ix;
            byport_ix = (byport_ix + 1) % ACCEPT_SOCK_MAX;
          }
          if(tcp_connectfd[i][j]  !=  INVALID_SOCKET)
          {
            close(tcp_connectfd[i][j]);
            tcp_connectfd[i][j] = INVALID_SOCKET;
          }
          tcp_connectfd[i][j] = tcp_sockfd;
          net_sys_info->debug_view_info->tcp_sockfd = tcp_connectfd[i][j];
          net_sys_info->debug_view_info->sockfd     = tcp_connectfd[i][j];
          net_tcp_state                         = TCP_STATE_IDLE;

          int flag = 1;
          /* set option at TCP level */ /* name of option */ /* the cast is historical cruft */ /* length of option value */
          ret = setsockopt(tcp_sockfd, IPPROTO_TCP, TCP_NODELAY, (void*) &flag,                     sizeof(int));

        }
      }
    }
    for(j = 0; j < ACCEPT_SOCK_MAX; j++)
    {
      if(tcp_connectfd[i][j]  !=  TCP_UNVALID_FD)
      {
        FD_ZERO(&readset);
        FD_ZERO(&writeset);
        FD_SET(tcp_connectfd[i][j], &readset);
        FD_SET(tcp_connectfd[i][j], &writeset);
        ret = select(tcp_connectfd[i][j] + 1, &readset, &writeset, 0, &tv);
        if(ret  > 0)
        {
          if(FD_ISSET(tcp_connectfd[i][j], &readset)  && FD_ISSET(tcp_connectfd[i][j], &writeset))
          {
            rxlen = recv(tcp_connectfd[i][j], net_rxbuf, NET_RXBUF_SIZE, 0);
            if(rxlen <= 0)
            {
              close(tcp_connectfd[i][j]);
              tcp_connectfd[i][j] = TCP_UNVALID_FD;
              net_sys_info->debug_view_info->sockfd = TCP_UNVALID_FD;
              net_sys_info->debug_view_info->tcp_sockfd = TCP_UNVALID_FD;
            }
            else
            {
              txlen = net_rxdata_analy(net_rxbuf, rxlen, net_txbuf, NET_TXBUF_SIZE, EXTERNAL);
              if(txlen)
              {
                txlen = send(tcp_connectfd[i][j], net_txbuf, txlen, 0);
                hmi_busy_set(HMI_IO_BUSY);

                TCP_CLOSE(txlen, tcp_connectfd[i][j]);
              }
              hmi_busy_set(HMI_IO_BUSY);
            }
          }
        }
      }
    }

  }
}
#endif
#endif

/****************************************************************************************
*函数名称: socket_app_init
*
*函数说明: socket 应用初始化函数
****************************************************************************************/
void socket_app_init(void)
{
  net_sys_info  = sys_info_datainfoget();
#if TCP_SERVER
  net_tcp_init();
#endif

#if UDP_MULTSERVER
  net_udpmult_init();
#endif

}

/****************************************************************************************
*函数名称: socket_app_pool
*
*函数说明: 网络socket数据包处理函数
****************************************************************************************/
void socket_app_pool(void)
{
#if TCP_SERVER
  net_tcp_pool();
#endif
#if UDP_MULTSERVER
  net_udpmult_pool();
#endif
}
STM32原子探索者：基于HAL库的多连接LWIP TCP服务器
UbiSqlserver的博客
09-21 847
最后，我们使用tcp_accept函数指定当有新的连接请求时将调用的回调函数tcp_server_accept。然后，我们使用tcp_recved函数通知协议栈已经成功接收到数据，并使用pbuf_free函数释放接收到的数据缓冲区。如果是，我们使用tcp_recv函数指定当收到数据时将调用的回调函数tcp_server_recv。其中，HAL_Init()用于初始化HAL库，SystemClock_Config()用于配置系统时钟，MX_LWIP_Init()用于初始化LWIP协议栈。
TCP服务器和客户端最大连接数
chengshan4842的博客
08-23 2278
只要资源 （内存硬盘cpu）足够，理论上可以接收无限个链接。所谓65535的限制，是针对客户端的，客户机每链接一个服务，就必须开一个tcp端口与之对应。这样，链接到65535个服务后，本地端口就被占满。服务端口仅仅使用一个。一个tcp链接，是四个元素决定的，server IP：po...
实现 FreeRTOS 和 LWIP 的多客户端服务器（socket方式）
最新发布
weixin_53150291的博客
07-26 230
本文介绍了在FreeRTOS中基于LWIP实现多客户端服务器的两种方法：1）任务方式，为每个客户端创建独立处理任务；2）select方式，使用非阻塞socket单任务处理多连接。详细展示了两种方案的代码实现，包括socket创建、绑定监听、连接处理等关键步骤。同时指出需要在lwipopts.h中配置相关参数，并提醒注意资源管理、错误处理和性能优化。任务方式简单但资源消耗大，select方式高效但实现复杂，开发者需根据应用场景选择合适方案。
Lwip之TCP服务端示例记录(1对多)
scl8295的博客
03-08 1597
1310241500。
lwIP 多网口绑定技术详解
qq_43353923的博客
06-19 692
正确初始化每个实例使用版本兼容的绑定方法：lwIP ≥ 2.1.0：优先使用旧版本：通过绑定特定 IP 地址实现在数据回调中验证来源网口配置正确的路由规则底层驱动确保数据分发到正确的网口实例遵循这些原则，您可以构建高性能的多网口网络设备，实现网络流量隔离、负载均衡和故障切换等高级功能。
STM32+LWIP服务器实现多客户端连接
qq_43536512的博客
09-25 1万+
用过正点原子LWIP服务器例程开发的朋友可能知道，例程的设计是只支持一个客户端连接的，但实际应用中往往需要用到多客户端连接。下面是在正点原子扩展例程 网络实验14 NETCONN_TCP 服务器(UCOSIII版本) 的基础上进行修改，实现多客户端连接的一个方法。 1、TCP服务器创建过程 建立一个TCP服务器需要经过 创建连接 conn=netconn_new(NETCONN_TCP); //创建一个TCP链接 绑定端口号 netconn_bind(conn,IP_ADDR_ANY,TCP_SERV
lwip tcp stm32 rtos 多客户端连接问题
qq_41142671的博客
12-09 730
最近在搞多客户端连接问题，使用的方法是任务创建的形式。一共2个任务，一个任务专门用于监听客户端的连接状态，一个任务就是客户端数据处理函数。MEMP_NUM_TCP_PCB MEMP_NUM_TCP_PCB_LISTEN MEMP_NUM_NETCONN 这三个宏限制的。1.客户端连接断开后，再次重新连接，发现服务器从网络上接受的数据是错误的。问题是：接受和发送的buff没有释放内存。2.多个客户端连接后，发现程序会直接死掉。3.多客户端连接数量的问题，发现lwip的客户端连接数量是受到。
STM32 TCP并发服务器源码（可与多个客户端通信）
07-09
并发服务器则是在同一时间处理多个客户端连接的能力，这通常通过多线程或异步编程实现，以提高服务的效率和响应速度。 在这个“STM32 TCP并发服务器源码”中，开发者可能采用了以下关键技术和概念： 1. **套接字...
lwip tcp
03-28
例如，接收到的 TCP 数据包可能由多个 `pbuf` 链接而成，避免单一大块内存分配： ```c struct pbuf { struct pbuf *next; void *payload; u16_t len; u16_t flags; // 类型标记（PBUF_RAM/PBUF_POOL等） }; ...
七LWIP学习笔记之传输控制协议（TCP）
Black_黑色的博客
04-27 1285
七LWIP学习笔记之传输控制协议（TCP） 一、协议简介 1、TCP的必要性 　　在很多情 况下，应用程序期望传输层能提供可靠的服务，在上层应用想把大量的顺序数据（例如一个文件）发送到另一台主机时，使用 UDP 会显得非常不方便。 在接收端，所有数据将按照编号被顺序组织起来，当所有数据接收成功后，TCP 才把数据递交给应用层。应用层不必担心报文的乱序、重复、丢失等题，TCP 采...
lwIP TCP/IP 协议栈笔记之十二： IP协议
Xanthium
09-02 2456
目录 1. IP地址 1.1 IP地址概述 1.2 IP地址编址 1.3 特殊IP地址 1.3.1 受限广播地址 1.3.2 直接广播地址 1.3.3 多播地址 1.3.4 环回地址 1.3.5 本网络本主机 2. 局域网与广域网的概念 2.1 局域网 2.2 广域网 3. 网络地址转换（NAT） 4. IP 数据报 5. IP 数据报的数据结构 6. IP 数据报...
LWIP重要说明
04-27
重要的文档，有关网络连接方面，LWIP是很重要的有关网络
lwIP TCP/IP 协议栈笔记之十： LwIP 数据流框架
Xanthium
08-29 5998
目录 1. 网卡数据接收流程 2. 内核超时处理 2.1 sys_timeo 结构体与超时链表 2.2 注册超时事件 2.3 超时检查 3. tcpip_thread 线程 4. LwIP 中的消息 4.1 消息结构 4.2 数据包消息 4.3API 消息 通信过程中，本质上是数据的交互，数据传递，理解LwIP的框架，就可以更清晰的理解数据传递过程、原理。 注：以下皆为有...
LwIP之TCP Server多client连接发送和接收Demo
ShineRoyal
02-22 5611
msh调用时对端口进行监听，监听到有客户端连接时，创建新的线程进行连接。 监听时设置最大连接数为4，使用SocketTool工具模拟client连接，实际效果如下。 /* * Copyright (c) 2006-2019, RT-Thread Development Team * * SPDX-License-Identifier: Apache-2.0 * * Change Log...
lwip 一个服务器连接多个客户端_「正点原子FPGA连载」第三十三章基于lwip的echo实验...
weixin_39630498的博客
11-27 2455
1)摘自【正点原子】领航者 ZYNQ 之嵌入式开发指南2)实验平台：正点原子领航者ZYNQ开发板3)平台购买地址：https://item.taobao.com/item.htm?&id=6061601087614)全套实验源码+手册+视频下载:http://www.openedv.com/docs/boards/fpga/zdyz_linhanz.html5)对正点原子FPGA感兴趣的同...
原子探索者 F407 LWIP 客户端多连接 断网线断服务 重新连接
curen999的博客
07-06 1289
原子探索者 F407 LWIP 客户端多连接 断网线断服务 重新连接 通过链路检测判断链路是否正常，并在正常后重新连接 通过子任务来启动连接，几个连接，就几个子任务 1、链路检测 通过回调函数，判断链路是否正常，并置相应位： uint8_t linkStatFlag = 0; void ethernetif_notify_conn_changed(struct netif *netif) { if(netif_is_link_up(netif) ) { printf("net link is up!
LwIP多TCP连接问题
热门推荐
我的未来从这里开始
08-29 1万+
多个TCP连接的问题困扰了我很久，前段时间解决了这个问题，现在写下我的感受： 多个TCP可以绑定多个端口，这里我是绑定一个端口，这样更加复合实际应用（我的多个TCP的功能都是一样的，即同一个应用）。创建、绑定和侦听只能运行一次，这个是对服务器的绑定（我的板子是服务端）。有几个TCP连接就要有几个进程来建立TCP连接。创建、绑定和侦听必须创建一个进程，此进程与TCP进程之间的关系是：
TCP服务器连接多客户端（C语言实现）
动感超人_Crush
05-13 1万+
目录 思路： 逻辑设计： 代码实现： 思路： 在服务端客户端T一对一TCP的基础上增加几条通信即可，要求各个连接可同时进行通信因此使用多线程。 主线程在listen实现后，使用一个 for 循环一直循环等待客户端的连接请求，将每次连接标记（sockFd）保存作为开启检测（检测条件可修改，我写的这个检测貌似也没啥用(▼ヘ▼#)）。 每次连接都会开启一个线程用于和客户端的通信（也是使用 for 循环进行数据的接收、处理、发送），数据接收使用阻塞等待。 通信的具体实现，在开发板上部署运行下方..
OPC客户端不能连接多个OPC服务器？一个OPC Funnel就够了
MatrikonChina的博客
09-30 2987
一般来讲OPC客户端本身可以支持连接多个OPC服务器，但是仍然存在着有些客户端，因为许可限制只能与单个数据源建立连接，或者一些编程没有做好只能支持单点连接的情况，那么OPC Funnel就是这种情况下的理想选择。另外有些时候，一些公司希望自己底下的多台设备的OPC服务器能够把数据统一收集上传方便管理，OPC Funnel同样可以适用于这种情况。
STM32 原子探索者基于HAL库多连接LWIP tcp 服务器
curen999的博客
06-30 1267
基于HAL库多连接LWIP tcp 服务器 1、通过原子探索者407板子做的样例； 2、通过STM32CUBEMX 生成程序模板； 3、修改lwip部分参数； 4、添加多连接TCPserver； 1、通过CubeMx生成程序模板 1）添加FREERTOS定时器 2）添加串口1用来做调试输出 3）网卡的添加以及lwip的添加见其他文档，其中ip地址为192.168.12.97 4）添加freeRTOS并修改参数：增加os的堆内存大小以及允许使用定时器、扩充默认任务的堆栈大小 允许使用定时器，定时器的定义
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

大文梅

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值