【STM32F407+CUBEMX+FreeRTOS+lwIP netconn UDP TCP记录】

STM32F407+CUBEMX+FreeRTOS+lwIP netconn UDP TCP记录

  • 注意
  • UDP
    • UDP1
    • UDP2
  • TCP
    • TCP client
    • TCP server
    • 图片

注意

1、超时
#include “lwipopts.h”

#define LWIP_SO_RCVTIMEO                1

2、先保证能ping通

3、关于工程创建可参考
【STM32F407+CUBEMX+FreeRTOS+lwIP之UDP记录】
4、其他可参考正点原子和野火的资料

UDP

UDP1

osThreadId_t netconn_udp_TaskHandle;
const osThreadAttr_t netconn_udp_Task_attributes = {
  .name = "udp_Task",
  .stack_size = 128 * 10,
  .priority = (osPriority_t) (osPriorityNormal-1),
};
void Start_netconn_udp_Task(void *argument);


void StartDefaultTask(void *argument)
{
  /* init code for LWIP */
  MX_LWIP_Init();
  /* USER CODE BEGIN StartDefaultTask */
	taskENTER_CRITICAL();           /* 进入临界区 */
	netconn_udp_TaskHandle = osThreadNew(Start_netconn_udp_Task, 
							NULL, &netconn_udp_Task_attributes);
//	netconn_udp_server_TaskHandle = osThreadNew(Start_netconn_udp_server_Task, 
//							NULL, &netconn_udp_server_Task_attributes);
//	netconn_tcp_client_TaskHandle = osThreadNew(Start_netconn_tcp_client_Task, 
//							NULL, &netconn_tcp_client_Task_attributes);
//	netconn_tcp_server_TaskHandle = osThreadNew(Start_netconn_tcp_server_Task, 
//						NULL, &netconn_tcp_server_Task_attributes);
	taskEXIT_CRITICAL();            /* 退出临界区 */
  /* Infinite loop */
  for(;;)
  {
    osDelay(1);
  }
  /* USER CODE END StartDefaultTask */
}

void Start_netconn_udp_Task(void *argument){
	vTaskDelay(1000);
	vTaskDelay(1000);
	vTaskDelay(1000);
	#define DEST_IP_ADDR0 192
	#define DEST_IP_ADDR1 168
	#define DEST_IP_ADDR2 123
	#define DEST_IP_ADDR3 92
	#define LWIP_DEMO_RX_BUFSIZE         2000        /* 定义最大接收数据长度 */
	#define LWIP_DEMO_PORT               8083       /* 定义连接的本地端口号 */

	/* 接收数据缓冲区 */
	uint8_t g_lwip_demo_recvbuf[LWIP_DEMO_RX_BUFSIZE];
	/* 发送数据内容 */
	char *g_lwip_demo_sendbuf = "ALIENTEK DATA\r\n";
	err_t err;
	static struct netconn *udpconn;
	static struct netbuf  *sentbuf,*recvbuf;
	ip_addr_t destipaddr;
	uint32_t data_len = 0;
	struct pbuf *q;
	static ip_addr_t *addr;
	static unsigned short port;
	
	/* 第一步：创建udp控制块 */
	udpconn = netconn_new(NETCONN_UDP);
	if(udpconn != NULL){
		/* 第二步：绑定控制块、本地IP和端口 */
		err = netconn_bind(udpconn, IP_ADDR_ANY, LWIP_DEMO_PORT);
		 /*构造目的IP地址 */
		IP4_ADDR(&destipaddr, DEST_IP_ADDR0,DEST_IP_ADDR1,DEST_IP_ADDR2,DEST_IP_ADDR3);
		/* 第三步：连接或者建立对话框 */
		netconn_connect(udpconn, &destipaddr, LWIP_DEMO_PORT);  /* 连接到远端主机 */
		if(err == ERR_OK){
			while(1){
				/* 第四步：发送信息 */
				sentbuf = netbuf_new();
				netbuf_alloc(sentbuf, strlen((char *)g_lwip_demo_sendbuf));
				memcpy(sentbuf->p->payload, (void *)g_lwip_demo_sendbuf, strlen((char *)g_lwip_demo_sendbuf));
				err = netconn_send(udpconn, sentbuf);               /* 将netbuf中的数据发送出去 */

				if (err != ERR_OK)
				{
					printf("发送失败\r\n");
					netbuf_delete(sentbuf);                         /* 删除buf */
				}
				netbuf_delete(sentbuf);                             /* 删除buf */
				
				/* 第五步：接收数据 */
				netconn_recv(udpconn, &recvbuf);
				if(recvbuf != NULL){								/* 接收到数据 */
					addr = netbuf_fromaddr(recvbuf);
					port = netbuf_fromport(recvbuf);
					memset(g_lwip_demo_recvbuf, 0, LWIP_DEMO_RX_BUFSIZE); /* 数据接收缓冲区清零 */
					for (q = recvbuf->p; q != NULL; q = q->next)        /* 遍历完整个pbuf链表 */
					{
						/* 判断要拷贝到UDP_DEMO_RX_BUFSIZE中的数据是否大于UDP_DEMO_RX_BUFSIZE的剩余空间，如果大于 */
						/* 的话就只拷贝UDP_DEMO_RX_BUFSIZE中剩余长度的数据，否则的话就拷贝所有的数据 */
						if (q->len > (LWIP_DEMO_RX_BUFSIZE - data_len)) memcpy(g_lwip_demo_recvbuf + data_len, q->payload, (LWIP_DEMO_RX_BUFSIZE - data_len)); /* 拷贝数据 */
						else memcpy(g_lwip_demo_recvbuf + data_len, q->payload, q->len);

						data_len += q->len;

						if (data_len > LWIP_DEMO_RX_BUFSIZE) break;     /* 超出TCP客户端接收数组,跳出 */
					}
					data_len = 0;
					printf("%s,%d,%s\n",inet_ntoa(addr),port,g_lwip_demo_recvbuf);
					netbuf_delete(recvbuf);                             /* 删除buf */
				}
				vTaskDelay(10);
			}
		}
	}
}

UDP2

osThreadId_t netconn_udp_server_TaskHandle;
const osThreadAttr_t netconn_udp_server_Task_attributes = {
  .name = "udp_server_Task",
  .stack_size = 128 * 10,
  .priority = (osPriority_t) (osPriorityNormal-1),
};
void Start_netconn_udp_server_Task(void *argument);

void StartDefaultTask(void *argument)
{
  /* init code for LWIP */
  MX_LWIP_Init();
  /* USER CODE BEGIN StartDefaultTask */
	taskENTER_CRITICAL();           /* 进入临界区 */
//	netconn_udp_TaskHandle = osThreadNew(Start_netconn_udp_Task, 
//							NULL, &netconn_udp_Task_attributes);
	netconn_udp_server_TaskHandle = osThreadNew(Start_netconn_udp_server_Task, 
							NULL, &netconn_udp_server_Task_attributes);
//	netconn_tcp_client_TaskHandle = osThreadNew(Start_netconn_tcp_client_Task, 
//							NULL, &netconn_tcp_client_Task_attributes);
//	netconn_tcp_server_TaskHandle = osThreadNew(Start_netconn_tcp_server_Task, 
//						NULL, &netconn_tcp_server_Task_attributes);
	taskEXIT_CRITICAL();            /* 退出临界区 */
  /* Infinite loop */
  for(;;)
  {
    osDelay(1);
  }
  /* USER CODE END StartDefaultTask */
}

void Start_netconn_udp_server_Task(void *argument){
	vTaskDelay(1000);
	vTaskDelay(1000);
	vTaskDelay(1000);
	static struct netconn *conn;
	static struct netbuf *buf;
	static ip_addr_t *addr;
	static unsigned short port;
	err_t err, recv_err;
	
	conn = netconn_new(NETCONN_UDP);
	if (conn!= NULL)
	{
		err = netconn_bind(conn, IP_ADDR_ANY, 8081);
		if (err == ERR_OK)
		{
		  while (1) 
		  {
			recv_err = netconn_recv(conn, &buf);
		  
			if (recv_err == ERR_OK) 
			{
			  addr = netbuf_fromaddr(buf);
			  port = netbuf_fromport(buf);
			  netconn_connect(conn, addr, port);
			  buf->addr.addr = 0;
			  netconn_send(conn,buf);
			  netbuf_delete(buf);
			}
			vTaskDelay(10);
		  }
		}
		else
		{
		  netconn_delete(conn);
		}
	}
}

TCP

TCP client

osThreadId_t netconn_tcp_client_TaskHandle;
const osThreadAttr_t netconn_tcp_client_Task_attributes = {
  .name = "tcp_client_Task",
  .stack_size = 128 * 24,
  .priority = (osPriority_t) (osPriorityNormal-1),
};
void Start_netconn_tcp_client_Task(void *argument);

void StartDefaultTask(void *argument)
{
  /* init code for LWIP */
  MX_LWIP_Init();
  /* USER CODE BEGIN StartDefaultTask */
	taskENTER_CRITICAL();           /* 进入临界区 */
//	netconn_udp_TaskHandle = osThreadNew(Start_netconn_udp_Task, 
//							NULL, &netconn_udp_Task_attributes);
//	netconn_udp_server_TaskHandle = osThreadNew(Start_netconn_udp_server_Task, 
//							NULL, &netconn_udp_server_Task_attributes);
	netconn_tcp_client_TaskHandle = osThreadNew(Start_netconn_tcp_client_Task, 
							NULL, &netconn_tcp_client_Task_attributes);
//	netconn_tcp_server_TaskHandle = osThreadNew(Start_netconn_tcp_server_Task, 
//						NULL, &netconn_tcp_server_Task_attributes);
	taskEXIT_CRITICAL();            /* 退出临界区 */
  /* Infinite loop */
  for(;;)
  {
    osDelay(1);
  }
  /* USER CODE END StartDefaultTask */
}

void Start_netconn_tcp_client_Task(void *argument){
	vTaskDelay(1000);
	vTaskDelay(1000);
	vTaskDelay(1000);

	/* 接收数据缓冲区 */
	uint8_t g_lwip_demo_recvbuf[LWIP_DEMO_RX_BUFSIZE]; 
	/* 发送数据内容 */
	char *g_lwip_demo_sendbuf = "ALIENTEK DATA\r\n";
	
	static struct netconn *tcp_clientconn = NULL; /* TCP CLIENT网络连接结构体 */
	err_t err,recv_err;
	ip4_addr_t server_ipaddr,loca_ipaddr;
	static uint16_t server_port,loca_port;
	struct pbuf *q;
	uint32_t data_len = 0;
	
	server_port = LWIP_DEMO_PORT;
	IP4_ADDR(&server_ipaddr,DEST_IP_ADDR0,DEST_IP_ADDR1,DEST_IP_ADDR2,DEST_IP_ADDR3);   /* 构造目的IP地址 */
	
	while(1)
	{;
		tcp_clientconn = netconn_new(NETCONN_TCP);                                      /* 创建一个TCP链接 */
		/*在网之后再开服务端*/
		err = netconn_connect(tcp_clientconn,&server_ipaddr,server_port);               /* 连接服务器 */
		if (err != ERR_OK)
		{
			printf("接连失败\r\n");
			netconn_delete(tcp_clientconn);                                             /* 返回值不等于ERR_OK,删除tcp_clientconn连接 */
		}
		else if (err == ERR_OK)                                                         /* 处理新连接的数据 */
		{
			struct netbuf *recvbuf;
			tcp_clientconn->recv_timeout = 10;
			netconn_getaddr(tcp_clientconn,&loca_ipaddr,&loca_port,1);                  /* 获取本地IP主机IP地址和端口号 */
			printf("连接上服务器%d.%d.%d.%d,本机端口号为:%d\r\n",DEST_IP_ADDR0,DEST_IP_ADDR1, DEST_IP_ADDR2,DEST_IP_ADDR3,loca_port);
			while(1){
				err = netconn_write(tcp_clientconn ,g_lwip_demo_sendbuf,strlen((char*)g_lwip_demo_sendbuf),NETCONN_COPY); /* 发送tcp_server_sentbuf中的数据 */
				if (err != ERR_OK)
				{
					printf("发送失败\r\n");
				}
				recv_err = netconn_recv(tcp_clientconn,&recvbuf);
				if (recv_err == ERR_OK)            /* 接收到数据 */
				{
					taskENTER_CRITICAL();                                                    /* 进入临界区 */
					memset(g_lwip_demo_recvbuf,0,LWIP_DEMO_RX_BUFSIZE);                      /* 数据接收缓冲区清零 */
					for (q = recvbuf->p;q != NULL;q = q->next)                               /* 遍历完整个pbuf链表 */
					{
						/* 判断要拷贝到TCP_CLIENT_RX_BUFSIZE中的数据是否大于TCP_CLIENT_RX_BUFSIZE的剩余空间，如果大于 */
						/* 的话就只拷贝TCP_CLIENT_RX_BUFSIZE中剩余长度的数据，否则的话就拷贝所有的数据 */
						if (q->len > (LWIP_DEMO_RX_BUFSIZE - data_len)) 
						{
							memcpy(g_lwip_demo_recvbuf + data_len,q->payload,(LWIP_DEMO_RX_BUFSIZE - data_len));/* 拷贝数据 */
						}
						else 
						{
							memcpy(g_lwip_demo_recvbuf + data_len,q->payload,q->len);
						}
						
						data_len += q->len;
						
						if (data_len > LWIP_DEMO_RX_BUFSIZE) 
						{
							break;                  /* 超出TCP客户端接收数组,跳出 */
						}
					}
					taskEXIT_CRITICAL();            /* 退出临界区 */
					data_len = 0;                   /* 复制完成后data_len要清零 */
					printf("%s\n",g_lwip_demo_recvbuf);
					
				}
				else if (recv_err == ERR_CLSD)       /* 关闭连接 */
				{
					netconn_close(tcp_clientconn);
					netconn_delete(tcp_clientconn);
					printf("服务器%d.%d.%d.%d断开连接\r\n",DEST_IP_ADDR0,DEST_IP_ADDR1, DEST_IP_ADDR2,DEST_IP_ADDR3);
					break;
				}
				vTaskDelay(10);
			}
		}
		vTaskDelay(10);
	}
}

TCP server

osThreadId_t netconn_tcp_server_TaskHandle;
const osThreadAttr_t netconn_tcp_server_Task_attributes = {
  .name = "tcp_server_Task",
  .stack_size = 128 * 24,
  .priority = (osPriority_t) (osPriorityNormal-1),
};
void Start_netconn_tcp_server_Task(void *argument);

void StartDefaultTask(void *argument)
{
  /* init code for LWIP */
  MX_LWIP_Init();
  /* USER CODE BEGIN StartDefaultTask */
	taskENTER_CRITICAL();           /* 进入临界区 */
//	netconn_udp_TaskHandle = osThreadNew(Start_netconn_udp_Task, 
//							NULL, &netconn_udp_Task_attributes);
//	netconn_udp_server_TaskHandle = osThreadNew(Start_netconn_udp_server_Task, 
//							NULL, &netconn_udp_server_Task_attributes);
//	netconn_tcp_client_TaskHandle = osThreadNew(Start_netconn_tcp_client_Task, 
//							NULL, &netconn_tcp_client_Task_attributes);
	netconn_tcp_server_TaskHandle = osThreadNew(Start_netconn_tcp_server_Task, 
						NULL, &netconn_tcp_server_Task_attributes);
	taskEXIT_CRITICAL();            /* 退出临界区 */
  /* Infinite loop */
  for(;;)
  {
    osDelay(1);
  }
  /* USER CODE END StartDefaultTask */
}


void Start_netconn_tcp_server_Task(void *argument){
	vTaskDelay(1000);
	vTaskDelay(1000);
	vTaskDelay(1000);
	static struct netconn *tcp_serverconn = NULL; /* TCP SERVER网络连接结构体 */
	err_t     err,recv_err;
	struct netconn *newconn;
	static    ip_addr_t ipaddr;
	static    u16_t  port;
	uint8_t   remot_addr[4];
	uint32_t  data_len = 0;
	struct    pbuf *q;
	
	/* 接收数据缓冲区 */
	uint8_t g_lwip_demo_recvbuf[LWIP_DEMO_RX_BUFSIZE]; 
	/* 发送数据内容 */
	char *g_lwip_demo_sendbuf = "ALIENTEK DATA \r\n";
	
	/* 第一步：创建一个TCP控制块 */
    tcp_serverconn = netconn_new(NETCONN_TCP);                      /* 创建一个TCP链接 */
    /* 第二步：绑定TCP控制块、本地IP地址和端口号 */
    netconn_bind(tcp_serverconn,IP_ADDR_ANY,LWIP_DEMO_PORT);        /* 绑定端口 8083号端口 */
    /* 第三步：监听 */
    netconn_listen(tcp_serverconn);                                 /* 进入监听模式 */
    tcp_serverconn->recv_timeout = 10;                              /* 禁止阻塞线程 等待10ms */
tcp_star:
	while (1) 
	{
		/* 第四步：接收连接请求 */
		err = netconn_accept(tcp_serverconn,&newconn);              /* 接收连接请求 */
		if (err == ERR_OK){ 
			newconn->recv_timeout = 10;
		}
		if (err == ERR_OK)                                          /* 处理新连接的数据 */
		{ 
			struct netbuf *recvbuf;
			netconn_getaddr(newconn,&ipaddr,&port,0);               /* 获取远端IP地址和端口号 */
			
			remot_addr[3] = (uint8_t)(ipaddr.addr >> 24); 
			remot_addr[2] = (uint8_t)(ipaddr.addr>> 16);
			remot_addr[1] = (uint8_t)(ipaddr.addr >> 8);
			remot_addr[0] = (uint8_t)(ipaddr.addr);
			printf("主机%d.%d.%d.%d连接上服务器,主机端口号为:%d\r\n",remot_addr[0], remot_addr[1],remot_addr[2],remot_addr[3],port);
			
			while (1)
			{
				err = netconn_write(newconn ,g_lwip_demo_sendbuf,strlen((char*)g_lwip_demo_sendbuf),NETCONN_COPY); /* 发送g_lwip_demo_sendbuf中的数据 */

				if(err != ERR_OK)
				{
					printf("发送失败\r\n");
				}
				recv_err = netconn_recv(newconn,&recvbuf);
				if (recv_err == ERR_OK)           /* 接收到数据 */
				{ 
					taskENTER_CRITICAL();                                           /* 进入临界区 */
					memset(g_lwip_demo_recvbuf,0,LWIP_DEMO_RX_BUFSIZE);               /* 数据接收缓冲区清零 */

					for (q = recvbuf->p;q != NULL;q = q->next)                       /* 遍历完整个pbuf链表 */
					{
						/* 判断要拷贝到LWIP_DEMO_RX_BUFSIZE中的数据是否大于LWIP_DEMO_RX_BUFSIZE的剩余空间，如果大于 */
						/* 的话就只拷贝LWIP_DEMO_RX_BUFSIZE中剩余长度的数据，否则的话就拷贝所有的数据 */
						if(q->len > (LWIP_DEMO_RX_BUFSIZE-data_len))
						{
							memcpy(g_lwip_demo_recvbuf + data_len,q->payload,(LWIP_DEMO_RX_BUFSIZE - data_len));/* 拷贝数据 */
						}
						else
						{
							memcpy(g_lwip_demo_recvbuf + data_len,q->payload,q->len);
						}
						
						data_len += q->len;

						if(data_len > LWIP_DEMO_RX_BUFSIZE)
						{
							break;   /*超出TCP客户端接收数组,跳出*/
						}
					}

					taskEXIT_CRITICAL();                                /* 退出临界区 */
					data_len = 0;                                       /* 复制完成后data_len要清零 */
					
					printf("%s\n",g_lwip_demo_recvbuf);					
					netbuf_delete(recvbuf);
				}
				else if (recv_err == ERR_CLSD)                           /* 关闭连接 */
				{
					netconn_close(newconn);
					netconn_delete(newconn);
					printf("主机:%d.%d.%d.%d断开与服务器的连接\r\n",remot_addr[0], remot_addr[1],remot_addr[2],remot_addr[3]);
//					break;
					goto tcp_star;
				}
				vTaskDelay(10);
			}
		}
		vTaskDelay(10);
	}
	
	/*ST*/
//	 struct netconn *conn, *newconn;
//  err_t err, accept_err;
//  struct netbuf *buf;
//  void *data;
//  u16_t len;

//  /* Create a new connection identifier. */
//  conn = netconn_new(NETCONN_TCP);
//  
//  if (conn!=NULL)
//  {  
//    /* Bind connection to well known port number 7. */
//    err = netconn_bind(conn, NULL, 7);
//    
//    if (err == ERR_OK)
//    {
//      /* Tell connection to go into listening mode. */
//      netconn_listen(conn);
//    
//      while (1) 
//      {
//        /* Grab new connection. */
//         accept_err = netconn_accept(conn, &newconn);
//    
//        /* Process the new connection. */
//        if (accept_err == ERR_OK) 
//        {

//          while (netconn_recv(newconn, &buf) == ERR_OK) 
//          {
//            do 
//            {
//              netbuf_data(buf, &data, &len);
//				printf("%s\n",data);
//              netconn_write(newconn, data, len, NETCONN_COPY);
//          
//            } 
//            while (netbuf_next(buf) >= 0);
//          
//            netbuf_delete(buf);
//          }
//        
//          /* Close connection and discard connection identifier. */
//          netconn_close(newconn);
//          netconn_delete(newconn);
//        }
//      }
//    }
//    else
//    {
//      netconn_delete(newconn);
//    }
//  }

}

图片

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/587401.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

探索Plotly交互式数据可视化

探索Plotly交互式数据可视化

👽发现宝藏 前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住分享一下给大家。【点击进入巨牛的人工智能学习网站】。 探索Plotly交互式数据可视化 在数据科学和数据分析领域，可视化是一种强大的工具…
阅读更多...
2024年第二十一届 五一杯 （C题）大学生数学建模挑战赛 | 多目标优化问题，深度学习分析 | 数学建模完整代码解析

2024年第二十一届 五一杯 （C题）大学生数学建模挑战赛 | 多目标优化问题，深度学习分析 | 数学建模完整代码解析

DeepVisionary 每日深度学习前沿科技推送&顶会论文&数学建模与科技信息前沿资讯分享，与你一起了解前沿科技知识！ 本次DeepVisionary带来的是五一杯的详细解读： 完整内容可以在文章末尾全文免费领取&阅读！ 首先&…
阅读更多...
【20】JAVASE-网络编程【从零开始学JAVA】

【20】JAVASE-网络编程【从零开始学JAVA】

Java零基础系列课程-JavaSE基础篇 Lecture：波哥 Java 是第一大编程语言和开发平台。它有助于企业降低成本、缩短开发周期、推动创新以及改善应用服务。如今全球有数百万开发人员运行着超过 51 亿个 Java 虚拟机，Java 仍是企业和开发人员的首选开发平台。…
阅读更多...
从NoSQL到NewSQL——10年代大数据浪潮下的技术革新

从NoSQL到NewSQL——10年代大数据浪潮下的技术革新

引言 在数字化浪潮的推动下，数据库技术已成为支撑数字经济的坚实基石。腾讯云 TVP《技术指针》联合《明说三人行》特别策划的直播系列——【中国数据库前世今生】，我们将通过五期直播，带您穿越五个十年，深入探讨每个时代的数据库演…
阅读更多...
虚拟机安装与配置win7

虚拟机安装与配置win7

一、安装镜像 Windows7 64位 ed2k://|file|cn_windows_7_ultimate_with_sp1_x64_dvd_u_677408.iso|3420557312|B58548681854236C7939003B583A8078|/ 建议迅雷下载 二、VMware 安装win7 1.新创自定义虚拟机 2.默认即可 3.iso文件我们自己下载，选择一个空的磁盘 4.…
阅读更多...
服务器远程连接jupyter notebook

服务器远程连接jupyter notebook

目录 服务器远程连接jupyter notebook1、在服务器端安装notebook2、在服务器端的设置Step 1:Step 2:Step 3: 3. 在服务器端运行jupyter4、在windows 上连接远程服务器 参考资料 服务器远程连接jupyter notebook 1、在服务器端安装notebook conda install jupyter notebook 2…
阅读更多...
STM32独立看门狗，实现单片机自动重启

STM32独立看门狗，实现单片机自动重启

今天学习了一下独立看门狗，看门狗的主要作用就是防止程序中有死循环或是不知道的bug，而造成在while循环中没有及时喂狗，程序就会控制单片机重启复位，从而不至于影响程序一直不能正常工作。 其实看门狗的应用也不是很复杂&#xf…
阅读更多...
基于Spring Boot的校园闲置物品租售系统设计与实现

基于Spring Boot的校园闲置物品租售系统设计与实现

基于Spring Boot的校园闲置物品租售系统设计与实现 开发语言：Java框架：springbootJDK版本：JDK1.8数据库工具：Navicat11开发软件：eclipse/myeclipse/idea 系统部分展示 系统首页界面图，在校园闲置物品租售…
阅读更多...
＜计算机网络自顶向下＞ Internet Protocol

＜计算机网络自顶向下＞ Internet Protocol

互联网中的网络层 IP数据报格式 ver: 四个比特的版本号（IPV4 0100, IPV6 0110） headlen：head的长度（头部长度字段（IHL）指定了头部的长度，以32位字（4字节）为单位计算。这…
阅读更多...
报错Unable to install JS，且提示Unable to run npm install【鸿蒙报错已解决】

报错Unable to install JS，且提示Unable to run npm install【鸿蒙报错已解决】

文章目录 项目场景：问题描述原因分析：解决方案：此Bug解决方案总结Bug解决方案寄语项目场景： 最近遇到了这个问题，看到网上也有人在询问这个问题，实操了很多网上的解决方案发现并不能解决这个Bug，所以我在解决这个问题后，总结了自己和其他人的解决经验，进行了整理，写…
阅读更多...
基于北京迅为iTOP-RK3588大语言模型部署测试

基于北京迅为iTOP-RK3588大语言模型部署测试

人工智能（AI）领域中的大模型（Large Model）逐渐成为研究的热点。大模型，顾名思义，是指拥有海量参数和高度复杂结构的深度学习模型。它的出现，不仅推动了AI技术的突破，更为各行各业带来…
阅读更多...
目标检测——YOLOv8算法解读

目标检测——YOLOv8算法解读

作者：Ultralytics公司 代码：https://github.com/ultralytics/ultralytics YOLO系列算法解读： YOLOv1通俗易懂版解读、SSD算法解读、YOLOv2算法解读、YOLOv3算法解读、YOLOv4算法解读、YOLOv5算法解读、YOLOR算法解读、YOLOX算法解读、YOLOv6算…
阅读更多...
全栈开发之路——前端篇（1）介绍、框架确定、ide设置与项目创建

全栈开发之路——前端篇（1）介绍、框架确定、ide设置与项目创建

文章目录 前言一、前端框架React和VueReactVue 二、编译器选择和配置1.传统的下载和使用2.你可能遇到的问题1.ERR！ syscall mkdir2.vue : File C:\nodejs\node_global\vue.ps1 cannot be loaded because running scripts is disabled on3.出现乱码问题 3.运行Vue 三…
阅读更多...
汽车CAN总线技术详解

汽车CAN总线技术详解

1. 历史 2. 应用 3. 优点 4. 基础概念 5. 组成 6. 应用 7. 网关 8. 波形分析 参考文献 汽车CAN总线技术详解（100多页支持下载）
阅读更多...
礼赞劳动节，致敬劳动者。节日随想：疾笔耕耘也是一种劳动方式。

礼赞劳动节，致敬劳动者。节日随想：疾笔耕耘也是一种劳动方式。

马克思也快诞辰了206年了，恩格斯领导的第二国际通过的决议节日也迎来了134岁的生日了，我也继续在劳动的路上。 五月是值得纪念的日子，作为一名无上光荣的分子，无比仰慕崇拜的两位先驱前辈大胡子，其一 生于斯&#xff0…
阅读更多...
如何批量删除多个不同路径的文件但又保留文件夹呢

如何批量删除多个不同路径的文件但又保留文件夹呢

首先，需要用到的这个工具： 度娘网盘 提取码：qwu2 蓝奏云 提取码：2r1z 1、我准备了三个文件夹（实际操作的时候可能是上百个文件夹，无所谓），里面都放了两个图片 2、然后打开工具&am…
阅读更多...
数据链路层（计算机网络）

数据链路层（计算机网络）

0、前言 本文大多数图片都来自于 B站UP主：湖科大教书匠 的教学视频，对高军老师及其团队制作出这么优质的课程表示感谢。本文的撰写目的不是为了应试，且受限于个人水平，可能和标准答案有所出入，请自行甄别，…
阅读更多...
带宽的理解-笔记

带宽的理解-笔记

带宽的理解 带宽(频带宽度)：是指电磁波最高频率和最低频率的差值，这一段频率被称为带宽。 举例说明 人耳能听到的频率范围是20赫兹到2万赫兹。换句话说，人而只对20赫兹至2万赫兹的声音频率有反应，超出或低于这一频率范围的声音我…
阅读更多...
bun 换源 国内阿里源 npmmirror 加速下载

bun 换源 国内阿里源 npmmirror 加速下载

Github https://github.com/oven-sh/bun 版本号 bun 1.1.5 windows 安装 bun 如果本机有 nodejs 环境, 可以 npm install -g bun 安装 ( 官方把 exe 已经传到了 npm 仓库, 走的国内 npm 镜像, 下载速度会很快) 没有 nodejs, 可以用 powershell 脚本安装 具体操作 全局 …
阅读更多...
【小浩算法 cpp题解】层次遍历与BFS

【小浩算法 cpp题解】层次遍历与BFS

层次遍历与BFS 前言我的思路思路一：队列思路二 递归 我的代码运行结果 前言 二叉树的层次遍历应该是数据结构里面最基础的算法了，比较容易想到的就是用队列,刚好C的模板库里面也有queue这个数据结构，入队出队已经给我们实现好了，…
阅读更多...
最新文章

Copyright @ 2022~2023