基于FreeRTOS的四麦_循迹_视觉_夹取小车

已于 2023-05-04 16:05:51 修改
阅读量456 收藏 6
点赞数 3
文章标签： 单片机 stm32 嵌入式硬件
于 2023-05-04 16:04:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/pupurui111/article/details/130487131
版权

目录

​思维导图

1.材料

2.PID算法控制电机闭环

1).调用函数让TIM读取CNT寄存器的数值。

2).从APP接收到的字符串进行XYZ三轴分解。

3).PID算法得出PWM，后赋值给结构体。

3.循迹（PID控制，卡尔曼滤波）

4.对树莓派3B 传输的数据进行处理

5.APP对舵机控制

1.材料

stm32vet6主控板，树莓派3b，八路循迹模块，TB6612电机驱动 x 2，降压模块（建议焊急停开关）注：不要用杜邦线接12v

2.PID算法控制电机闭环

PID(proportion integration differentiation)其实就是指比例，积分，微分控制。(图片源于网络)

1).调用函数让TIM读取CNT寄存器的数值。

//读取编码器计数
int Read_Encoder(u8 TIMX)
{
 int Encoder_TIM;    
 switch(TIMX)
 {
	case 2:  Encoder_TIM= (short)TIM2 -> CNT;   TIM2 -> CNT=0;  break;
	case 3:  Encoder_TIM= (short)TIM3 -> CNT;   TIM3 -> CNT=0;  break;
	case 4:  Encoder_TIM= (short)TIM4 -> CNT;   TIM4 -> CNT=0;  break;	
	case 5:  Encoder_TIM= (short)TIM5 -> CNT;   TIM5 -> CNT=0;  break;	
	default: Encoder_TIM=0;
 }
	return Encoder_TIM;//速度
}

将读取到的数值，赋值给结构体（结构体可提高封装效果）

//编码器数据转换为车轮速度，单位m/s
void Get_Velocity_Form_Encoder(void)
{
		float Encoder_A_pr,Encoder_B_pr,Encoder_C_pr,Encoder_D_pr; 
		OriginalEncoder.A=Read_Encoder(2);	
		OriginalEncoder.B=Read_Encoder(3);	
		OriginalEncoder.C=Read_Encoder(4);	
		OriginalEncoder.D=Read_Encoder(5);	

		switch(Car_Mode)
		{
			case Mec_Car:       Encoder_A_pr= OriginalEncoder.A; Encoder_B_pr= OriginalEncoder.B; Encoder_C_pr=-OriginalEncoder.C;  Encoder_D_pr=-OriginalEncoder.D; break; 
		}
		MOTOR_A.Encoder= Encoder_A_pr*CONTROL_FREQUENCY*Wheel_perimeter/Encoder_precision;  
		MOTOR_B.Encoder= Encoder_B_pr*CONTROL_FREQUENCY*Wheel_perimeter/Encoder_precision;  
		MOTOR_C.Encoder= Encoder_C_pr*CONTROL_FREQUENCY*Wheel_perimeter/Encoder_precision; 
		MOTOR_D.Encoder= Encoder_D_pr*CONTROL_FREQUENCY*Wheel_perimeter/Encoder_precision; 
}

typedef struct  
{
	float Encoder;   
	float Motor_Pwm;  
	float Target;      
	float Velocity_KP;
	float	Velocity_KI;
}Motor_parameter;

2).从APP接收到的字符串进行XYZ三轴分解。

在运动学分析中，将目标速度赋值给结构体。

void Drive_Motor(float Vx,float Vy,float Vz)
{
		float amplitude=1.3; //目标速度
		
	  if (Car_Mode==Mec_Car) 
    {
		  //运动学逆解
			MOTOR_A.Target   = +Vy+Vx-Vz*(Axle_spacing+Wheel_spacing);
			MOTOR_B.Target   = -Vy+Vx-Vz*(Axle_spacing+Wheel_spacing);
			MOTOR_C.Target   = +Vy+Vx+Vz*(Axle_spacing+Wheel_spacing);
			MOTOR_D.Target   = -Vy+Vx+Vz*(Axle_spacing+Wheel_spacing);
		
		//电机目标速度限幅
			MOTOR_A.Target=target_limit_float(MOTOR_A.Target,-amplitude,amplitude); 
			MOTOR_B.Target=target_limit_float(MOTOR_B.Target,-amplitude,amplitude); 
			MOTOR_C.Target=target_limit_float(MOTOR_C.Target,-amplitude,amplitude); 
			MOTOR_D.Target=target_limit_float(MOTOR_D.Target,-amplitude,amplitude); 
		} 
		
}

3).PID算法得出PWM，后赋值给结构体。

//pid     pwm+=Kp[e（k）-e(k-1)]+Ki*e(k)     pwm=pwm+Kp[e（k）-e(k-1)]+Ki*e(k)
int Incremental_PI_A (float Encoder,float Target)
{ 	
	 static float Bias,Pwm,Last_bias;
	 Bias=Target-Encoder;  //计算偏差
	MOTOR_A.Velocity_KP=300;
	MOTOR_A.Velocity_KI=300;
	 Pwm+=Velocity_KP*(Bias-Last_bias)+Velocity_KI*Bias; 
	 if(Pwm>16700)Pwm=16700;
	 if(Pwm<-16700)Pwm=-16700;
	 Last_bias=Bias;  //保存上一次偏差 
	 return Pwm;    
}
int Incremental_PI_B (float Encoder,float Target)
{  
	 static float Bias,Pwm,Last_bias;
	 Bias=Target-Encoder; 
	 Pwm+=Velocity_KP*(Bias-Last_bias)+Velocity_KI*Bias;  
	 if(Pwm>16700)Pwm=16700;
	 if(Pwm<-16700)Pwm=-16700;
	 Last_bias=Bias;  
	 return Pwm;
}
int Incremental_PI_C (float Encoder,float Target)
{  
	 static float Bias,Pwm,Last_bias;
	 Bias=Target-Encoder; 
	 Pwm+=Velocity_KP*(Bias-Last_bias)+Velocity_KI*Bias; 
	 if(Pwm>16700)Pwm=16700;
	 if(Pwm<-16700)Pwm=-16700;
	 Last_bias=Bias; 
	 return Pwm; 
}
int Incremental_PI_D (float Encoder,float Target)
{  
	 static float Bias,Pwm,Last_bias;
	 Bias=Target-Encoder;
	 Pwm+=Velocity_KP*(Bias-Last_bias)+Velocity_KI*Bias;  
	 if(Pwm>16700)Pwm=16700;
	 if(Pwm<-16700)Pwm=-16700;
	 Last_bias=Bias; 
	 return Pwm; 
}
	MOTOR_A.Motor_Pwm=Incremental_PI_A(MOTOR_A.Encoder, MOTOR_A.Target);
	MOTOR_B.Motor_Pwm=Incremental_PI_B(MOTOR_B.Encoder, MOTOR_B.Target);
	MOTOR_C.Motor_Pwm=Incremental_PI_C(MOTOR_C.Encoder, MOTOR_C.Target);
    MOTOR_D.Motor_Pwm=Incremental_PI_D(MOTOR_D.Encoder, MOTOR_D.Target);

赋值给CRR寄存器，封装TIM寄存器。

#define PWM_PORTA1 GPIOB			 //PWMA
#define PWM_PIN_A1 GPIO_Pin_8 
#define PWMA1 	  TIM10->CCR1	 

#define PWM_PORTA2 GPIOB			 //PWMA
#define PWM_PIN_A2 GPIO_Pin_9 
#define PWMA2 	  TIM11->CCR1	 

#define PWM_PORTB1 GPIOE			 //PWMB
#define PWM_PIN_B1 GPIO_Pin_5 
#define PWMB1 	  TIM9->CCR1	 

#define PWM_PORTB2 GPIOE			 //PWMB
#define PWM_PIN_B2 GPIO_Pin_6 
#define PWMB2 	  TIM9->CCR2	 

#define PWM_PORTC1 GPIOE			 //PWMC
#define PWM_PIN_C1 GPIO_Pin_11 
#define PWMC1 	  TIM1->CCR2	

#define PWM_PORTC2 GPIOE			 //PWMC
#define PWM_PIN_C2 GPIO_Pin_9 
#define PWMC2 	  TIM1->CCR1	

#define PWM_PORTD1 GPIOE			 //PWMD
#define PWM_PIN_D1 GPIO_Pin_14
#define PWMD1 	  TIM1->CCR4	 

#define PWM_PORTD2 GPIOE			 //PWMD
#define PWM_PIN_D2 GPIO_Pin_13 
#define PWMD2 	  TIM1->CCR3	

Set_Pwm( MOTOR_A.Motor_Pwm, -MOTOR_B.Motor_Pwm, -MOTOR_C.Motor_Pwm, MOTOR_D.Motor_Pwm  ); 

void Set_Pwm(int motor_a,int motor_b,int motor_c,int motor_d)
{
	if(motor_a<0)			PWMA1=16799,PWMA2=16799+motor_a;
	else 	            PWMA2=16799,PWMA1=16799-motor_a;
	
	if(motor_b<0)			PWMB1=16799,PWMB2=16799+motor_b;
	else 	            PWMB2=16799,PWMB1=16799-motor_b;

	if(motor_c<0)			PWMC1=16799,PWMC2=16799+motor_c;
	else 	            PWMC2=16799,PWMC1=16799-motor_c;
	
	if(motor_d<0)			PWMD1=16799,PWMD2=16799+motor_d;
	else 	            PWMD2=16799,PWMD1=16799-motor_d;
}

电机成功闭环！

3.循迹（PID控制，卡尔曼滤波）

初始化一个数组更方便调试，读取循迹电平。

	void check_LED()
{
		xunji1[0]=L4;
		xunji1[1]=L3;
		xunji1[2]=L2;
		xunji1[3]=L1;
		xunji1[4]=R1;
		xunji1[5]=R2;
		xunji1[6]=R3;
		xunji1[7]=R4;
}

最简单的直接，条件语句判断赋值。

void xunji()
{
			check_LED();
			if(L2==0&&L1==0&&R1==0&&R2==0)                                                                               //   --00 00--
			{
				Drive_Motor(0, 0, 0);
			}
 
		   else if(L4==1&&L3==1&&L2==0&&L1==0&&R1==0&&R2==0&&R3==1&&R4==1)   //停车线                                       1100 0011
		 {
				Drive_Motor(0, 0, 0);
		 }
		 
//--------------------------------------------【直线】---------------------------------------------------------------------------------		 
		 
		 else if(L4==1&&L3==1&&L2==1&&L1==0&&R1==0&&R2==1&&R3==1&&R4==1)// 直线                                           1110  0111
		 {
        Drive_Motor(-0.4, 0, 0);
		 } 
		 else if(L4==1&&L3==1&&L2==0&&L1==0&&R1==0&&R2==1&&R3==1&&R4==1)// 直线                                            1100 0111
		 {
        Drive_Motor(-0.35, 0, 0);
		 } 
		 else if(L4==1&&L3==1&&L2==1&&L1==0&&R1==0&&R2==0&&R3==1&&R4==1)// 直线                                          1110 0011
		 {
        Drive_Motor(-0.35, 0, 0);
		 }
		
	  else if(L1==0)// 直线                                                                                               ---0 ----
		 {
        Drive_Motor(-0.475, 0, 0);
		 } 
		 	  else if(R1==0	)// 直线                                                                                          ---- 0---
		 {
        Drive_Motor(-0.475, 0, 0);
		 } 
		 else if(L4==1&&L3==1&&L2==1&&L1==0&&R1==1&&R2==1&&R3==1&&R4==1)// 直线                                            1100 0111
		 {
   Drive_Motor(-0.3, 0, 0);
		 } 
		 else if(L4==1&&L3==1&&L2==1&&L1==1&&R1==0&&R2==1&&R3==1&&R4==1)// 直线                                          1110 0011
		 {
   Drive_Motor(-0.3, 0, 0);
		 }
		
     else if(L4==1&&L3==1&&L2==0&&L1==1&&R1==1&&R2==1&&R3==1&&R4==1)// 小左偏2  （直线）			Load(-1000,-0);  
		 {
			   Drive_Motor(-0.025, -0.475, 0);
		 } 
		 else if(L4==1&&L3==1&&L2==1&&L1==1&&R1==1&&R2==0&&R3==1&&R4==1)// 中左偏2 （直线） 		Load(-1500,-0); 
		 {
         Drive_Motor(-0.025, 0.475, 0);
		 } 	 
		 
		 
		 else if(L4==1&&L3==1&&L2==0&&L1==0&&R1==1&&R2==1&&R3==1&&R4==1)// （直线）			Load(-1000,-0);              1100 1111                        
		 {
			   Drive_Motor(-0.4, 0, 0);
		 }
		 else if(L4==1&&L3==1&&L2==1&&L1==1&&R1==0&&R2==0&&R3==1&&R4==1)// （直线） 			Load(-1000,-0);              1111 0011                    
		 {
        Drive_Motor(-0.4, 0, 0);
		 }
		 
		 //--------------------------------------------【左偏】---------------------------------------------------------------------------------
		
		 else if(L4==1&&L3==0&&L2==0&&L1==1&&R1==1&&R2==1&&R3==1&&R4==1)// 中左偏  	                                      1001 1111
		 {
          Drive_Motor(-0.02, 0, 1.05);
			 
		 } 
		 else if(L4==0&&L3==0&&L2==1&&L1==1&&R1==1&&R2==1&&R3==1&&R4==1)// 大左偏  		                                    0011 1111
		 {
         Drive_Motor(-0.02, 0, 1.3);
		 } 
		 else if(L4==0&&L3==0&&L2==0&&L1==1&&R1==1&&R2==1&&R3==1&&R4==1)//左边很转弯（直角弯）   	                                  0001 1111 
		 {
         Drive_Motor(-0.02, 0, 1.3);
		 }
		 else if(L4==0&&L3==0&&L2==0&&L1==0&&R1==1&&R2==1&&R3==1&&R4==1)//左边急转弯（直角弯）                                     0000 1111
		 {
         Drive_Motor(-0.5, 0, 1.35);
		 }
		 else if(L4==1&&L3==0&&L2==0&&L1==0&&R1==1&&R2==1&&R3==1&&R4==1)//右边超急转弯    		                1000 1111 
		 {
         Drive_Motor(-0.1, 0, 1.35);
		 }
		 else if(L4==1&&L3==0&&L2==0&&L1==0&&R1==0&&R2==1&&R3==1&&R4==1)//左边超急转弯    		                1000 0111
		 {
         Drive_Motor(-0.1, 0, 1.4);
		 }
		 
//		 
//		 		  else if(L3==0)// 大左偏2 		Load(-1500,-0);                                                                  -0-- ----
//		 {
//         Drive_Motor(-0.1, 0, 1.325);
//		
//		 }
//		 		 else if(L4==0)// 大左偏2 		Load(-1500,-0);                                                                  0--- ----                       
//		 {
//         Drive_Motor(-0.1, 0, 1.375);
//	
//		 }

	//	 ----------------------------------------【右偏】---------------------------------------------------------------------------------------
		 		 
		 else if(L4==1&&L3==1&&L2==1&&L1==1&&R1==1&&R2==0&&R3==0&&R4==1)// 中右偏  		                                     1111 1001
		 {
        Drive_Motor(-0.02, 0, -1.05);
		 } 
		 else if(L4==1&&L3==1&&L2==1&&L1==1&&R1==1&&R2==1&&R3==0&&R4==0)// 大右偏  	                                       1111 1100
		 {
		    Drive_Motor(-0.02, 0, -1.3); 
		 } 
		 else if(L4==1&&L3==1&&L2==1&&L1==1&&R1==1&&R2==0&&R3==0&&R4==0)//右边很转弯     			                             1111 1000
		 { 
			  Drive_Motor(-0.02, 0, -1.325);
		 }
	   else if(L4==1&&L3==1&&L2==1&&L1==1&&R1==0&&R2==0&&R3==0&&R4==0)//右边急转弯                                          1111 0000
		 {
			  Drive_Motor(-0.05, 0, -1.35);
		 }
		 else if(L4==1&&L3==1&&L2==1&&L1==1&&R1==0&&R2==0&&R3==0&&R4==1)//右边超急转弯    		                     1111 0001 
		 {
         Drive_Motor(-0.1, 0, -1.375);
			 	
		 }
		 else if(L4==1&&L3==1&&L2==1&&L1==0&&R1==0&&R2==0&&R3==0&&R4==1)//右边超急转弯    		             1110 0001
		 {
         Drive_Motor(-0.1, 0, -1.4 );
		 }
//		 	 else if(R3==0)// 大右偏2  		                                                                                         ---- --0-
//		 {
//		    Drive_Motor(-0.1, 0, -1.325);
//			}
//		 	 else if(R4==0)// 大右偏2                                                                                              ---- ---0		
//		 {
//		    Drive_Motor(-0.1, 0, -1.375);
//			}
		}

4.对树莓派3B 传输的数据进行处理

	if(ShiJue=='s')
			{
//				if(shijue1<=10)
//				{
//      Drive_Motor(-0.3,0,0);
//				}
//					if(10<shijue1&&shijue1<=DELAY)
//		  {	
				xunji();
//			}
//			 count1++;
			}
			if(ShiJue=='l')
			{
				Drive_Motor(-0.3,0.3, 0);//向左循迹
				delay_ms(500);
					Drive_Motor(0,0,0);
			}
			if(ShiJue=='r')
			{
				Drive_Motor(-0.3, -0.3, 0);//向右循迹
					delay_ms(500);
					Drive_Motor(0,0,0);
			}

开启串口中断，赋值给变量，对应变量进行控制

int USART3_IRQHandler(void)//串口三与视觉通信的中断
{	
	if(USART_GetITStatus(USART3, USART_IT_RXNE) != RESET)  
	{
		ShiJue = USART_ReceiveData(USART3); //读取数据
		if(Time_count<CONTROL_DELAY)
		  return 0;	
	} 
  return 0;	
}

5.APP对舵机控制

	 switch(Flag_Direction)  
	 {
			case 1:      Move_X=RC_Velocity;  	 Move_Y=0;                             break;
			case 2:      Move_X=RC_Velocity;  	 Move_Y=-RC_Velocity;  	               break;
			case 17:     Move_Z= -PI/2*(RC_Velocity/500); 	                           break;
			case 3:      Move_X=0;      		     Move_Y=-RC_Velocity;                  break;
			case 5:      Move_X=-RC_Velocity;  	 Move_Y=0;                             break;
			case 7:      Move_X=0;     	 		     Move_Y=RC_Velocity;                   break;
			case 18:     Move_Z= PI/2*(RC_Velocity/500);                               break;
			case 8:      Move_X=RC_Velocity; 	   Move_Y=RC_Velocity;                   break; 
 		  case 9:      mark1=1; APP_ON_Flag=0;								                       break;
		  case 10:   	 TIM_SetCompare3(TIM8, 2100);		 															 break;
		  case 11:   	 TIM_SetCompare3(TIM8,1150);					  									  	 break;
		  case 12:   	 TIM_SetCompare1(TIM12, 2400);															     break;
		  case 19:     TIM_SetCompare1(TIM12, 1500);																	 break;
		  case 13:     TIM_SetCompare1(TIM12, 600);																 break;
		  case 14:  	 TIM_SetCompare4(TIM8, 1450); 																 break;
	 	  case 15:     TIM_SetCompare4(TIM8, 1550);																	 break;
	 	  case 16:     TIM_SetCompare4(TIM8, 1500);															     break;
		  case 4:      Move_X=-RC_Velocity;  	 Move_Y=-RC_Velocity;                  break;
		  case 6:      Move_X=-RC_Velocity;  	 Move_Y=RC_Velocity;                   break;
			default:     Move_X=0;               Move_Y=0;    Move_Z=0;                break;
	 }

Angstt
关注
  • 3
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
基于FreeRTOS的WIFI控制避障小车
06-24
在stm32f103上移植FreeRTOS任务调度系统,实时控制小车的前进,超声波测距,WIFI指令接收.
2021电赛F题智能送药小车方案分析(openMV数字识别,红线循迹,STM32HAL库freeRTOS,串级PID快速学习,小车自动返回）
热门推荐
You are more than what you have become
11-11 6万+
2021电赛F题智能送药小车方案分析(openARTmini数字识别加循迹融合代码,STM32HAL库freeRTOS,串级PID快速学习,小车自动返回） 附有工程代码链接，分析详细，工程完善
stm32智能小车(FreeRTOS项目练习)
qq_47775761的博客
05-05 7502
看完了FreeRTOS的教程，想找个项目练手，淘宝或者网上少有基于FreeRTOS的项目，于是我就想用FreeRTOS做个智能小车，可能FreeRTOS不是做小车的最优解，但主要目的是用来练手。
FreeRTOS任务
hqy450665101的博客
02-01 316
FreeRTOS任务 在裸机系统中，系统的主体是main函数里面顺序执行的无限循环，这个无限循环里面CPU按照顺序完成各种事情，在多任务系统中，我们根据功能不同，把整个系统分割成一个个独立的且无法返回的函数，这个函数我们称为任务。 创建任务 定义任务栈 在裸机系统中，全局变量，有子函数调用，有中断发生等都存放在栈，栈是单片机RAM里面一段连续的内存空间，栈的大小一般在启动文件或者链接脚本里面指定，最后由C库函数_main进行初始化。 但是在多任务系统中，每个任务都是独立的，互不干扰的，所以要为每个任务都分
基于STM32手把手教你做FreeRTOS平衡小车
qq_16627473的博客
07-26 3145
此平衡小车基于STM32F401CCU6制作，在FreeRTOS下运行，能够完成直立，在手机蓝牙调试APP控制下能够前后运动以及转动。基于STM32手把手教你做FreeRTOS平衡小车。
Freertos-小车开发笔记 3 --PID控制编码电机
weixin_57000913的博客
03-29 1124
通过编码点击控制小车的后轮转动，通过舵机改变前轮的转向。一、创建软件定时器/* 创建软件定时器1-2 */10, //定时时间10mspdTRUE,// 周期定时器(void *)1, // 定时器编号//定时器回调函数//开启软件定时器//暂停软件定时器。
FreeRTOS.zip_FreeRTOS 移植_freertos_freertos移植
09-24
FreeRTOS操作系统在CortexM3上的移植
freertos.rar_2440 FREERTOS_freertos_recursive semaphore_嵌入式
09-22
很优秀的实时嵌入式操作系统。开源、功能强大。
freertos.rar_FreeRTOS详解_freertos_freertos开发
07-15
freertos 开发资料汇总，包含使用教程、运用详解等
XC2000_FreeRTOS.zip_FreeRTOS 移植_XC2000_FreeRTOS_freertos_infineo
07-15
在英飞凌XC2000平台上移植Freertos，功能实现任务切换，编译器为Tasking。
FreeRTOS.rar_FreeRTOS GNU_freertos
09-14
本代码已经经过修改，适应于EBD7X256开发板。 采用的编译器是gnuarm-3.4.3。
Freertos-小车开发笔记 1 --freertos-库函数移植
weixin_57000913的博客
03-15 657
stm32F103移植 FreeRTOS。使用一个基础工程，基础工程越简单越好，这里我们就用基础例程 中的跑马灯实验来作为基础工程
基于STM32F103与FreeRTOS的自平衡小车实现
weixin_49460450的博客
11-15 1727
对于高精度的设备当然不允许有这种误差存在，于是I算法就是来解决这一问题，I算法会进行误差值的累加，但显而前面几次误差过大，我们得先忽略，不然I算法也无效，I算法是积分算法，累加之前的误差，加上一个合适的系数，这就会补偿前面那个临界误差来带的影响，这样我们的PID算法就差D算法了，D算法是为了解决当我们的无人机好好的飞着突然受到了一个强风吹那咋办，岂不会立马系统就变得晃动很大，因为P这时对于的差值很大，为了解决这一点，D算法微分就刚好能解决这一点，D算法积分算法是通过计算上一次偏差。这样我们就得到了速度。
Freertos-小车开发笔记 2 --编码电机使用
weixin_57000913的博客
03-15 3841
通过编码点击控制小车的后轮转动，通过舵机改变前轮的转向。一、TB6612电机驱动板采用tb6612电机作为编码电机的驱动板，该驱动板只需要1个pwm信号和两个IO口即可控制一个编码电机.编码器电机为直流减速电机，一般直流电机的转速都是一分钟几千上万转的，所以一般需要安装减速器。减 速器是一种相对精密的机械零件，使用它的目的是降低转速，增加转矩。减速后的直流电机力矩增大、可控性更强。按照传动级数不同可分为单级和多级减速器；按照传动类型可分为齿轮减速器、蜗杆减速器和行星齿轮减速器。
STM32cubeMX详细教学及多个小项目合集(包含RTOS）
m0_49476241的博客
09-01 2881
现在大家学习完STM32总是会感觉做不出什么实在的东西，现在我就给大家推荐我写的几篇关于智能小车的项目，及智能家居的项目，希望这些文章可以帮助大家更加深入的去理解STM32相关的知识点。在学习这些东西之前大家可以先去学习STM32的基本操作，以及C语言的基本知识点。还可以去学习关于RTOS的知识。大家以后有什么想学习的可以私信或者留言。.........
用Ai编写一个电机驱动程序
番茄蛋汤面
05-12 1360
对于有一定编程经验的人来说，这个回答还是能看懂的，但是如果是初学者，也不难理解，还是完整的提供了核心的程序，对于HAL库来说，不同的开发平台虽然不尽相同，但是基本有现成的程序接口，总的来是AI的这个回答还是可以的，但是和这个程序还没提涉及到产品逻辑，要想达到能用的状态还需要人工进行一些加工和修饰。
【STM32】标准库实现中断点灯/串口通信
最新发布
weixin_72935906的博客
05-19 739
在实际硬件操控时，会遇到很多情况。比如本次探究中，就发现下载代码后并没有按照预想的那样实现功能，可以试试1.按下Stm32的RESET复位键。2.如果是无法收发串口信息，可以先按复位观察，如果没反应就更换串口助手软件。3.检查代码中的波特率。4.更换硬件。
在全志H616核桃派开发板上配置I2C引脚并读取温度数据
DOT小文哥的博客
05-17 509
根据手册给的时序，这里要创建两个msg，第一个是写，buf内存放读取温度的命令0x07。第二个是读，连续3个字节，其中前两个是温度数据。根据时序图，需要两个msg，第一个msg是写，地址帧后只跟寄存器编号。指令来使能/关闭指定设备的底层驱动，使能后，引脚就会由gpio模式切换为对应的引脚复用功能。为了方便查找，我们加入了一个显示功能引脚位置的功能，运行以下命令，查看板子的40pin引脚上有几个可用i2c。加入我现在想往地址是0x3c的设备上，把寄存器0x01赋值为0x55，那msg结构体的设置就该如下。
嵌入式单片机笔试题
qq_19343801的博客
05-14 1387
DC-DC转换器通过改变输入电压的形式（通常是电压升压或降压）来提供输出电压。它们使用开关元件（如MOSFET）以及电感和电容来实现电压的转换。LDO则通过调整输入电压之间的差值来提供稳定的输出电压。它们通过调节一个可变电阻（通常是一个晶体管）来实现电压稳定。由于DC-DC转换器利用了电感和电容存储能量，它们通常具有较高的效率，特别是在较大的电压转换范围内。LDO的效率通常较低，特别是在输入和输出电压之间的差值（即压降）很大时，因为它们将多余的能量转化为热量散失。
freertos 华大单片机 __disable_irq
02-02
freertos 是一个用于嵌入式系统的实时操作系统，而华大单片机是一种常用的嵌入式处理器。在 freertos 中，__disable_irq 是一种用于禁止中断的函数或宏。 当我们在华大单片机上使用 freertos 时，可能会遇到需要在特定情况下禁止中断的情况，比如在对共享资源进行访问时。这时我们可以使用 __disable_irq 函数来暂时禁止所有中断的发生，以确保操作的原子性和安全性。 __disable_irq 函数的作用是关闭当前使用的处理器的中断，这意味着处理器将不再响应任何中断请求，直到通过 __enable_irq 函数重新开启中断。这样可以确保在临界区内的代码执行时不会被任何中断打断。 在 freertos 中，__disable_irq 函数通常用于临界区的保护，比如在访问共享资源时，需要先禁止中断，在操作完成后再重新开启中断，以避免其他任务或中断处理程序对共享资源的干扰。 总而言之，在使用 freertos 运行华大单片机时，__disable_irq 函数是一个非常重要的工具，可以帮助我们在多任务环境下保证关键代码的执行顺序和安全性。因此，在设计和开发嵌入式系统时，使用 __disable_irq 函数是一个常见的做法。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值