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

news2024/11/16 21:30:23

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);
//    }
//  }

}

图片

在这里插入图片描述

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

NLP 笔记：TF-IDF

NLP 笔记：TF-IDF

TF-IDF（Term Frequency-Inverse Document Frequency，词频-逆文档频率）是一种用于信息检索和文本挖掘的统计方法，用来评估一个词在一组文档中的重要性。TF-IDF的基本思想是，如果某个词在一篇文档中出现频率高&#xff0…
阅读更多...
使用Python的Tkinter库创建你的第一个桌面应用程序

使用Python的Tkinter库创建你的第一个桌面应用程序

文章目录 准备工作创建窗口和按钮代码解释运行你的应用程序结论 在本教程中，我们将介绍如何使用Python的Tkinter库创建一个简单的桌面应用程序。我们将会创建一个包含一个按钮的窗口，点击按钮时会在窗口上显示一条消息。 准备工作 首先，确保…
阅读更多...
图片懒加载：提升网页性能的秘诀

图片懒加载：提升网页性能的秘诀

🤍 前端开发工程师、技术日更博主、已过CET6 🍨 阿珊和她的猫_CSDN博客专家、23年度博客之星前端领域TOP1 🕠 牛客高级专题作者、打造专栏《前端面试必备》 、《2024面试高频手撕题》 🍚 蓝桥云课签约作者、上架课程《Vue.js 和 E…
阅读更多...
Python-Socket编程实现tcp-udp通信

Python-Socket编程实现tcp-udp通信

本文章是记录我准备大创项目时学的socket编程的用法，纯属记录生活，没有教学意义，视频我是看b站up主王铭东学的，讲的很详细，我只粗略学了个大概，我想要通过tcp，udp传输yolo目标检测中的物体坐标信…
阅读更多...
QT：按钮类控件

QT：按钮类控件

文章目录 PushButton快捷键Radio Buttion PushButton 这个类继承自QAbstractButton，是所有按钮的父类 创建一个带有图标的按钮： 假设这个图片是这个 那么我们就可以创建按钮并进行设置了： #include "widget.h" #include "u…
阅读更多...
net lambda 、 匿名函数 以及集合（实现IEnumerable的 如数组 、list等）

net lambda 、 匿名函数 以及集合（实现IEnumerable的 如数组 、list等）

匿名函数：》》》 Action a1 delegate(int i) { Console.WriteLine(i); }; Lambda:>>> Aciont a1 (int i) > { Console.WriteLine(i); }; 可以简写 （编译器会自动根据委托类型 推断） Action a1 （i）> {…
阅读更多...
图像处理的一些操作（1）

图像处理的一些操作（1）

图像处理 1.安装PIL，skimage库1.1导入skimage库中的oi模块和data模块 2.读取图像文件2.1读取图像文件2.2 以灰度模式读取图像2.3 查看示例图像的目录路径2.4 读取chelsea图片2.5 加载示例图片并保存2.6 获得加载图片的信息2.6.1 输出图片类型2.6.2 输出图片尺寸2.6.…
阅读更多...
linux 光驱（光盘）安装

linux 光驱（光盘）安装

文章目录 自带 YUM 库创建 repo创建文件夹挂载光驱开机自启动挂载安装软件YUM 安装RPM 安装 自带 YUM 库 ls /etc/yum.repos.d创建 repo vim /etc/yum.repo.d/demo.repo // 编写 repo 相关配置 [demo] namedemo baseurlfile:///mnt/cdrom gpkcheck0创建文件夹挂载光驱 /dev/…
阅读更多...
黑马点评项目个人笔记+项目优化调整

黑马点评项目个人笔记+项目优化调整

博客须知 本篇博客内容来源与黑马点评项目实战篇-16.用户签到-实现签到功能_哔哩哔哩_bilibili，作者对视频内容进行了整合，由于记笔记时图片使用的是本地路径，所以导致博客的图片无法正常显示，如果有图片需求可以下载上方的pdf须…
阅读更多...
【介绍下大数据组件之Storm】

【介绍下大数据组件之Storm】

🎥博主：程序员不想YY啊 💫CSDN优质创作者，CSDN实力新星，CSDN博客专家 🤗点赞🎈收藏⭐再看💫养成习惯 ✨希望本文对您有所裨益，如有不足之处，欢迎在评论区提出…
阅读更多...
树莓派点亮LED灯

树莓派点亮LED灯

简介 使用GPIO Zero library 的 Python库实现点亮LED灯。接线 树莓派引脚参考图如下： LED正极 接GPIO17 LED负极 接GND 权限 将你的用户加到gpio组中， 否则无法控制GPIO sudo usermod -a -G gpio 代码 from gpiozero import LED from time impor…
阅读更多...
PhpAdmin-getshell

PhpAdmin-getshell

PhpAdmin-getshell 通过未授权成功写入，然后getshell 路径：C:\phpstudy_pro\Extensions\MySQL5.7.26\ 写入木马： into写入文件： 使用需看要secure_file_priv的值。 当value为“null”时，不允许读取任意文件 当value为…
阅读更多...
VS Code工具将json数据格式化

VS Code工具将json数据格式化

诉求：json数据格式化应该在工作中用到的地方特别多，为了更方便、更仔细的对json数据查看，将json数据格式化是非常有必要的。 VS Code中如何将json数据快速格式化 1、在VS Code中安装Beautify JSON插件 2、安装完后在需要格式化的文件中按住…
阅读更多...
pyqt拖入图片并显示

pyqt拖入图片并显示

pyqt拖入图片并显示 介绍效果代码 介绍 像拖入文本一样，把图片拖入到窗体中显示。 效果 代码 import sys from PyQt5.QtWidgets import QApplication, QWidget, QLabel, QVBoxLayout from PyQt5.QtGui import QPixmap, QDragEnterEvent, QDropEvent from PyQt5.Q…
阅读更多...
Co-assistant Networks for Label Correction论文速读

Co-assistant Networks for Label Correction论文速读

文章目录 Co-assistant Networks for Label Correction摘要方法Noise DetectorNoise Cleaner损失函数 实验结果 Co-assistant Networks for Label Correction 摘要 问题描述： 描述医学图像数据集中存在损坏标签的问题。强调损坏标签对深度神经网络性能的影响。 提…
阅读更多...
基于springboot实现迪迈手机商城设计系统项目【项目源码+论文说明】

基于springboot实现迪迈手机商城设计系统项目【项目源码+论文说明】

基于springboot实现迪迈手机商城设计系统演示 研究背景 当前社会各行业领域竞争压力非常大，随着当前时代的信息化，科学化发展，让社会各行业领域都争相使用新的信息技术，对行业内的各种相关数据进行科学化，规范化管理。…
阅读更多...
53.HarmonyOS鸿蒙系统 App(ArkTS) socket套接字连接失败无效参数--invalid argument

53.HarmonyOS鸿蒙系统 App(ArkTS) socket套接字连接失败无效参数--invalid argument

ark ts socket套接字连接失败无效参数--invalid argument 绑定本机真实连接的WIFI的IP，不要绑定127.0.0.1
阅读更多...
【树——数据结构】

【树——数据结构】

文章目录 1.基本概念2.基本术语1.结点之间的关系描述2.结点，树的属性描述3.有序树，无序树4.森林 3.树的性质考点1考点2考点3考点4 4.树的存储结构5.树和森林的遍历 1.基本概念 结点，根节点，分支结点，叶子结点&#xf…
阅读更多...
民航电子数据库：mysql与cae（insert语法差异）

民航电子数据库：mysql与cae（insert语法差异）

目录 示例1、cae插入数据时不支持value关键字，只能使用values2、insert时，就算是自增主键，只要新增时包含了主键，该主键就必须有值，否则会报错：字段xxx不能取空值 对接民航电子数据库，本篇记录i…
阅读更多...
php反序列化以及相关例题

php反序列化以及相关例题

目录 一、什么是序列化和反序列化？ 二、相关函数 serialize()函数： unserialize()函数：反序列化 三、PHP序列化格式 四、序列化与反序列化的作用 五、各种数据类型序列化后的效果 六、魔术方法 七、反序列化的一些绕过 八…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023