STM32F407+FreeRTOS+Ethernet(DP83848)+Lwip实现socket通信

1万 · 2021-10-4 16:32

/*-----------------------------------------------------------------------------------*/
#if (osCMSIS < 0x20000U)
osMutexId lwip_sys_mutex;
osMutexDef(lwip_sys_mutex);
#else
osMutexId_t lwip_sys_mutex;
#endif
// Initialize sys arch
void sys_init(void)
{
#if (osCMSIS < 0x20000U)
  lwip_sys_mutex = osMutexCreate(osMutex(lwip_sys_mutex));
#else
  lwip_sys_mutex = osMutexNew(NULL);
#endif
}
/*-----------------------------------------------------------------------------------*/
                                    /* Mutexes*/
/*-----------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------*/
#if LWIP_COMPAT_MUTEX == 0
/* Create a new mutex*/
err_t sys_mutex_new(sys_mutex_t *mutex) {
#if (osCMSIS < 0x20000U)
  osMutexDef(MUTEX);
  *mutex = osMutexCreate(osMutex(MUTEX));
#else
  *mutex = osMutexNew(NULL);
#endif
  if(*mutex == NULL)
  {
#if SYS_STATS
++lwip_stats.sys.mutex.err;
#endif /* SYS_STATS */
return ERR_MEM;
  }
#if SYS_STATS
  ++lwip_stats.sys.mutex.used;
  if (lwip_stats.sys.mutex.max < lwip_stats.sys.mutex.used) {
lwip_stats.sys.mutex.max = lwip_stats.sys.mutex.used;
  }
#endif /* SYS_STATS */
  return ERR_OK;
}
/*-----------------------------------------------------------------------------------*/
/* Deallocate a mutex*/
void sys_mutex_free(sys_mutex_t *mutex)
{
#if SYS_STATS
   --lwip_stats.sys.mutex.used;
#endif /* SYS_STATS */
  osMutexDelete(*mutex);
}
/*-----------------------------------------------------------------------------------*/
/* Lock a mutex*/
void sys_mutex_lock(sys_mutex_t *mutex)
{
#if (osCMSIS < 0x20000U)
  osMutexWait(*mutex, osWaitForever);
#else
  osMutexAcquire(*mutex, osWaitForever);
#endif
}
/*-----------------------------------------------------------------------------------*/
/* Unlock a mutex*/
void sys_mutex_unlock(sys_mutex_t *mutex)
{
  osMutexRelease(*mutex);
}
#endif /*LWIP_COMPAT_MUTEX*/
/*-----------------------------------------------------------------------------------*/
// TODO
/*-----------------------------------------------------------------------------------*/
/*
  Starts a new thread with priority "prio" that will begin its execution in the
  function "thread()". The "arg" argument will be passed as an argument to the
  thread() function. The id of the new thread is returned. Both the id and
  the priority are system dependent.
*/
sys_thread_t sys_thread_new(const char *name, lwip_thread_fn thread , void *arg, int stacksize, int prio)
{
#if (osCMSIS < 0x20000U)
  const osThreadDef_t os_thread_def = { (char *)name, (os_pthread)thread, (osPriority)prio, 0, stacksize};
  return osThreadCreate(&os_thread_def, arg);
#else
  const osThreadAttr_t attributes = {
                     .name = name,
                     .stack_size = stacksize,
                     .priority = (osPriority_t)prio,
                  };
  return osThreadNew(thread, arg, &attributes);
#endif
}
/*
  This optional function does a "fast" critical region protection and returns
  the previous protection level. This function is only called during very short
  critical regions. An embedded system which supports ISR-based drivers might
  want to implement this function by disabling interrupts. Task-based systems
  might want to implement this by using a mutex or disabling tasking. This
  function should support recursive calls from the same task or interrupt. In
  other words, sys_arch_protect() could be called while already protected. In
  that case the return value indicates that it is already protected.
  sys_arch_protect() is only required if your port is supporting an operating
  system.
  Note: This function is based on FreeRTOS API, because no equivalent CMSIS-RTOS
      API is available
*/
sys_prot_t sys_arch_protect(void)
{
#if (osCMSIS < 0x20000U)
  osMutexWait(lwip_sys_mutex, osWaitForever);
#else
  osMutexAcquire(lwip_sys_mutex, osWaitForever);
#endif
  return (sys_prot_t)1;
}
/*
  This optional function does a "fast" set of critical region protection to the
  value specified by pval. See the documentation for sys_arch_protect() for
  more information. This function is only required if your port is supporting
  an operating system.
  Note: This function is based on FreeRTOS API, because no equivalent CMSIS-RTOS
      API is available
*/
void sys_arch_unprotect(sys_prot_t pval)
{
  ( void ) pval;
  osMutexRelease(lwip_sys_mutex);
}
#endif /* !NO_SYS */

1万 · 2021-10-4 16:33

2.4 网卡底层的编写
在无操作性移植的时候，我们的网卡收发数据就是单纯的收发数据， ethernetif_input() 函数就是处理接收网卡数据的，但是使用了操作系统的话，我们一般将接收数据函数独立成为一个网卡接收线程，这样子在收到数据的时候才去处理数据，然后递交给内核线程，所以我们只需要稍作修改即可，将函数转换成线程就行了，并且在初始化网卡的时候创建网卡接收线程。当然，我们也能将发送函数独立成一个线程，我们暂时没有必要去处理它，此处只创建一个网卡接收线程，具体见

void ethernetif_input(void const * argument)
{
  struct pbuf *p;
  struct netif *netif = (struct netif *) argument;
  for( ;; )
  {
if (osSemaphoreWait(s_xSemaphore, TIME_WAITING_FOR_INPUT) == osOK)
{
   do
   {
      LOCK_TCPIP_CORE();
      p = low_level_input( netif );
      if (p != NULL)
      {
      if (netif->input( p, netif) != ERR_OK )
      {
         pbuf_free(p);
      }
      }
      UNLOCK_TCPIP_CORE();
   } while(p!=NULL);
}
  }
}

在网卡接收线程中需要留意一下以下内容：网卡接收线程是需要通过信号量机制去接收数据的，一般来说我们都是使用中断的方式去获取网络数据包，当产生中断的时候，我们一般不会在中断中处理数据，而是告诉对应的线程去处理，也就是我们的网卡接收线程去处理数据，那么就会通过信号量进行同步，当网卡接收到了数据就会产生中断释放一个信号量，然后线程从阻塞中恢复，去获取网卡的数据并且向上层递交。当然我们还需要在中断中对网卡底层进行编写！

void HAL_ETH_RxCpltCallback(ETH_HandleTypeDef *heth)
{
  osSemaphoreRelease(s_xSemaphore);
}

这个函数是有ETH_IRQHandler中的HAL_ETH_IRQHandler调用！

1万 · 2021-10-4 16:33

网卡初始化函数 low_level_init()

static void low_level_init(struct netif *netif)
{
  uint32_t regvalue = 0;
  HAL_StatusTypeDef hal_eth_init_status;
/* Init ETH */
uint8_t MACAddr[6] ;
  heth.Instance = ETH;
  heth.Init.AutoNegotiation = ETH_AUTONEGOTIATION_ENABLE;
  heth.Init.Speed = ETH_SPEED_100M;
  heth.Init.DuplexMode = ETH_MODE_FULLDUPLEX;
  heth.Init.PhyAddress = DP83848_PHY_ADDRESS;
  MACAddr[0] = 0x00;
  MACAddr[1] = 0x80;
  MACAddr[2] = 0xE1;
  MACAddr[3] = 0x00;
  MACAddr[4] = 0x00;
  MACAddr[5] = 0x00;
  heth.Init.MACAddr = &MACAddr[0];
  heth.Init.RxMode = ETH_RXINTERRUPT_MODE;
  heth.Init.ChecksumMode = ETH_CHECKSUM_BY_HARDWARE;
  heth.Init.MediaInterface = ETH_MEDIA_INTERFACE_RMII;
  /* USER CODE BEGIN MACADDRESS */
  /* USER CODE END MACADDRESS */
  hal_eth_init_status = HAL_ETH_Init(&heth);
  if (hal_eth_init_status == HAL_OK)
  {
/* Set netif link flag */
netif->flags |= NETIF_FLAG_LINK_UP;
  }
  /* Initialize Tx Descriptors list: Chain Mode */
  HAL_ETH_DMATxDescListInit(&heth, DMATxDscrTab, &Tx_Buff[0][0], ETH_TXBUFNB);
  /* Initialize Rx Descriptors list: Chain Mode  */
  HAL_ETH_DMARxDescListInit(&heth, DMARxDscrTab, &Rx_Buff[0][0], ETH_RXBUFNB);
#if LWIP_ARP || LWIP_ETHERNET
  /* set MAC hardware address length */
  netif->hwaddr_len = ETH_HWADDR_LEN;
  /* set MAC hardware address */
  netif->hwaddr[0] =  heth.Init.MACAddr[0];
  netif->hwaddr[1] =  heth.Init.MACAddr[1];
  netif->hwaddr[2] =  heth.Init.MACAddr[2];
  netif->hwaddr[3] =  heth.Init.MACAddr[3];
  netif->hwaddr[4] =  heth.Init.MACAddr[4];
  netif->hwaddr[5] =  heth.Init.MACAddr[5];
  /* maximum transfer unit */
  netif->mtu = 1500;
  /* Accept broadcast address and ARP traffic */
  /* don't set NETIF_FLAG_ETHARP if this device is not an ethernet one */
  #if LWIP_ARP
netif->flags |= NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP;
  #else
netif->flags |= NETIF_FLAG_BROADCAST;
  #endif /* LWIP_ARP */
/* create a binary semaphore used for informing ethernetif of frame reception */
  osSemaphoreDef(SEM);
  s_xSemaphore = osSemaphoreCreate(osSemaphore(SEM), 1);
/* create the task that handles the ETH_MAC */
/* USER CODE BEGIN OS_THREAD_DEF_CREATE_CMSIS_RTOS_V1 */
  osThreadDef(EthIf, ethernetif_input, osPriorityRealtime, 0, INTERFACE_THREAD_STACK_SIZE);
  osThreadCreate (osThread(EthIf), netif);
/* USER CODE END OS_THREAD_DEF_CREATE_CMSIS_RTOS_V1 */
  /* Enable MAC and DMA transmission and reception */
  HAL_ETH_Start(&heth);
/* USER CODE BEGIN PHY_PRE_CONFIG */
/* USER CODE END PHY_PRE_CONFIG */
  /**** Configure PHY to generate an interrupt when Eth Link state changes ****/
  /* Read Register Configuration */
  HAL_ETH_ReadPHYRegister(&heth, PHY_MICR, &regvalue);
  regvalue |= (PHY_MICR_INT_EN | PHY_MICR_INT_OE);
  /* Enable Interrupts */
  HAL_ETH_WritePHYRegister(&heth, PHY_MICR, regvalue );
  /* Read Register Configuration */
  HAL_ETH_ReadPHYRegister(&heth, PHY_MISR, &regvalue);
  regvalue |= PHY_MISR_LINK_INT_EN;
  /* Enable Interrupt on change of link status */
  HAL_ETH_WritePHYRegister(&heth, PHY_MISR, regvalue);
/* USER CODE BEGIN PHY_POST_CONFIG */
/* USER CODE END PHY_POST_CONFIG */
#endif /* LWIP_ARP || LWIP_ETHERNET */
/* USER CODE BEGIN LOW_LEVEL_INIT */
/* USER CODE END LOW_LEVEL_INIT */
}

其中low_level_output/low_level_input跟noos函数编写一致即可

1万 · 2021-10-4 16:33

3.代码简介(以CubeMx生成代码做说明)

我大概分析了一下init以及收数据的代码流程(红线)

1万 · 2021-10-4 16:34

4.使用lwip的socket通信
4.1 socket概念
Socket 英文原意是“孔”或者“插座”的意思，在网络编程中，通常将其称之为“套接字”，当前网络中的主流程序设计都是使用 Socket 进行编程的，因为它简单易用，更是一个标准，能在不同平台很方便移植。本章讲解的是 LwIP 中的 Socket 编程接口，因为 LwIP 作者为了能让更多开发者直接上手 LwIP 的编程，专门设计了 LwIP 的第三种编程接口——Socket API，它兼容 BSDSocket。

Socket 虽然是能在多平台移植，但是 LwIP 中的 Socket 并不完善，因为 LwIP 设计之初就是为了在嵌入式平台中使用，它只实现了完整 Socket 的部分功能，不过，在嵌入式平台中，这些功能早已足够。

在 Socket 中，它使用一个套接字来记录网络的一个连接，套接字是一个整数，就像我们操作文件一样，利用一个文件描述符，可以对它打开、读、写、关闭等操作，类似的，在网络中，我们也可以对 Socket 套接字进行这样子的操作，比如开启一个网络的连接、读取连接主机发送来的数据、向连接的主机发送数据、终止连接等操作。

4.2 socket API介绍
4.2.1 socket() API介绍

这个函数的功能是向内核申请一个套接字，lwip中的socket最终实现是lwip_socket，但是为了兼容BSD socket，所以重新define了一下，我们来看下

/** @ingroup socket */
#define socket(domain,type,protocol)             lwip_socket(domain,type,protocol)
参数：

domain：表示该套接字使用的协议簇，对于 TCP/IP 协议来说，该值始终为 AF_INET。

type：指定了套接字使用的服务类型，可能的类型有 3 种：

1）SOCK_STREAM：提供可靠的（即能保证数据正确传送到对方）面向连接的 Socket 服务，多用于资料（如文件）传输，如 TCP 协议。

2）SOCK_DGRAM：是提供无保障的面向消息的 Socket 服务，主要用于在网络上发广播信息，如 UDP 协议，提供无连接不可靠的数据报交付服务。

3）SOCK_RAW：表示原始套接字，它允许应用程序访问网络层的原始数据包，这个套接字用得比较少，暂时不用理会它。

protocol ：指定了套接字使用的协议，在 IPv4 中，只有 TCP 协议提供 SOCK_STREAM 这种可靠的服务，只有 UDP 协议提供 SOCK_DGRAM 服务，对于这两种协议，protocol 的值均为 0。当申请套接字成功的时候，该函数返回一个 int 类型的值，也是 Socket 描述符，用户通过这个值可以索引到一个 Socket 连接结构——lwip_sock，当申请套接字失败时，该函数返回-1。

4.2.2 bind() API介绍

用于服务器端绑定套接字与网卡信息,lwip中的bind最终实现是lwip_bind，但是为了兼容BSD bind，所以重新define了一下，我们来看下

/** @ingroup socket */
#define bind(s,name,namelen)                   lwip_bind(s,name,namelen)
参数：

s :是表示要绑定的 Socket 套接字，注意了，这个套机字必须是从 socket() 函数中返回的索引，否则将无法完成绑定操作。

name: 是一个指向 sockaddr 结构体的指针，其中包含了网卡的 IP 地址、端口号等重要的信息，LwIP 为了更好描述这些信息，使用了 sockaddr 结构体来定义了必要的信息的字段，它常被用于Socket API 的很多函数中，我们在使用 bind() 的时候，只需要直接填写相关字段即可

namelen：指定了 name 结构体的长度。

下面我们来说下name的struct,如下：

struct sockaddr {
  u8_t       sa_len;
  sa_family_t sa_family;
  char       sa_data[14];
};
为了便于理解，lwip重新定义了一下这个结构体

/* members are in network byte order */
struct sockaddr_in {
  u8_t          sin_len;
  sa_family_t    sin_family; /* 协议簇 */
  in_port_t    sin_port; /* 端口号 */
  struct in_addr  sin_addr; /* IP地址 */
#define SIN_ZERO_LEN 8
  char          sin_zero[SIN_ZERO_LEN];
};
4.2.3 connect() API介绍

它用于客户端中，将 Socket 与远端 IP 地址、端口号进行绑定，在 TCP 客户端连接中，调用这个函数将发生握手过程（会发送一个 TCP 连接请求），并最终建立新的 TCP 连接，而对于 UDP协议来说，调用这个函数只是在 UDP 控制块中记录远端 IP 地址与端口号，而不发送任何数据，参数信息与 bind() 函数是一样的

/** @ingroup socket */
#define connect(s,name,namelen)                lwip_connect(s,name,namelen)
4.2.4 listen() API介绍

只能在 TCP 服务器中使用，让服务器进入监听状态，等待远端的连接请求， LwIP 中可以接收多个客户端的连接，因此参数 backlog 指定了请求队列的大小

/** @ingroup socket */
#define listen(s,backlog)                      lwip_listen(s,backlog)
4.2.5 accept() API介绍

用于 TCP 服务器中，等待着远端主机的连接请求，并且建立一个新的 TCP 连接，在调用这个函数之前需要通过调用 listen() 函数让服务器进入监听状态。accept() 函数的调用会阻塞应用线程直至与远程主机建立 TCP 连接。参数 addr 是一个返回结果参数，它的值由 accept() 函数设置，其实就是远程主机的地址与端口号等信息，当新的连接已经建立后，远端主机的信息将保存在连接句柄中，它能够唯一的标识某个连接对象。同时函数返回一个 int 类型的套接字描述符，根据它能索引到连接结构，如果连接失败则返回-1

/** @ingroup socket */
#define accept(s,addr,addrlen)                   lwip_accept(s,addr,addrlen)
4.2.6 read()、recv()、recvfrom() API介绍

read() 与 recv() 函数的核心是调用 recvfrom() 函数， recv() 与 read() 函数用于从 Socket 中接收数据，它们可以是 TCP 协议和 UDP 协议！

/** @ingroup socket */
#define recv(s,mem,len,flags)                   lwip_recv(s,mem,len,flags)
/** @ingroup socket */
#define recvmsg(s,message,flags)                lwip_recvmsg(s,message,flags)
/** @ingroup socket */
#define recvfrom(s,mem,len,flags,from,fromlen) lwip_recvfrom(s,mem,len,flags,from,fromlen)
men 参数记录了接收数据的缓存起始地址，len 用于指定接收数据的最大长度，如果函数能正确接收到数据，将会返回一个接收到数据的长度，否则将返回-1，若返回值为 0，表示连接已经终止，应用程序可以根据返回的值进行不一样的操作。recv() 函数包含一个 flags 参数，我们暂时可以直接忽略它，设置为 0 即可。注意，如果接收的数据大于用户提供的缓存区，那么多余的数据会被直接丢弃。

4.2.7 sendto() API介绍

这个函数主要是用于 UDP 协议传输数据中，它向另一端的 UDP 主机发送一个 UDP 报文，参数 data 指定了要发送数据的起始地址，而 size 则指定数据的长度，参数 flag 指定了发送时候的一些处理，比如外带数据等，此时我们不需要理会它，一般设置为 0 即可，参数 to 是一个指向 sockaddr 结构体的指针，在这里需要我们自己提供远端主机的 IP 地址与端口号，并且用 tolen 参数指定这些信息的长度！

/** @ingroup socket */
#define sendto(s,dataptr,size,flags,to,tolen)    lwip_sendto(s,dataptr,size,flags,to,tolen)
4.2.8 sendto() API介绍

send() 函数可以用于 UDP 协议和 TCP 连接发送数据。在调用 send() 函数之前，必须使用 connect()函数将远端主机的 IP 地址、端口号与 Socket 连接结构进行绑定。对于 UDP 协议，send() 函数将调用 lwip_sendto() 函数发送数据，而对于 TCP 协议，将调用 netconn_write_partly() 函数发送数据。相对于 sendto() 函数，参数基本是没啥区别的，但无需我们设置远端主机的信息，更加方便操作，因此这个函数在实际中使用也是很多的

/** @ingroup socket */
#define send(s,dataptr,size,flags)             lwip_send(s,dataptr,size,flags)
4.2.9 write() API介绍

这个函数一般用于处于稳定的 TCP 连接中传输数据，当然也能用于 UDP 协议中，它也是基于lwip_send 上实现的，但是无需我们设置 flag 参数

/** @ingroup socket */
#define write(s,dataptr,len)                   lwip_write(s,dataptr,len)
4.2.10 close() API介绍

close() 函数是用于关闭一个指定的套接字，在关闭套接字后，将无法使用对应的套接字描述符索引到连接结构，该函数的本质是对 netconn_delete() 函数的封装（真正处理的函数是 netconn_prepare_delete()），如果连接是 TCP 协议，将产生一个请求终止连接的报文发送到对端主机中，如果是 UDP 协议，将直接释放 UDP 控制块的内容!

/** @ingroup socket */
#define close(s)                               lwip_close(s)

1万 · 2021-10-4 16:34

4.3 socket创建一个TCP server做一个回显实验

代码如下：

#include "tcpecho.h"

#include "lwip/opt.h"

#if LWIP_SOCKET

#include <lwip/sockets.h>

#include "lwip/sys.h"

#include "lwip/api.h"

/*-----------------------------------------------------------------------------------*/

#define RECV_DATA (1024)

#define LOCAL_PORT 5001

static void

tcpecho_thread(void *arg)

{

int sock = -1,connected;

char *recv_data;

struct sockaddr_in server_addr,client_addr;

socklen_t sin_size;

int recv_data_len;

printf("本地端口号是%d\n\n",LOCAL_PORT);

recv_data = (char *)pvPortMalloc(RECV_DATA);

if (recv_data == NULL)

{

printf("No memory\n");

goto __exit;

}

sock = socket(AF_INET, SOCK_STREAM, 0);

if (sock < 0)

{

printf("Socket error\n");

goto __exit;

}

server_addr.sin_family = AF_INET;

server_addr.sin_addr.s_addr = INADDR_ANY;

server_addr.sin_port = htons(LOCAL_PORT);

memset(&(server_addr.sin_zero), 0, sizeof(server_addr.sin_zero));

if (bind(sock, (struct sockaddr *)&server_addr, sizeof(struct sockaddr)) == -1)

{

printf("Unable to bind\n");

goto __exit;

}

if (listen(sock, 5) == -1)

{

printf("Listen error\n");

goto __exit;

}

while(1)

{

sin_size = sizeof(struct sockaddr_in);

connected = accept(sock, (struct sockaddr *)&client_addr, &sin_size);

printf("new client connected from (%s, %d)\n",

inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));

{

int flag = 1;

setsockopt(connected,

IPPROTO_TCP, /* set option at TCP level */

TCP_NODELAY, /* name of option */

(void *) &flag, /* the cast is historical cruft */

sizeof(int)); /* length of option value */

}

while(1)

{

recv_data_len = recv(connected, recv_data, RECV_DATA, 0);

if (recv_data_len <= 0)

break;

printf("recv %d len data\n",recv_data_len);

write(connected,recv_data,recv_data_len);

}

if (connected >= 0)

closesocket(connected);

connected = -1;

}

__exit:

if (sock >= 0) closesocket(sock);

if (recv_data) free(recv_data);

}

/*-----------------------------------------------------------------------------------*/

void

tcpecho_init(void)

{

sys_thread_new("tcpecho_thread", tcpecho_thread, NULL, 512, 4);

}

/*-----------------------------------------------------------------------------------*/

1万 · 2021-10-4 16:35

效果如下：

这个实验室我们STM32做TCP server,然后IP是静态IP(192.168.1.250),开启的TCP port是5001,

1万 · 2021-10-4 16:36

4.4 socket创建一个TCP client间隔发送数据

#include "tcp_client.h"
#include "lwip/opt.h"
#include "lwip/sys.h"
#include "lwip/api.h"
#include <lwip/sockets.h>
#define DEST_IP_ADDR0 192
#define DEST_IP_ADDR1 168
#define DEST_IP_ADDR2 1
#define DEST_IP_ADDR3 102
#define DEST_PORT 5001
static void client(void *thread_param)
{
  int sock = -1;
  struct sockaddr_in client_addr;

  ip4_addr_t ipaddr;

  uint8_t send_buf[]= "This is a TCP Client test...\n";

  printf("目地IP地址:%d.%d.%d.%d \t 端口号:%d\n\n",    \
      DEST_IP_ADDR0,DEST_IP_ADDR1,DEST_IP_ADDR2,DEST_IP_ADDR3,DEST_PORT);

  printf("请将电脑上位机设置为TCP Server.在User/arch/sys_arch.h文件中将目标IP地址修改为您电脑上的IP地址\n\n");

  printf("修改对应的宏定义:DEST_IP_ADDR0,DEST_IP_ADDR1,DEST_IP_ADDR2,DEST_IP_ADDR3,DEST_PORT\n\n");

  IP4_ADDR(&ipaddr,DEST_IP_ADDR0,DEST_IP_ADDR1,DEST_IP_ADDR2,DEST_IP_ADDR3);
  while(1)
  {
sock = socket(AF_INET, SOCK_STREAM, 0);
if (sock < 0)
{
   printf("Socket error\n");
   vTaskDelay(10);
   continue;
}
client_addr.sin_family = AF_INET;
client_addr.sin_port = htons(DEST_PORT);
client_addr.sin_addr.s_addr = ipaddr.addr;
memset(&(client_addr.sin_zero), 0, sizeof(client_addr.sin_zero));
if (connect(sock,
            (struct sockaddr *)&client_addr,
            sizeof(struct sockaddr)) == -1)
{
      printf("Connect failed!\n");
      closesocket(sock);
      vTaskDelay(10);
      continue;
}

printf("Connect to server successful!\n");

while (1)
{
   if(write(sock,send_buf,sizeof(send_buf)) < 0)
      break;

   vTaskDelay(1000);
}

closesocket(sock);
  }
}
void
tcp_client_init(void)
{
  sys_thread_new("client", client, NULL, 512, 4);
}

1万 · 2021-10-4 16:36

效果如下：

这个实验室我们STM32做TCP client,然后连接pc的tcp server(PC IP地址为：192.168.1.102)，PC的TCP port为5001

只看该作者 · 2021-10-6 16:01

STM32F407+FreeRTOS+Ethernet(DP83848)+Lwip实现socket通信

十世金身

技术领袖奖章

坚毅之洋流

荣誉元老奖章