【STM32】STM32学习笔记-USART串口手法HEX和文本数据包(29)

news2024/9/23 3:20:03

00. 目录

文章目录

    • 00. 目录
    • 01. 串口简介
    • 02. 串口收发HEX数据包接线图
    • 03. 串口收发HEX数据包示例1
    • 04. 串口收发HEX数据包示例2
    • 05. 串口收发文本数据包接线图
    • 06. 串口收发文本数据包示例
    • 07. 程序示例下载
    • 08. 附录

01. 串口简介

串口通讯(Serial Communication)是一种设备间非常常用的串行通讯方式，因为它简单便捷，因此大部分电子设备都支持该通讯方式， 电子工程师在调试设备时也经常使用该通讯方式输出调试信息。

在计算机科学里，大部分复杂的问题都可以通过分层来简化。如芯片被分为内核层和片上外设；STM32标准库则是在寄存器与用户代码之间的软件层。 对于通讯协议，我们也以分层的方式来理解，最基本的是把它分为物理层和协议层。物理层规定通讯系统中具有机械、电子功能部分的特性， 确保原始数据在物理媒体的传输。协议层主要规定通讯逻辑，统一收发双方的数据打包、解包标准。 简单来说物理层规定我们用嘴巴还是用肢体来交流，协议层则规定我们用中文还是英文来交流。

02. 串口收发HEX数据包接线图

在这里插入图片描述

03. 串口收发HEX数据包示例1

uart.h

#ifndef __UART_H__
#define __UART_H__

#include "stm32f10x.h"    

extern uint8_t recvPacket[];


void uart_init(void);

void uart_send_byte(uint8_t byte);

void uart_send_array(uint8_t *arr, uint16_t len);


void uart_send_string(char *str);

void uart_send_number(uint32_t num, uint8_t len);

void uart_printf(char *format, ...);

uint8_t uart_getRxFlag(void);


uint8_t uart_getRxData(void);

void uart_send_packet(uint8_t arr[], int len);


#endif /**/

uart.c

#include "uart.h"

#include <stdio.h>
#include <stdarg.h>

uint8_t recvData;
uint8_t recvFlag;

uint8_t recvPacket[32];

void uart_init(void)
{
	GPIO_InitTypeDef GPIO_InitStruct;
	USART_InitTypeDef USART_InitStruct;
	NVIC_InitTypeDef NVIC_InitStruct;
	
	
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);

	//GPIO初始化  PA9 TX
	GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF_PP;
	GPIO_InitStruct.GPIO_Pin = GPIO_Pin_9;
	GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStruct);
	
	//GPIO初始化  PA10 RX
	GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IPU;
	GPIO_InitStruct.GPIO_Pin = GPIO_Pin_10;
	GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStruct);

	USART_InitStruct.USART_BaudRate = 9600;
	USART_InitStruct.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
	USART_InitStruct.USART_Mode = USART_Mode_Tx | USART_Mode_Rx;
	USART_InitStruct.USART_Parity = USART_Parity_No;
	USART_InitStruct.USART_StopBits = USART_StopBits_1;
	USART_InitStruct.USART_WordLength = USART_WordLength_8b;
	
	USART_Init(USART1, &USART_InitStruct);
	
	//设置串口中断
	USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);
	
	//设置中断分组
	NVIC_InitStruct.NVIC_IRQChannel = USART1_IRQn;
	NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
	NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 1;
	NVIC_InitStruct.NVIC_IRQChannelSubPriority = 1;
	NVIC_Init(&NVIC_InitStruct);
	
	USART_Cmd(USART1, ENABLE);
}

void uart_send_byte(uint8_t byte)
{
	USART_SendData(USART1, byte);
	
	while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);
}


void uart_send_array(uint8_t *arr, uint16_t len)
{
	uint16_t i;
	for (i = 0; i < len; i++)
	{
		uart_send_byte(arr[i]);
	}
}


void uart_send_string(char *str)
{
	uint16_t i = 0;
	
	while(*(str + i) != '\0')
	{
		uart_send_byte(str[i]);
		i++;
	}
}

//x的y次方
uint32_t uart_pow(uint32_t x, uint32_t y)
{
	uint32_t result = 1;
	
	while(y)
	{
		result *= x;
		y--;
	}
	
	return result;
}

void uart_send_number(uint32_t num, uint8_t len)
{
	uint8_t i;
	for (i = 0; i < len; i++)
	{
		uart_send_byte(num / uart_pow(10, len - i - 1) % 10 + '0');
	}
	
}

int fputc(int ch, FILE *fp)
{
	uart_send_byte(ch);
	
	return ch;
}


void uart_printf(char *format, ...)
{
	char str[128];
	
	va_list arg;
	va_start(arg, format);
	vsprintf(str, format, arg);
	va_end(arg);
	
	uart_send_string(str);
}

void USART1_IRQHandler(void)
{
	static uint8_t recvState = 0;
	static uint8_t i = 0;
	
	if (USART_GetITStatus(USART1, USART_IT_RXNE) == SET)
	{
		recvData = USART_ReceiveData(USART1);
		
		//状态机
		if (0 == recvState)
		{
			if (recvData == 0xFF)
			{
				recvState = 1;
				i = 0;
			}
		}
		else if (1 == recvState)
		{
			recvPacket[i] = recvData;
			i++;
			
			if (i >= 4)
			{
				recvState = 2;
			}
		} 
		else if (2 == recvState)
		{
			if (recvData == 0xFE)
			{
				i = 0;
				recvState = 0;
				recvFlag = 1;
			}
		
		}

		
	
		USART_ClearITPendingBit(USART1, USART_IT_RXNE);
	}

}

uint8_t uart_getRxFlag(void)
{
	if (1 == recvFlag)
	{
		recvFlag = 0;
		return 1;
	}
	return 0;
}


uint8_t uart_getRxData(void)
{
	return recvData;
}


//发送HEX报文数据
void uart_send_packet(uint8_t arr[], int len)
{
	//发送报文 FF
	uart_send_byte(0xFF);
	
	
	uart_send_array(arr, len);
	
	//发送报尾
	uart_send_byte(0xFE);	
}

main.c

#include "stm32f10x.h"
#include <stdio.h>
#include "delay.h"
#include "oled.h"
#include "uart.h"


 int main(void)
 {	 
	 
	 uint8_t arr[] = {0x1, 0x2, 0x3, 0x4};
	 OLED_Init();
	 
	 uart_init();
	 
	 //中断分组
	 NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);

	 OLED_ShowChar(1, 1, 'A');

	
	 uart_send_packet(arr, 4);
		 
	 while(1)
	 {
		 if (1 == uart_getRxData())
		 {
			OLED_ShowHexNum(1, 1, recvPacket[0], 2);
			OLED_ShowHexNum(1, 4, recvPacket[1], 2);
			OLED_ShowHexNum(1, 7, recvPacket[2], 2);
			OLED_ShowHexNum(1, 10, recvPacket[3], 2);			 
		 }	 
	 }
	 
	 return 0;
 }

04. 串口收发HEX数据包示例2

uart.h

#ifndef __UART_H__
#define __UART_H__

#include "stm32f10x.h"    

extern uint8_t recvPacket[];


void uart_init(void);

void uart_send_byte(uint8_t byte);

void uart_send_array(uint8_t *arr, uint16_t len);


void uart_send_string(char *str);

void uart_send_number(uint32_t num, uint8_t len);

void uart_printf(char *format, ...);

uint8_t uart_getRxFlag(void);


uint8_t uart_getRxData(void);

void uart_send_packet(uint8_t arr[], int len);


#endif /**/

uart.c

#include "uart.h"

#include <stdio.h>
#include <stdarg.h>

uint8_t recvData;
uint8_t recvFlag;

uint8_t recvPacket[32];

void uart_init(void)
{
	GPIO_InitTypeDef GPIO_InitStruct;
	USART_InitTypeDef USART_InitStruct;
	NVIC_InitTypeDef NVIC_InitStruct;
	
	
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);

	//GPIO初始化  PA9 TX
	GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF_PP;
	GPIO_InitStruct.GPIO_Pin = GPIO_Pin_9;
	GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStruct);
	
	//GPIO初始化  PA10 RX
	GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IPU;
	GPIO_InitStruct.GPIO_Pin = GPIO_Pin_10;
	GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStruct);

	USART_InitStruct.USART_BaudRate = 9600;
	USART_InitStruct.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
	USART_InitStruct.USART_Mode = USART_Mode_Tx | USART_Mode_Rx;
	USART_InitStruct.USART_Parity = USART_Parity_No;
	USART_InitStruct.USART_StopBits = USART_StopBits_1;
	USART_InitStruct.USART_WordLength = USART_WordLength_8b;
	
	USART_Init(USART1, &USART_InitStruct);
	
	//设置串口中断
	USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);
	
	//设置中断分组
	NVIC_InitStruct.NVIC_IRQChannel = USART1_IRQn;
	NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
	NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 1;
	NVIC_InitStruct.NVIC_IRQChannelSubPriority = 1;
	NVIC_Init(&NVIC_InitStruct);
	
	USART_Cmd(USART1, ENABLE);
}

void uart_send_byte(uint8_t byte)
{
	USART_SendData(USART1, byte);
	
	while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);
}


void uart_send_array(uint8_t *arr, uint16_t len)
{
	uint16_t i;
	for (i = 0; i < len; i++)
	{
		uart_send_byte(arr[i]);
	}
}


void uart_send_string(char *str)
{
	uint16_t i = 0;
	
	while(*(str + i) != '\0')
	{
		uart_send_byte(str[i]);
		i++;
	}
}

//x的y次方
uint32_t uart_pow(uint32_t x, uint32_t y)
{
	uint32_t result = 1;
	
	while(y)
	{
		result *= x;
		y--;
	}
	
	return result;
}

void uart_send_number(uint32_t num, uint8_t len)
{
	uint8_t i;
	for (i = 0; i < len; i++)
	{
		uart_send_byte(num / uart_pow(10, len - i - 1) % 10 + '0');
	}
	
}

int fputc(int ch, FILE *fp)
{
	uart_send_byte(ch);
	
	return ch;
}


void uart_printf(char *format, ...)
{
	char str[128];
	
	va_list arg;
	va_start(arg, format);
	vsprintf(str, format, arg);
	va_end(arg);
	
	uart_send_string(str);
}

void USART1_IRQHandler(void)
{
	static uint8_t recvState = 0;
	static uint8_t i = 0;
	
	if (USART_GetITStatus(USART1, USART_IT_RXNE) == SET)
	{
		uint8_t recvData1 = USART_ReceiveData(USART1);
		
		//状态机
		if (0 == recvState)
		{
			if (recvData1 == 0xFF)
			{
				recvState = 1;
				i = 0;
			}
		}
		else if (1 == recvState)
		{
			recvPacket[i] = recvData1;
			i++;
			
			if (i >= 4)
			{
				recvState = 2;
			}
		} 
		else if (2 == recvState)
		{
			if (recvData1 == 0xFE)
			{
				recvState = 0;
				recvFlag = 1;
			}
		
		}

		
		USART_ClearITPendingBit(USART1, USART_IT_RXNE);
	}
}

uint8_t uart_getRxFlag(void)
{
	if (1 == recvFlag)
	{
		recvFlag = 0;
		return 1;
	}
	return 0;
}


uint8_t uart_getRxData(void)
{
	return recvData;
}


//发送HEX报文数据
void uart_send_packet(uint8_t arr[], int len)
{
	//发送报文 FF
	uart_send_byte(0xFF);
	
	
	uart_send_array(arr, len);
	
	//发送报尾
	uart_send_byte(0xFE);	
}

main.c

#include "stm32f10x.h"
#include <stdio.h>
#include "delay.h"
#include "oled.h"
#include "uart.h"
#include "key.h"


 int main(void)
 {	 
	 
	 uint8_t arr[] = {0x1, 0x2, 0x3, 0x4};

	 

	 
	 //中断分组
	 NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);

	 key_init();
	 
	 uart_init();
	 
	OLED_Init();
	 
	 
	 OLED_ShowString(1, 1, "TxPacket");
	 OLED_ShowString(3, 1, "RxPacket");

 
	 while(1)
	 {
		 if (1 == key_scan())
		 {
			arr[0]++;
			arr[1]++; 
			arr[2]++;
			arr[3]++;
			 
			uart_send_packet(arr, 4); 
			
			OLED_ShowHexNum(2, 1, arr[0], 2);
			OLED_ShowHexNum(2, 4, arr[1], 2);
			OLED_ShowHexNum(2, 7, arr[2], 2);
			OLED_ShowHexNum(2, 10, arr[3], 2);			 
		 } 
		 if (1 == uart_getRxData())
		 {
			OLED_ShowHexNum(4, 1, recvPacket[0], 2);
			OLED_ShowHexNum(4, 4, recvPacket[1], 2);
			OLED_ShowHexNum(4, 7, recvPacket[2], 2);
			OLED_ShowHexNum(4, 10, recvPacket[3], 2);			 
		 }	 
	 }
	 
	 return 0;
 }

05. 串口收发文本数据包接线图

在这里插入图片描述

06. 串口收发文本数据包示例

uart.h

#ifndef __SERIAL_H
#define __SERIAL_H

#include <stdio.h>

extern uint8_t Serial_TxPacket[];
extern uint8_t Serial_RxPacket[];
extern uint8_t Serial_RxFlag;

void Serial_Init(void);
void Serial_SendByte(uint8_t Byte);
void Serial_SendArray(uint8_t *Array, uint16_t Length);
void Serial_SendString(char *String);
void Serial_SendNumber(uint32_t Number, uint8_t Length);
void Serial_Printf(char *format, ...);

void Serial_SendPacket(void);


#endif

uart.c

#include "stm32f10x.h"                  // Device header
#include <stdio.h>
#include <stdarg.h>


uint8_t Serial_TxPacket[4];				//FF 01 02 03 04 FE
char Serial_RxPacket[100];
uint8_t Serial_RxFlag;

void Serial_Init(void)
{
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
	
	GPIO_InitTypeDef GPIO_InitStructure;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStructure);
	
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStructure);
	
	USART_InitTypeDef USART_InitStructure;
	USART_InitStructure.USART_BaudRate = 9600;
	USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
	USART_InitStructure.USART_Mode = USART_Mode_Tx | USART_Mode_Rx;
	USART_InitStructure.USART_Parity = USART_Parity_No;
	USART_InitStructure.USART_StopBits = USART_StopBits_1;
	USART_InitStructure.USART_WordLength = USART_WordLength_8b;
	USART_Init(USART1, &USART_InitStructure);
	
	USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);
	
	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
	
	NVIC_InitTypeDef NVIC_InitStructure;
	NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
	NVIC_Init(&NVIC_InitStructure);
	
	USART_Cmd(USART1, ENABLE);
}

void Serial_SendByte(uint8_t Byte)
{
	USART_SendData(USART1, Byte);
	while (USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);
}

void Serial_SendArray(uint8_t *Array, uint16_t Length)
{
	uint16_t i;
	for (i = 0; i < Length; i ++)
	{
		Serial_SendByte(Array[i]);
	}
}

void Serial_SendString(char *String)
{
	uint8_t i;
	for (i = 0; String[i] != '\0'; i ++)
	{
		Serial_SendByte(String[i]);
	}
}

uint32_t Serial_Pow(uint32_t X, uint32_t Y)
{
	uint32_t Result = 1;
	while (Y --)
	{
		Result *= X;
	}
	return Result;
}

void Serial_SendNumber(uint32_t Number, uint8_t Length)
{
	uint8_t i;
	for (i = 0; i < Length; i ++)
	{
		Serial_SendByte(Number / Serial_Pow(10, Length - i - 1) % 10 + '0');
	}
}

int fputc(int ch, FILE *f)
{
	Serial_SendByte(ch);
	return ch;
}

void Serial_Printf(char *format, ...)
{
	char String[100];
	va_list arg;
	va_start(arg, format);
	vsprintf(String, format, arg);
	va_end(arg);
	Serial_SendString(String);
}


void Serial_SendPacket(void)
{
	Serial_SendByte(0xFF);
	Serial_SendArray(Serial_TxPacket, 4);
	Serial_SendByte(0xFE);
}


void USART1_IRQHandler(void)
{
	static uint8_t RxState = 0;
	static uint8_t pRxPacket = 0;
	if (USART_GetITStatus(USART1, USART_IT_RXNE) == SET)
	{
		uint8_t RxData = USART_ReceiveData(USART1);
		
		if (RxState == 0)
		{
			if (RxData == '@' && 0 == Serial_RxFlag)
			{
				RxState = 1;
				pRxPacket = 0;
			}
		}
		else if (RxState == 1)
		{

			if (RxData == '\r')
			{
				RxState = 2;
				
			}
			else
			{
				Serial_RxPacket[pRxPacket] = RxData;
				pRxPacket ++;
			}
		}
		else if (RxState == 2)
		{
			if (RxData == '\n')
			{
				RxState = 0;
				Serial_RxPacket[pRxPacket] = '\0';
				Serial_RxFlag = 1;
			}
		}
		
		USART_ClearITPendingBit(USART1, USART_IT_RXNE);
	}
}

main.c

#include "stm32f10x.h"                  // Device header
#include "Delay.h"
#include "OLED.h"
#include "Serial.h"
#include "LED.h"

#include <string.h>

int main(void)
{
	OLED_Init();
		LED_Init();
	Serial_Init();

	
	OLED_ShowString(1, 1, "TxPacket");
	OLED_ShowString(3, 1, "RxPacket");
	
	
	while (1)
	{
		
		if (Serial_RxFlag == 1)
		{
			OLED_ShowString(4, 1, "                     ");
			OLED_ShowString(4, 1, Serial_RxPacket);
			
			if (strcmp(Serial_RxPacket, "LED_ON") == 0)
			{
				LED1_ON();
				OLED_ShowString(2, 1, "                     ");
				OLED_ShowString(2, 1, "LED_ON_OK");
				Serial_SendString("LED_ON_OK\r\n");
			}
			else if (strcmp(Serial_RxPacket, "LED_OFF") == 0)
			{
				LED1_OFF();
				OLED_ShowString(2, 1, "                     ");
				OLED_ShowString(2, 1, "LED_OFF_OK");	
				Serial_SendString("LED_OFF_OK\r\n");				
			}
			else
			{
				OLED_ShowString(2, 1, "                     ");
				OLED_ShowString(2, 1, "ERROR_COMMAND");	
				Serial_SendString("ERROR_COMMAND\r\n");				
			}
			
			Serial_RxFlag = 0;
		}
	}
}

07. 程序示例下载

24-UART收发HEX数据包

25-UART收发HEX数据包2.rar

26-UART收发文本数据包.rar

08. 附录

参考: 【STM32】江科大STM32学习笔记汇总

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

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

相关文章

高精度彩色3D相机：开启崭新的彩色3D成像时代

高精度彩色3D相机：开启崭新的彩色3D成像时代

3D成像的新时代 近年来&#xff0c;机器人技术的快速发展促使对3D相机技术的需求不断增加&#xff0c;原因在于&#xff0c;相机在提高机器人的性能和实现多种功能方面发挥了决定性作用。然而&#xff0c;其中许多应用所需的解决方案更复杂&#xff0c;仅提供环境的深度信息是…
阅读更多...
【LeetCode】142. 环形链表 II（中等）——代码随想录算法训练营Day04

【LeetCode】142. 环形链表 II（中等）——代码随想录算法训练营Day04

题目链接&#xff1a;142. 环形链表 II 题目描述 给定一个链表的头节点 head &#xff0c;返回链表开始入环的第一个节点。 如果链表无环&#xff0c;则返回 null。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了…
阅读更多...
Docker 介绍 及 支持的操作系统

Docker 介绍 及 支持的操作系统

Docker组成&#xff1a; Docker主机(Host)&#xff1a; 一个物理机或虚拟机, 用于运行Docker服务进程和容器, 也成为宿主机, node节点。 Docker服务器端(Server)&#xff1a; Docker守护进程, 运行Docker容器。 Docker客户端(Client)&#xff1a; 客户端使用docker命令或其他工…
阅读更多...
层叠布局（Stack）

层叠布局（Stack）

目录 1、概述 2、开发布局 3、对齐方式 3.1、TopStart 3.2、Top 3.3、TopEnd 3.4、Start 3.5、Center 3.6、End 3.7、BottomStart 3.8、Bottom 3.9、BottomEnd 4、Z序控制 5、场景示例 1、概述 层叠布局&#xff08;StackLayout&#xff09;用于在屏幕上预留一…
阅读更多...
Linux的SSH服务

Linux的SSH服务

一.SSH服务简介 1.什么是SSH SSH&#xff08;Secure Shell&#xff09;是一种安全通道协议&#xff0c;主要用来实现字符界面的远程登录、远程复制等功能。SSH 协议对通信双方的数据传输进行了加密处理&#xff0c;其中包括用户登录时输入的用户口令&#xff0c;SSH 为建立在应…
阅读更多...
Elasticsearch：Search tutorial - 使用 Python 进行搜索 （四）

Elasticsearch：Search tutorial - 使用 Python 进行搜索 （四）

在本节中&#xff0c;你将了解另一种机器学习搜索方法&#xff0c;该方法利用 Elastic Learned Sparse EncodeR 模型或 ELSER&#xff0c;这是一种由 Elastic 训练来执行语义搜索的自然语言处理模型。这是继之前的文章 “Elasticsearch&#xff1a;Search tutorial - 使用 Pyth…
阅读更多...
NeRF算法模型简析：从理论到实践的轻度解析以及如何编辑和微调

NeRF算法模型简析：从理论到实践的轻度解析以及如何编辑和微调

nerf模型可编辑的&#xff1f; NeRF模型的可编辑性&#xff08;editability&#xff09;指的是能够修改预训练的NeRF模型以改变其生成的场景或对象的某些特征&#xff0c;而不是从头开始重新训练模型。这种编辑可以是改变颜色、形状、纹理或者添加、移除和修改场景中的对象。 在…
阅读更多...
在CentOS上设置和管理静态HTTP网站的版本控制

在CentOS上设置和管理静态HTTP网站的版本控制

在CentOS上设置和管理静态HTTP网站的版本控制是一项重要的任务&#xff0c;它可以帮助您跟踪和回滚对网站所做的更改&#xff0c;确保数据的一致性和完整性。以下是在CentOS上设置和管理静态HTTP网站的版本控制的步骤&#xff1a; 安装版本控制系统在CentOS上安装Git或其他版本…
阅读更多...
LeetCode讲解篇之78. 子集

LeetCode讲解篇之78. 子集

文章目录 题目描述题解思路题解代码 题目描述 题解思路 初始化一个start变量记录当前从哪里开始遍历搜索nums 搜索过程的数字组合加入结果集 然后从start下标开始遍历nums&#xff0c;更新start&#xff0c;递归搜索 直到搜索完毕&#xff0c;返回结果集 题解代码 class …
阅读更多...
记录用python封装的第一个小程序

记录用python封装的第一个小程序

前言 我要封装的是前段时间复现的一个视频融合拼接的程序&#xff0c;现在我打算将他封装成exe程序&#xff0c;我在这里只记录一下我封装的过程&#xff0c;使用的是pyinstaller&#xff0c;具体的封装知识我就不多说了&#xff0c;可以参考我另一篇博客&#xff1a;将Python…
阅读更多...
逼格满满，推荐一个高效测试用例工具：XMind2TestCase ！

逼格满满，推荐一个高效测试用例工具：XMind2TestCase ！

一、背景 软件测试的核心是什么&#xff1f;毫无疑问是测试分析和测试用例设计&#xff0c;也是日常测试投入最多时间的工作内容之一。 然而&#xff0c;传统的测试用例设计过程有很多痛点&#xff1a; 1、使用Excel表格进行测试用例设计&#xff0c;虽然成本低&#xff0c;但…
阅读更多...
POI：对Word的基本操作

POI：对Word的基本操作

1 向word中写入文本并设置样式 package com.example;import org.apache.poi.xwpf.usermodel.*;import java.io.File; import java.io.FileOutputStream;/*** Author&#xff1a;xiexu* Date&#xff1a;2024/1/12 23:54*/ public class WriteWord {static String PATH "…
阅读更多...
Linux（Ubantu）交叉编译生成windows(32位,64位)可执行程序和库

Linux（Ubantu）交叉编译生成windows(32位,64位)可执行程序和库

机缘 机缘巧合下收到了这个小任务. 工作流 先是找了下资料发现过去的都是关于mingw32. 教程的做法: 增加个源 (trusty 是linux发行的版本标识,比如22.04是jammy deb http://us.archive.ubuntu.com/ubuntu trusty main universe更新源 sudo apt update下载mingw32. sudo…
阅读更多...
阅读笔记lv.1

阅读笔记lv.1

阅读笔记 sql中各种 count结论不同存储引擎计算方式区别count() 类型 责任链模式常见场景例子&#xff08;闯关游戏&#xff09; sql中各种 count 结论 innodb count(*) ≈ count(1) > count(主键id) > count(普通索引列) > count(未加索引列)myisam 有专门字段记录…
阅读更多...
通过shell脚本确定当前平台

通过shell脚本确定当前平台

shell中的变量OSTYPE存储操作系统的名称&#xff0c;也可以使用uname命令来确认当前所在的平台。 shell中的变量HOSTTYPE存储操作系统的架构。 测试代码如下所示&#xff1a; #! /bin/bashecho "use OSTYPE:" if [[ "$OSTYPE" "linux-gnu&quo…
阅读更多...
java大学生宿舍共享厨房系统宿舍自习室宿舍洗衣房系统源码包含技术文档

java大学生宿舍共享厨房系统宿舍自习室宿舍洗衣房系统源码包含技术文档

主要功能&#xff1a;学生可注册登录&#xff0c;预约自己宿舍楼栋的共享厨房和评价&#xff0c;也可以使用该楼栋的洗衣房&#xff0c;查看洗衣机吹风机的使用情况和报修&#xff0c;还可以进入该楼栋自习室打卡和评价。管理员可管理所有的学生和宿管&#xff0c;分配宿舍&…
阅读更多...
MYSQL的操作

MYSQL的操作

1.库的操作 1.1创建数据库 语法&#xff1a; CREATE DATABASE [IF NOT EXISTS] db_name [create_specification [, create_specification] ...] create_specification: [DEFAULT] CHARACTER SET charset_name [DEFAULT] COLLATE collation_name 说明&#xff1a; #…
阅读更多...
GitHub项目推荐-incubator

GitHub项目推荐-incubator

项目地址 Github地址&#xff1a;GitHub - apache/incubator-anser 官网&#xff1a;Apache Answer | Free Open-source Q&A Platform 项目简述 这是Apache的一个开源在线论坛&#xff0c;也可以部署成为一个自有的QA知识库。项目主要使用了Go和Typescript来开发&#…
阅读更多...
Feature Fusion for Online Mutual KD

Feature Fusion for Online Mutual KD

paper&#xff1a;Feature Fusion for Online Mutual Knowledge Distillation official implementation&#xff1a;https://github.com/Jangho-Kim/FFL-pytorch 本文的创新点 本文提出了一个名为特征融合学习&#xff08;Feature Fusion Learning, FFL&#xff09;的框架&…
阅读更多...
设计模式—— 单例设计模式

设计模式—— 单例设计模式

单例设计模式 什么是单例模式 单例模式是一种对象创建型模式&#xff0c;使用单例模式&#xff0c;可以保证为一个类只生成唯一的实例对象。也就是说&#xff0c;在整个程序空间中&#xff0c;该类只存在一个实例对象。 为什么使用单例模式 在应用系统开发中&#xff0c;我…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023