32f4，usart2fifo,2025

news2025/4/22 22:45:12

usart2fifo.h

#ifndef __USART2FIFO_H
#define __USART2FIFO_H

#include "stdio.h"	
#include "stm32f4xx_conf.h"
#include "sys.h" 
#include "fifo_usart2.h"


//extern u8 RXD2_TimeOut;//超时检测

//extern u8 Timer6_1ms_flag;


extern __IO bool Usart2_rxFrameFlag ;
extern __IO uint8_t Usart2_rxCmd[USART2_FIFO_SIZE] ;
extern __IO uint8_t Usart2_rxCount ;
//********************************************************************************
#define USART2_REC_LEN  			   256  	     //定义最大接收字节数 200
#define DIY_END_CODE_Before      0x0D  //每次发送的帧尾\n
#define DIY_END_CODE             0x0A  //每次发送的帧尾\n


extern u8  USART2_RX_BUF[USART2_FIFO_SIZE]; //接收缓冲,最大USART_REC_LEN个字节.末字节为换行符 
extern u16   USART2_RX_STA;         		//接收状态标记	

extern  u16    USART2_Rec_Byte_Length;//接收长度，最大是200，在接收数组空间范围内？
extern  u8     USART2_Rec_Frame_Flag;//接收完整一帧标记=0,没接收完，=1接收完

void uart2_init(u32 baudRate);//设置串口1的波特率，以及初始化
void Clear_Uart2_RecBuf(void);//清空接收缓冲区
u8 Judge_Usart2_Response(char* fmt,...);//判断串口1接受到的字符串，比对
//if(Judge_Usart1_Response("OK"))只要存在OK连续两个就行，分大小写
//uyyOKoo
//https://www.cnblogs.com/zhanxiaohong0303/p/zz_2020_10_1.html
//将按照指定格式接收的数据赋值
u8 Get_Usart2_Data(int *x,float *y);
u8 Get_Usart2_Data2(float *x,float *y);

u8 Get_Usart2_S1(float *x);//旋转舵机
u8 Get_Usart2_S2(float *x);//爪子舵机
u8 Get_Usart2_S7(float *x);//步进电机

#endif

usart2fifo.c

#include "sys.h"
#include "usart2FIFO.h"	
#include "led.h"	
#include "stdlib.h"
#include "stdarg.h"
#include "stdio.h"
 	
#include "fifo_usart2.h"


__IO bool Usart2_rxFrameFlag = false;
__IO uint8_t Usart2_rxCmd[USART2_FIFO_SIZE] = {0};
__IO uint8_t Usart2_rxCount = 0;


//u8 RXD2_TimeOut=0;//超时检测
//u8 Timer6_1ms_flag=0;
//注意,读取USARTx->SR能避免莫名其妙的错误   	
u8 USART2_RX_BUF[USART2_FIFO_SIZE];     //接收缓冲,最大USART_REC_LEN个字节.
//接收状态
//bit15，	接收完成标志
//bit14，	接收到0x0d
//bit13~0，	接收到的有效字节数目
u16 USART2_RX_STA=0;       //接收状态标记	
u16 USART2_Rec_Byte_Length=0;//接收长度，最大是200，在接收数组空间范围内？
u8  USART2_Rec_Frame_Flag=0;//接收完整一帧标记
			
			
			
			
			
			
			
//初始化IO 串口1 
//bound:波特率
void uart2_init(u32 baudRate)
{
   //GPIO端口设置
  GPIO_InitTypeDef     GPIO_InitStructure;
	USART_InitTypeDef    USART_InitStructure;
	
	RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD,ENABLE); //使能GPIOD时钟
	RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2,ENABLE);//使能USART1时钟
 
	//串口1对应引脚复用映射
	GPIO_PinAFConfig(GPIOD,GPIO_PinSource5,GPIO_AF_USART2); //GPIO5复用为USART2
GPIO_PinAFConfig(GPIOD,GPIO_PinSource6,GPIO_AF_USART2); //GPIO6复用为USART2
	
	//USART1端口配置
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5 | GPIO_Pin_6; //GPIOA9与GPIOA10
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;//复用功能
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;	//速度50MHz
	GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; //推挽复用输出
	GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP; //上拉
	GPIO_Init(GPIOD,&GPIO_InitStructure); //初始化PA9，PA10

   //USART1 初始化设置
	USART_InitStructure.USART_BaudRate = baudRate;//波特率设置
	USART_InitStructure.USART_WordLength = USART_WordLength_8b;//字长为8位数据格式
	USART_InitStructure.USART_StopBits = USART_StopBits_1;//一个停止位
	USART_InitStructure.USART_Parity = USART_Parity_No;//无奇偶校验位
	USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件数据流控制
	USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;	//收发模式
 
 USART_Init(USART2, &USART_InitStructure); //初始化串口2
	
	
	  USART_ClearFlag(USART2, USART_FLAG_TC);
		USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);//开启相关中断，接收一个字节，就发生中断
	
	   USART_ITConfig(USART2, USART_IT_IDLE, ENABLE);//开启空闲中断
	   USART_ITConfig(USART2, USART_IT_ORE_RX, ENABLE);//开启空闲中断

		  USART_Cmd(USART2, ENABLE);  //使能串口2

}

void USART2_IRQHandler(void)                	//串口2中断服务程序
{
		__IO uint16_t i = 0;

	//接收中断(接收到的数据必须是0x0a结尾)
	if(USART_GetITStatus(USART2, USART_IT_RXNE) != RESET)  
	{
				// 未完成一帧数据接收，数据进入缓冲队列
				usart2_fifo_enQueue((uint8_t)USART2->DR);

				// 清除串口接收中断
				USART_ClearITPendingBit(USART2, USART_IT_RXNE);
	}
		
	
/**********************************************************
***	串口空闲中断
**********************************************************/
	else if(USART_GetITStatus(USART2, USART_IT_IDLE) != RESET)
	{
		// 先读SR再读DR，清除IDLE中断
		USART2->SR; USART2->DR;

		// 提取一帧数据命令
		Usart2_rxCount = usart2_fifo_queueLength(); //获取数据长度
   for(i=0; i < Usart2_rxCount; i++) 
   { 
	    Usart2_rxCmd[i] = usart2_fifo_deQueue();//拆解数据
			//printf("response data=%x\r\n",Usart2_rxCmd[i]);
	 }
	 
		// 一帧数据接收完成，置位帧标志位
		Usart2_rxFrameFlag = true;
	}

//溢出中断
  else if(USART_GetITStatus(USART2,USART_IT_ORE))
	{
			  USART_ClearFlag(USART2, USART_FLAG_ORE);
		USART_ReceiveData(USART2);
	}		
} 




void Clear_Uart2_RecBuf(void)//清空接收缓冲区
{
	u16 i;

	for(i=0;i<USART2_FIFO_SIZE;i++)
	{
		Usart2_rxCmd[i]=0;
	}
	USART2_Rec_Byte_Length=0;
	Usart2_rxFrameFlag=0;
}

//#include "stdlib.h"
//#include "stdarg.h"
//#include "stdio.h"  
//#include "string.h"  //str函数
//带不定长度参数的函数if(Judge_Usart1_Response("OK9999"))
u8 Judge_Usart2_Response(char* fmt,...)
{
	char p[USART2_FIFO_SIZE];
	va_list ap;
	//如果串口1没接收到一帧数据，那么返回0，结束本函数
	if(!Usart2_rxFrameFlag) return 0;
  //如果接收到一帧数据，到下面将需要判断的数据数据复制到p数组中
	va_start(ap,fmt);
	vsprintf((char*)p,fmt,ap);
	va_end(ap); //结束ap指针，必须结束
	//用strstr函数，将接收到的字符串和我们的数据进行对比，如果没有相等的那么返回0并结束函数，否则返回1说明判断有效
	if(strstr((char*)Usart2_rxCmd,p)==NULL) return 0;
	else return 1;
}


//获取指定格式字符串的部分数据
u8 Get_Usart2_Data(int *x,float *y)
{
	int xtemp;
	float ytemp;
	
	if(!Usart2_rxFrameFlag) return 0;
	//x=125,y=25.65\r\n
	sscanf((const char *)Usart2_rxCmd,"x1=%d,y=%f",&xtemp,&ytemp);
	*x=(int)xtemp;
	*y=(float)ytemp;
	return 1;
}

//获取指定格式字符串的部分数据
u8 Get_Usart2_Data2(float *x,float *y)
{
	float  xtemp;
	float ytemp;
	
	if(!Usart2_rxFrameFlag) return 0;
	//x=125,y=25.65\r\n
	if(Usart2_rxCmd[0]=='x' && Usart2_rxCmd[1]=='2')
	{
		sscanf((const char *)Usart2_rxCmd,"x2=%f,y=%f",&xtemp,&ytemp);
		*x=(float)xtemp;
		*y=(float)ytemp;
		return 1;
	}
	else return 0;

}
//https://www.cnblogs.com/zhanxiaohong0303/p/zz_2020_10_1.html

//获取指定格式字符串的部分数据
u8 Get_Usart2_S1(float *x)
{
	float xtemp;
//	if(!USART2_Rec_Frame_Flag) return 0;
	if(Usart2_rxCmd[0]=='t'&&Usart2_rxCmd[1]=='2')
	{
		sscanf((const char *)Usart2_rxCmd,"t2=%f",&xtemp);
		*x=(float)xtemp;	
		return 1;
	}
	else	return 0;
}
u8 Get_Usart2_S2(float *x)
{
	float xtemp;
	
//	if(!USART2_Rec_Frame_Flag) return 0;
	if(Usart2_rxCmd[0]=='t'&&Usart2_rxCmd[1]=='3')
	{
		sscanf((const char *)Usart2_rxCmd,"t3=%f",&xtemp);
		*x=(float)xtemp;
		return 1;
	}
	else	return 0;

}

u8 Get_Usart2_S7(float *x)
{
	float xtemp;
	if(Usart2_rxCmd[0]=='t'&&Usart2_rxCmd[1]=='7')
	{
			sscanf((const char *)Usart2_rxCmd,"t7=%f",&xtemp);
		*x=(float)xtemp;
		return 1;
	}
	else	return 0;
//	if(!USART2_Rec_Frame_Flag) return 0;

}
//*******************************
//int main(void)
//{ 
// 
//	u8 t;
//	u8 len;	
//	u16 times=0;  
//	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//设置系统中断优先级分组2
//	delay_init(168);		//延时初始化 
//	uart_init(115200);	//串口初始化波特率为115200
//	LED_Init();		  		//初始化与LED连接的硬件接口  
//	while(1)
//	{
//		if(USART_RX_STA&0x8000)
//		{					   
//			len=USART_RX_STA&0x3fff;//得到此次接收到的数据长度
//			printf("\r\n您发送的消息为:\r\n");
//			for(t=0;t<len;t++)
//			{
//				USART_SendData(USART1, USART_RX_BUF[t]);         //向串口1发送数据
//				while(USART_GetFlagStatus(USART1,USART_FLAG_TC)!=SET);//等待发送结束
//			}
//			printf("\r\n\r\n");//插入换行
//			USART_RX_STA=0;
//		}else
//		{
//			times++;
//			if(times%5000==0)
//			{
//				printf("\r\nALIENTEK 探索者STM32F407开发板 串口实验\r\n");
//				printf("正点原子@ALIENTEK\r\n\r\n\r\n");
//			}
//			if(times%200==0)printf("请输入数据,以回车键结束\r\n");  
//			if(times%30==0)LED0=!LED0;//闪烁LED,提示系统正在运行.
//			delay_ms(10);   
//		}
//	}
//}


 
//void Clear_Openmv_Rxbuff(void)
//{
//	u8 *p,i;
//	p=openmv_rx_data;
//	for(i=0;i<Rx_Length;i++)
//	{
//		*p++=0;
//	}
//	length=0;
//	rx_flag=0;
//}

//u8 Judge_Openmv_Response(char* fmt,...)
//{
//	char p[30];
//	if(!rx_flag) return 0;
//	va_list ap;
//	va_start(ap,fmt);
//	vsprintf((char*)p,fmt,ap);
//	va_end(ap); 
//	if(strstr((char*)openmv_rx_data,p)==NULL) return 0;
//	else return 1;
//}

//		if(Judge_Openmv_Response("OK"))
//		{
//			Clear_Openmv_Rxbuff();
//			LCD_ShowString(0,16,"OK");
//		}

fifo_usart2.h

#ifndef __FIFO_USART2_H
#define __FIFO_USART2_H

#include "sys.h"
#include "stdbool.h"

/**********************************************************

**********************************************************/

#define 	USART2_FIFO_SIZE   128


typedef struct {
	uint16_t buffer[USART2_FIFO_SIZE];
	__IO uint8_t ptrWrite;
	__IO uint8_t ptrRead;
}USART2_FIFO_t;

extern __IO USART2_FIFO_t rx2FIFO;

void     usart2_fifo_initQueue(void);
void     usart2_fifo_enQueue(uint16_t data);
uint16_t usart2_fifo_deQueue(void);
bool     usart2_fifo_isEmpty(void);//bool需要添加stdbool.h头文件
uint16_t usart2_fifo_queueLength(void);

#endif

fifo_usart2.c

#include "fifo_usart2.h"

/**********************************************************
**********************************************************/

__IO USART2_FIFO_t rx2FIFO = {0};

/**
	* @brief   初始化队列
	* @param   无
	* @retval  无
	*/
void usart2_fifo_initQueue(void)
{
	rx2FIFO.ptrRead  = 0;
	rx2FIFO.ptrWrite = 0;
}

/**
	* @brief   入队
	* @param   无
	* @retval  无
	*/
void usart2_fifo_enQueue(uint16_t data)
{
	rx2FIFO.buffer[rx2FIFO.ptrWrite] = data;
	
	++rx2FIFO.ptrWrite;
	
	if(rx2FIFO.ptrWrite >= USART2_FIFO_SIZE)
	{
		rx2FIFO.ptrWrite = 0;
	}
}

/**
	* @brief   出队
	* @param   无
	* @retval  无
	*/
uint16_t usart2_fifo_deQueue(void)
{
	uint16_t element = 0;

	element = rx2FIFO.buffer[rx2FIFO.ptrRead];

	++rx2FIFO.ptrRead;

	if(rx2FIFO.ptrRead >= USART2_FIFO_SIZE)
	{
		rx2FIFO.ptrRead = 0;
	}

	return element;
}

/**
	* @brief   判断空队列
	* @param   无
	* @retval  无
	*/
bool usart2_fifo_isEmpty(void)
{
	if(rx2FIFO.ptrRead == rx2FIFO.ptrWrite)
	{
		return true;
	}

	return false;
}

/**
	* @brief   计算队列长度
	* @param   无
	* @retval  无
	*/
uint16_t usart2_fifo_queueLength(void)
{
	if(rx2FIFO.ptrRead <= rx2FIFO.ptrWrite)
	{
		return (rx2FIFO.ptrWrite - rx2FIFO.ptrRead);
	}
	else
	{
		return (USART2_FIFO_SIZE - rx2FIFO.ptrRead + rx2FIFO.ptrWrite);
	}
}

测试main.c

#include "sys.h"
#include "usart.h"
#include "delay.h"
#include "led.h"
#include "beep.h"
#include "usart2fifo.h"
#include "fifo_usart2.h"

int main(void)
{
	u16 i=0;
	float rotate_angle,grab_angle,stepper_mm;
//	int x;
//	float y;
	
	Nvic_Init(NVIC_PriorityGroup_4);//中断分组第四组 高优先打断低优先
	Set_Nvic_Irq(USART1_IRQn,0,3);//设置串口1的中断等级；
  Delay_Init();//延时函数默认中断优先级是最低的。
	
	
	LED_Init();//LED灯初始化
  BEEP_Init();//蜂鸣器初始化
	
	uart1_init(115200);//设置串口1的波特率是115200
  uart2_init(115200);
	Usart_SendByte(USART1,'a');//测试单字节发送函数
	Usart_SendByte(USART1,'b');//测试单字节发送函数
	
	Usart_SendString(USART1,"tab\r\n");//测试字符串发送函数
	printf("hello world\r\n");//这个也能用，测试printf函数

	printf("LED=1,%d\r\n",i);//这个也能用，测试printf函数
	Printf(USART1,"LED=0,%d\r\n",i);//这个也能用，测试大写的Printf函数

	while(1)
	{
		
  //*********************************************  串口屏HMI命令解析
   //*********************************************
   //*********************************************
   //*********************************************
   //*********************************************

		if(Usart2_rxFrameFlag==true)
		{
		
												{
													
													//将接收的数据通过串口1输出，验证数据
						//			Usart_SendString(USART1,Usart2_rxCmd);
						//			
						//			for(i=0;i<Usart2_rxCount;i++)
						//			{
						//				Usart_SendByte(USART1,Usart2_rxCmd[i]);
						//			}
												Usart_SendByte(USART1,Usart2_rxCmd[Usart2_rxCount-1]);
						//			Usart_SendByte(USART1,Usart2_rxCmd[Usart2_rxCount-2]);
						//			Usart_SendByte(USART1,Usart2_rxCmd[Usart2_rxCount-1]);
												}
								if(Usart2_rxCmd[Usart2_rxCount-1]==0x0a) //如果接收到的最后的数据是约定好的帧尾，最后面的0x0a
								{
									
											printf("0d ok\r\n");

									if(Usart2_rxCmd[Usart2_rxCount-2]==0x0d)  //前一个0x0d
									{
										
										    printf("0d 0a ok\r\n");
									      USART2_Rec_Frame_Flag=1;//接收标记等于1，在哪里清0？在判断里面清0
										
													if(Judge_Usart2_Response("stop"))
													{
														printf("stop\r\n");
//														machine_stop_flag=1;
//														machine_start_flag=0;
														Clear_Uart2_RecBuf();
													}
												else	if(Get_Usart2_S1(&rotate_angle))  //旋转舵机旋转一个角度
													{
													//	Servo1_move(rotate_angle,1200,270);
														printf("rotate_angle=%f\r\n",rotate_angle);
														Clear_Uart2_RecBuf();
													}	
													else	if(Get_Usart2_S2(&grab_angle)) //抓手舵机旋转一个角度
													{
													//	servohandflag =1;
														
														Clear_Uart2_RecBuf();
													}	
													else	if(Get_Usart2_S7(&stepper_mm))  //步进电机运动到绝对坐标，以回0的位置为原点
													{
													//	hmi_stepper_mm_flag=1;
														//move(stepper_mm);
														printf("stepper_mm=%f\r\n",stepper_mm);
														Clear_Uart2_RecBuf();
													}	
 
									
												else Clear_Uart2_RecBuf();
												} 
											}
								
			Usart2_rxCount=0;//长度清零，给下次使用
			Usart2_rxFrameFlag=false;
      Clear_Uart2_RecBuf();
		}


		
	}
}

在这里插入图片描述

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

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

相关文章

激光模拟单粒子效应试验如何验证CANFD芯片的辐照阈值？

激光模拟单粒子效应试验如何验证CANFD芯片的辐照阈值？

在现代航天电子系统中&#xff0c;CANFD&#xff08;Controller Area Network with Flexible Data-rate&#xff09;芯片作为关键的通信接口元件&#xff0c;其可靠性与抗辐射性能直接关系到整个系统的稳定运行。由于宇宙空间中存在的高能粒子辐射&#xff0c;芯片可能遭受单粒…
阅读更多...
从零构建大语言模型全栈开发指南：第五部分：行业应用与前沿探索-5.2.1模型偏见与安全对齐（Red Teaming实践）

从零构建大语言模型全栈开发指南：第五部分：行业应用与前沿探索-5.2.1模型偏见与安全对齐（Red Teaming实践）

👉 点击关注不迷路 👉 点击关注不迷路 👉 点击关注不迷路 文章大纲 大语言模型全栈开发指南：伦理与未来趋势 - 第五部分：行业应用与前沿探索5.2.1 模型偏见与安全对齐（Red Teaming实践）一、模型偏见的来源与影响1. 偏见的定义与分类2. 偏见的实际影响案例二、安全对齐…
阅读更多...
Docker安装开源项目x-ui详细图文教程

Docker安装开源项目x-ui详细图文教程

本章教程，主要介绍如何使用Docker部署开源项目x-ui 详细教程。 一、拉取镜像 docker pull enwaiax/x-ui:latest二、运行容器 mkdir x-ui && cd x-ui docker run -itd --network=host \-v $PWD<
阅读更多...
检索增强生成(RAG) 优化策略

检索增强生成(RAG) 优化策略

检索增强生成(RAG) 优化策略篇 一、RAG基础功能篇 1.1 RAG 工作流程 二、RAG 各模块有哪些优化策略&#xff1f;三、RAG 架构优化有哪些优化策略&#xff1f; 3.1 如何利用 知识图谱&#xff08;KG&#xff09;进行上下文增强&#xff1f; 3.1.1 典型RAG架构中&#xff0c;向…
阅读更多...
零基础玩转树莓派5！从系统安装到使用VNC远程控制树莓派桌面实战

零基础玩转树莓派5！从系统安装到使用VNC远程控制树莓派桌面实战

文章目录 前言1.什么是Appsmith2.Docker部署3.Appsmith简单使用4.安装cpolar内网穿透5. 配置公网地址6. 配置固定公网地址总结 前言 你是否曾因公司内部工具的开发周期长、成本高昂而头疼不已&#xff1f;或是突然灵感爆棚想给团队来点新玩意儿&#xff0c;却苦于没有专业的编…
阅读更多...
【MyBatis】深入解析 MyBatis：关于注解和 XML 的 MyBatis 开发方案下字段名不一致的的查询映射解决方案

【MyBatis】深入解析 MyBatis：关于注解和 XML 的 MyBatis 开发方案下字段名不一致的的查询映射解决方案

注解查询映射 我们再来调用下面的 selectAll() 这个接口&#xff0c;执行的 SQL 是 select* from user_info&#xff0c;表示全列查询&#xff1a; 运行测试类对应方法&#xff0c;在日志中可以看到&#xff0c;字段名一致&#xff0c;Mybatis 就成功从数据库对应的字段中拿到…
阅读更多...
图像退化对目标检测的影响 ！！

图像退化对目标检测的影响 ！！

文章目录 引言 1、理解图像退化 2、目标检测中的挑战 3、应对退化的自适应方法 4、新兴技术与研究方向 5、未来展望 6、代码 7、结论 引言 在计算机视觉领域&#xff0c;目标检测是一项关键任务&#xff0c;它使计算机能够识别和定位数字图像中的物体。这项技术支撑着从自动驾…
阅读更多...
《AI大模型应知应会100篇》第57篇：LlamaIndex使用指南：构建高效知识库

《AI大模型应知应会100篇》第57篇：LlamaIndex使用指南：构建高效知识库

第57篇&#xff1a;LlamaIndex使用指南&#xff1a;构建高效知识库 摘要 在大语言模型&#xff08;LLM&#xff09;驱动的智能应用中&#xff0c;如何高效地管理和利用海量知识数据是开发者面临的核心挑战之一。LlamaIndex&#xff08;原 GPT Index&#xff09; 是一个专为构建…
阅读更多...
目标检测中COCO评估指标中每个指标的具体含义说明：AP、AR

目标检测中COCO评估指标中每个指标的具体含义说明：AP、AR

《------往期经典推荐------》 一、AI应用软件开发实战专栏【链接】 项目名称项目名称1.【人脸识别与管理系统开发】2.【车牌识别与自动收费管理系统开发】3.【手势识别系统开发】4.【人脸面部活体检测系统开发】5.【图片风格快速迁移软件开发】6.【人脸表表情识别系统】7.【…
阅读更多...
如何利用ATECLOUD测试平台的芯片测试解决方案实现4644芯片的测试？

如何利用ATECLOUD测试平台的芯片测试解决方案实现4644芯片的测试？

作为多通道 DC-DC 电源管理芯片的代表产品&#xff0c;4644 凭借 95% 以上的转换效率、1% 的输出精度及多重保护机制&#xff0c;广泛应用于航天航空&#xff08;卫星电源系统&#xff09;、医疗设备&#xff08;MRI 梯度功放&#xff09;、工业控制&#xff08;伺服驱动单元&a…
阅读更多...
《继电器：机械骑士的电磁战甲》

《继电器：机械骑士的电磁战甲》

点击下面图片带您领略全新的嵌入式学习路线 &#x1f525;爆款热榜 88万阅读 1.6万收藏 第一章&#xff1a;千年契约的青铜誓言 在电气王国的熔炉深处&#xff0c;电磁铁与簧片的盟约已镌刻千年。电磁铁身披螺旋铜线编织的斗篷&#xff0c;其胸膛中沉睡着一道可召唤磁力的古…
阅读更多...
快速求平方根

快速求平方根

1. 前置知识 建议首先阅读我的另外一篇文章《雷神之锤 III 竞技场》快速求平方根倒数的计算探究》。建议大家自己看过《雷神之锤 III 竞技场》快速求平方根倒数的计算探究》学会快速求平方根倒数算法后&#xff0c;不看我这篇文章&#xff0c;自己推导一篇快速求平方根的算法&…
阅读更多...
C语言基础要素(019)：输出ASCII码表

C语言基础要素(019)：输出ASCII码表

计算机以二进制处理信息&#xff0c;但二进制对人类并不友好。比如说我们规定用二进制值 01000001 表示字母’A’&#xff0c;显然通过键盘输入或屏幕阅读此数据而理解它为字母A&#xff0c;是比较困难的。为了有效的使用信息&#xff0c;先驱者们创建了一种称为ASCII码的交换代…
阅读更多...
CI/CD(九) Jenkins共享库与多分支流水线准备

CI/CD(九) Jenkins共享库与多分支流水线准备

后端构建 零&#xff1a;安装插件 Pipeline: Stage View&#xff08;阶段视图&#xff09;、SSH Pipeline Steps&#xff08;共享库代码中要调用sshCommond命令&#xff09; 一、上传共享库 二、Jenkins配置共享库 3、新增静态资源与修改配置 如果是docker和k8s启动&#xf…
阅读更多...
pip安装timm依赖失败

pip安装timm依赖失败

在pycharm终端给虚拟环境安装timm库失败&#xff08; pip install timm&#xff09;&#xff0c;提示你要访问 https://rustup.rs/ 来下载并安装 Rust 和 Cargo 直接不用管&#xff0c;换一条命令 pip install timm0.6.13 成功安装 简单粗暴
阅读更多...
详解隔离级别（4种），分别用表格展示问题出现的过程及解决办法

详解隔离级别（4种），分别用表格展示问题出现的过程及解决办法

选择隔离级别的时候&#xff0c;既需要考虑数据的一致性&#xff0c;避免脏数据&#xff0c;又要考虑系统性能的问题。下面我们通过商品抢购的场景来讲述这4种隔离级别的区别 未提交读&#xff08;read uncommitted&#xff09; 未提交读是最低的隔离级别&#xff0c;其含义是…
阅读更多...
NO.63十六届蓝桥杯备战|基础算法-⼆分答案|木材加工|砍树|跳石头(C++)

NO.63十六届蓝桥杯备战|基础算法-⼆分答案|木材加工|砍树|跳石头(C++)

⼆分答案可以处理⼤部分「最⼤值最⼩」以及「最⼩值最⼤」的问题。如果「解空间」在从⼩到⼤的「变化」过程中&#xff0c;「判断」答案的结果出现「⼆段性」&#xff0c;此时我们就可以「⼆分」这个「解空间」&#xff0c;通过「判断」&#xff0c;找出最优解。 这个「⼆分答案…
阅读更多...
深层储层弹塑性水力裂缝扩展机理

深层储层弹塑性水力裂缝扩展机理

弹性与弹塑性储层条件下裂缝形态对比 参考&#xff1a; The propagation mechanism of elastoplastic hydraulic fracture in deep reservoir | International Journal of Coal Science & Technology
阅读更多...
循环神经网络 - 机器学习任务之异步的序列到序列模式

循环神经网络 - 机器学习任务之异步的序列到序列模式

前面我们学习了机器学习任务之同步的序列到序列模式&#xff1a;循环神经网络 - 机器学习任务之同步的序列到序列模式-CSDN博客 本文我们来学习循环神经网络应用中的第三种模式&#xff1a;异步的序列到序列模式&#xff01; 一、基本概述&#xff1a; 异步的序列到序列模式…
阅读更多...
什么是检索增强生成（RAG）

什么是检索增强生成（RAG）

1、什么是检索增强生成&#xff08;RAG&#xff09; 1.1 检索增强生成的概念 检索增强生成&#xff08;Retrieval-Augmented Generation, RAG&#xff09;是一种结合了信息检索和文本生成技术的新型自然语言处理方法。这种方法增强了模型的理解和生成能力。 相较于经典生成…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023