STM32及FreeRTOS的平衡小车

将STM32的裸机程序改为FreeRTOS的三个任务
裸机程序是在每次接收到6050的中断中执行。数据读取。 Pid输出PWM。进行控制。
FreeRTOS三个任务，分别为数据读取，pid控制。 OLED显示。
现在的问题是。改为FreeRTOS，我不知道是不是数据传递的问题。小车的车轮会来回左右转。疯狂转动，不会平稳。
如果是裸机的程序小车非常稳
到底是什么原因啊，如何改？

一下午又改了改
添加了消息队列修改优先级还是不行，PID也不会有什么问题吧（裸机程序中很平稳），但问什么输出的pwm如此高，角度显示只偏一点，轮子还是狂转？

**//rtos任务代码**
#include "main.h"
#include "timers.h"
int Bluetooth_data;

float Angle_turn = 0;
int L_Speed,R_Speed;
float pitch,roll,yaw;         //欧拉角
short aacx,aacy,aacz;        //加速度传感器原始数据
short gyrox,gyroy,gyroz;    //陀螺仪原始数据
u8 stop_flag=0;
extern int Moto1,Moto2;
extern u8 Fore,Back,Left,Right;

TaskHandle_t start_task_handle;
#define START_TASK_STACK 128
#define START_TASK_PRIORITY 1
void App_Task_Start(void *pvParameters);

/* 获取姿态数据的任务配置 */
TaskHandle_t data_task_handle;
#define DATA_TASK_STACK 384
#define DATA_TASK_PRIORITY 4
void App_Task_GetData(void *pvParameters);

/* 进行PID控制的任务配置 */
TaskHandle_t pid_task_handle;
#define PID_TASK_STACK 384
#define PID_TASK_PRIORITY 5
void App_Task_PID(void *pvParameters);

/* 进行oled显示的任务配置 */
TaskHandle_t display_task_handle;
#define DISPLAY_TASK_STACK 256
#define DISPLAY_TASK_PRIORITY 3
void App_Task_Display(void *pvParameters);

void App_Task_Init(void)
{
    /* 1. 创建启动任务 */
    xTaskCreate(
        (TaskFunction_t)App_Task_Start,
        (char *)"App_Task_Start",
        (configSTACK_DEPTH_TYPE)START_TASK_STACK,
        (void *)NULL,
        (UBaseType_t)START_TASK_PRIORITY,
        (TaskHandle_t *)&start_task_handle);
            
    /* 2. 启动调度器 */
    vTaskStartScheduler();
}

/**
 * @description: 启动任务：用于创建其他任务
 * @param {void *} pvParameters
 * @return {*}
 */
void App_Task_Start(void *pvParameters)
{        BaseType_t xReturn = pdPASS;
    taskENTER_CRITICAL();
    xReturn=xTaskCreate(
        (TaskFunction_t)App_Task_GetData,
        (char *)"App_Task_GetData",
        (configSTACK_DEPTH_TYPE)DATA_TASK_STACK,
        (void *)NULL,
        (UBaseType_t)DATA_TASK_PRIORITY,
        (TaskHandle_t *)&data_task_handle);
            if(xReturn==pdPASS)
            printf("GetData TASK SUCCEED!\r\n");
            
    xReturn=xTaskCreate(
        (TaskFunction_t)App_Task_PID,
        (char *)"App_Task_PID",
        (configSTACK_DEPTH_TYPE)PID_TASK_STACK,
        (void *)NULL,
        (UBaseType_t)PID_TASK_PRIORITY,
        (TaskHandle_t *)&pid_task_handle);
            if(xReturn==pdPASS)
            printf("PID TASK SUCCEED!\r\n");
            
    xReturn=xTaskCreate(
        (TaskFunction_t)App_Task_Display,
        (char *)"App_Task_Display",
        (configSTACK_DEPTH_TYPE)DISPLAY_TASK_STACK,
        (void *)NULL,
        (UBaseType_t)DISPLAY_TASK_PRIORITY,
        (TaskHandle_t *)&display_task_handle);
            if(xReturn==pdPASS)
            printf("OLED TASK SUCCEED!\r\n");
            
    vTaskDelete(NULL);
    taskEXIT_CRITICAL();
}

/**
 * @description: 获取姿态数据：角度、编码器值
 * @param {void} *pvParameters
 * @return {*}
 */
void App_Task_GetData(void *pvParameters)
{
//    TickType_t pxPreviousWakeTime = xTaskGetTickCount();
//        if (mpu_dmp_init() != 0) {  // 添加初始化状态检查
//            OLED_ShowString(1, 1, "L:");
//            OLED_Clear();}
//        else{OLED_ShowString(1, 1, "OK");
//            OLED_Clear();}
        
    while (1) {
        // 等待中断通知，阻塞直到数据就绪
        ulTaskNotifyTake(pdTRUE, portMAX_DELAY);

        
        // 读取传感器数据（移至任务中）
        if (mpu_dmp_get_data(&pitch, &roll, &yaw) == 0) {
            MPU_Get_Gyroscope(&gyrox, &gyroy, &gyroz);  
        } 
//                printf("A: %0.2f,%0.2f,%0.2f\r\n", pitch, roll, yaw);
        
        L_Speed = Read_Encoder(3);
        R_Speed = Read_Encoder(4);
    
        /* 获取完数据，通知pid控制任务 */
        xTaskNotifyGive(pid_task_handle);
//        vTaskDelayUntil(&pxPreviousWakeTime, 2);
    }
}

/**
 * @description: 进行PID控制的任务
 * @param {void} *pvParameters
 * @return {*}
 */
void App_Task_PID(void *pvParameters)
{    
    int Target=0;
//    TickType_t last_wake = xTaskGetTickCount();
  
    while(1)
    {
        /* 等待“获取数据任务”的通知 */
        ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
//            printf("Gyro: %d %d %d\r\n", gyrox, gyroy, gyroz);
//            printf("B: %0.2f,%0.2f,%0.2f\r\n", pitch, roll, yaw);
                pid.Pv = roll*10;                                                                                //角度*十倍                                            
                if(Turn_Off(pid.Pv))stop_flag=1;                                                    //检测是否小车异常，异常就停止
                else stop_flag=0;
        Moto1 = balance(pid.Pv) + Velocity(Target,L_Speed, R_Speed) ;//+ turn(gyroz, Angle_turn);        
        Moto2 = balance(pid.Pv) + Velocity(Target,L_Speed, R_Speed) ;//- turn(gyroz, Angle_turn);
        Xianfu_Pwm(); // 对PWM进行限幅
//                printf("PWM: %d %d \r\n", Moto1, Moto2);
        Set_Pwm(Moto1, Moto2); 
                xTaskNotifyGive(display_task_handle);
//                vTaskDelayUntil(&last_wake, 2);
    }
}

/**
 * @description: OLED显示任务
 * @param {void} *pvParameters
 * @return {*}
 */
void App_Task_Display(void *pvParameters)
{
//    TickType_t pxPreviousTime = xTaskGetTickCount();
    while(1)
    {
//            printf("C: %0.2f,%0.2f,%0.2f\r\n", pitch, roll, yaw);
            ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
        OLED_ShowString(1, 1, "L:");
        OLED_ShowSignedNum(1, 3, L_Speed, 2);
        OLED_ShowString(1, 9, "R:");
        OLED_ShowSignedNum(1, 11, R_Speed, 2);
        OLED_ShowString(2, 1, "x:");
        OLED_ShowSignedNum(2, 3, pitch, 2);
        OLED_ShowString(2, 9, "y:");
        OLED_ShowSignedNum(2, 11, roll, 2);
        OLED_ShowString(3, 1, "Blue:");
        OLED_ShowNum(3, 6, Bluetooth_data, 4);
        OLED_ShowString(4, 1, "BAT:");
        // OLED_ShowNum(4, 6, BAT, 4);
//        vTaskDelayUntil(&pxPreviousTime, 2);
    }
}

void EXTI9_5_IRQHandler(void) {
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    if (EXTI_GetITStatus(EXTI_Line8) == SET) {
//            printf("PWM" );
        // 发送通知前检查任务句柄有效性
        if (data_task_handle != NULL) {
            xTaskNotifyFromISR(data_task_handle, 0, eNoAction, &xHigherPriorityTaskWoken);
        }
        EXTI_ClearITPendingBit(EXTI_Line8);
        portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
    }
}

**//裸机主要代码**
int main(void)
{       
      OLED_Init();
     TIM3_Encoder_Init();
     TIM4_Encoder_Init();
     MOTOR_Init();
     TIM2_PWM_Init(7199,0);                           //PWM输出初始化
     MPU6050_EXTI_Init(); 
     MPU_Init();
     mpu_dmp_init();
     PID_Init();
    uart2_Init();

//    OLED_ShowString(1,1, "L_Speed:   RPM");
//    OLED_ShowString(2,1, "R_Speed:   RPM");
////    OLED_ShowString(3,1, "pitch:");
//    OLED_ShowString(3,1, "roll:");
//    OLED_ShowString(4,1, "yaw:");
//    
    
    
//    Moto1=60000;
//    Moto2=60000;
//    Set_Pwm(Moto1,Moto2); 
    while(1)
    {
      printf("%d,%d,%0.2f,%0.2f,%0.2f\n",Moto1,Moto2,pitch,roll,yaw);//这里打印了多少个就是多少个通道，上位机会识别
        My_XianShi();
    } 

}

void EXTI9_5_IRQHandler(void)
{
  if (EXTI_GetITStatus(EXTI_Line8)==SET)
  {
       YunDong();
      
    EXTI_ClearITPendingBit(EXTI_Line8);
  }



}



void YunDong(void)
{
if(mpu_dmp_get_data(&pitch,&roll,&yaw)==0)
        { 
            MPU_Get_Gyroscope(&gyrox,&gyroy,&gyroz);
        }
      pid.Pv = roll*10;                                                                                //角度*十倍                                            
            if(Turn_Off(pid.Pv))stop_flag=1;                                                    //检测是否小车异常，异常就停止
            else stop_flag=0;
            
            L_Speed=Read_Encoder(3);    
            R_Speed=Read_Encoder(4);
        
        
        // 2.将数据压入闭环控制中，计算出控制输出量
            
      /*前后*/
      if((Fore==0)&&(Back==0))Target=0;   // 未接收到前进后退指令->速度清零，稳在原地
      if(Fore==1)Target++;  // 前进1标志位拉高->需要前进
      if(Back==1)Target--;  // 
        Xianfu_Pwm();// 限幅
      
      /*左右*/
      if((Left==0)&&(Right==0))Angle_turn=0;
      if(Left==1)Angle_turn--;   // 左转
      if(Right==1)Angle_turn++;  // 右转
         Xianfu_Pwm();        // 限幅
      
//      /*转向约束*/
      if((Left==0)&&(Right==0))pid.Turn_Kd=0.1;    // 若无左右转向指令，则开启转向约束
      else if((Left==1)||(Right==1))pid.Turn_Kd=0;  // 若左右转向指令接收到，则去掉转向约束
//      Velocity_out=Velocity(Target,Encoder_Left,Encoder_Right); // 速度环
//      Vertical_out=Vertical(Velocity_out+Med_Angle,Roll,gyrox);              // 直立环
//            Turn_out=Turn(gyroz,Turn_Speed);
        
        
        
        
        
            Moto1 = balance(pid.Pv) +Velocity(Target,L_Speed,R_Speed)+turn(gyroz,Angle_turn);//;        
            Moto2 = balance(pid.Pv) + Velocity(Target,L_Speed,R_Speed)-turn(gyroz,Angle_turn);//;
            /*STM32输出给电机用于控制其姿态的PWM应为小车的直立环B＿PWM与速度环V＿PWM之和，
            如果有遥控左右则应该叠加相应的转向环的T＿PWM分别控制左右电机。
            Mt1=BPwm+Ve Pwm-TPwm;∥计算左轮电机最终PWM
            Mt2=BPwm+Ve Pwm+TPwm:∥计算右轮电机最终PWM*/
            
            
            Xianfu_Pwm();                                                                                            //对PWM行限幅
            Set_Pwm(Moto1,Moto2);      
}

**//添加了消息队列，还是狂转**
#include "main.h"


/* 定义消息队列结构体 */
typedef struct {
    float gyroz;
      short gyrox;
    float roll;
    int L_Speed;
    int R_Speed;
} SensorData_t;

typedef struct {
//    float pitch;
    float roll;
    int L_Speed;
    int R_Speed;
    int Moto1;
    int Moto2;
    int Bluetooth_data;
} DisplayData_t;

//typedef struct {
//    int Bluetooth_data;
//} bluetoothData_t;

QueueHandle_t sensorQueue;  // GetData任务到PID任务的队列
QueueHandle_t displayQueue; // PID任务到Display任务的队列
QueueHandle_t bluetoothQueue; // 蓝牙数据队列






//int L_Speed,R_Speed;
//float pitch,roll,yaw;         //欧拉角
//short aacx,aacy,aacz;        //加速度传感器原始数据
//short gyrox,gyroy,gyroz;    //陀螺仪原始数据
int Bluetooth_data = 0;
u8 stop_flag=0;
//extern int Moto1,Moto2;


TaskHandle_t start_task_handle;
#define START_TASK_STACK 128
#define START_TASK_PRIORITY 1
void App_Task_Start(void *pvParameters);

/* 获取姿态数据的任务配置 */
TaskHandle_t data_task_handle;
#define DATA_TASK_STACK 384
#define DATA_TASK_PRIORITY 4
void App_Task_GetData(void *pvParameters);

/* 进行PID控制的任务配置 */
TaskHandle_t pid_task_handle;
#define PID_TASK_STACK 384
#define PID_TASK_PRIORITY 5
void App_Task_PID(void *pvParameters);

/* 进行oled显示的任务配置 */
TaskHandle_t display_task_handle;
#define DISPLAY_TASK_STACK 256
#define DISPLAY_TASK_PRIORITY 3
void App_Task_Display(void *pvParameters);

void App_Task_Init(void)
{            
        /* 创建消息队列 */
    sensorQueue = xQueueCreate(1, sizeof(SensorData_t));
    displayQueue = xQueueCreate(1, sizeof(DisplayData_t));
    bluetoothQueue = xQueueCreate(5, sizeof(int)); // 假设蓝牙数据为整数
    
    
    /* 1. 创建启动任务 */
    xTaskCreate(
        (TaskFunction_t)App_Task_Start,
        (char *)"App_Task_Start",
        (configSTACK_DEPTH_TYPE)START_TASK_STACK,
        (void *)NULL,
        (UBaseType_t)START_TASK_PRIORITY,
        (TaskHandle_t *)&start_task_handle);
            
    /* 2. 启动调度器 */
    vTaskStartScheduler();
}

/**
 * @description: 启动任务：用于创建其他任务
 * @param {void *} pvParameters
 * @return {*}
 */
void App_Task_Start(void *pvParameters)
{        BaseType_t xReturn = pdPASS;
    taskENTER_CRITICAL();
    xReturn=xTaskCreate(
        (TaskFunction_t)App_Task_GetData,
        (char *)"App_Task_GetData",
        (configSTACK_DEPTH_TYPE)DATA_TASK_STACK,
        (void *)NULL,
        (UBaseType_t)DATA_TASK_PRIORITY,
        (TaskHandle_t *)&data_task_handle);
            if(xReturn==pdPASS)
            printf("GetData TASK SUCCEED!\r\n");
            
    xReturn=xTaskCreate(
        (TaskFunction_t)App_Task_PID,
        (char *)"App_Task_PID",
        (configSTACK_DEPTH_TYPE)PID_TASK_STACK,
        (void *)NULL,
        (UBaseType_t)PID_TASK_PRIORITY,
        (TaskHandle_t *)&pid_task_handle);
            if(xReturn==pdPASS)
            printf("PID TASK SUCCEED!\r\n");
            
    xReturn=xTaskCreate(
        (TaskFunction_t)App_Task_Display,
        (char *)"App_Task_Display",
        (configSTACK_DEPTH_TYPE)DISPLAY_TASK_STACK,
        (void *)NULL,
        (UBaseType_t)DISPLAY_TASK_PRIORITY,
        (TaskHandle_t *)&display_task_handle);
            if(xReturn==pdPASS)
            printf("OLED TASK SUCCEED!\r\n");
            
    vTaskDelete(NULL);
    taskEXIT_CRITICAL();
}

/**
 * @description: 获取姿态数据：角度、编码器值
 * @param {void} *pvParameters
 * @return {*}
 */

void App_Task_GetData(void *pvParameters) {
    SensorData_t sensorData;
    float pitch, roll, yaw;
    short gyrox, gyroy, gyroz;

    while (1) {
        ulTaskNotifyTake(pdTRUE, portMAX_DELAY);

        if (mpu_dmp_get_data(&pitch, &roll, &yaw) == 0) {
            MPU_Get_Gyroscope(&gyrox, &gyroy, &gyroz);
        }
        int L_Speed = Read_Encoder(3);
        int R_Speed = Read_Encoder(4);

        /* 填充传感器数据结构 */
        sensorData.gyroz = gyroz;
                sensorData.gyrox = gyrox;
        sensorData.roll = roll;
        sensorData.L_Speed = L_Speed;
        sensorData.R_Speed = R_Speed;

        /* 发送到PID队列（覆盖旧数据） */
        xQueueOverwrite(sensorQueue, &sensorData);
    }
}

/**
 * @description: 进行PID控制的任务
 * @param {void} *pvParameters
 * @return {*}
 */
void App_Task_PID(void *pvParameters) {
    SensorData_t sensorData;
    DisplayData_t displayData;
        int Target,received_cmd;
        float Angle_turn = 0;
      
    while (1) {
        if (xQueueReceive(sensorQueue, &sensorData, portMAX_DELAY) == pdPASS) {
                    
                    /* 处理蓝牙指令队列 */
           while(xQueueReceive(bluetoothQueue, &received_cmd, 0) == pdPASS) {
                Bluetooth_data = received_cmd;  // 同步到全局变量
                            
                switch(Bluetooth_data) {
                    case 0x00:  // 刹车
                        Target = 0;
                        Angle_turn = 0;
                        break;
                    case 0x11:  // 前进
                        Target++;
                        break;
                    case 0x12:  // 后退
                        Target--;
                        break;
                    case 0x13:  // 左转
                        Angle_turn -= 5.0f;  // 每收到一次左转指令增加5度
                        break;
                    case 0x14:  // 右转
                        Angle_turn += 5.0f;
                        break;
                }
                Xianfu_Pwm(); // 限幅操作
            }
         

                /* PID计算 */
            pid.Pv = sensorData.roll * 10;
            stop_flag = Turn_Off(pid.Pv) ? 1 : 0;

            int Moto1 = balance(pid.Pv,sensorData.gyrox) + Velocity(Target, sensorData.L_Speed, sensorData.R_Speed) + turn(sensorData.gyroz, Angle_turn);
            int Moto2 = balance(pid.Pv,sensorData.gyrox) + Velocity(Target, sensorData.L_Speed, sensorData.R_Speed)- turn(sensorData.gyroz, Angle_turn);
            Xianfu_Pwm();
            Set_Pwm(Moto1, Moto2);

         

            /* 填充显示数据结构 */
//            displayData.pitch = sensorData.pitch;
            displayData.roll = sensorData.roll;
            displayData.L_Speed = sensorData.L_Speed;
            displayData.R_Speed = sensorData.R_Speed;
            displayData.Moto1 = Moto1;
            displayData.Moto2 = Moto2;
            displayData.Bluetooth_data = Bluetooth_data;

            /* 发送到显示队列 */
            xQueueOverwrite(displayQueue, &displayData);
        }
    }
}
/**
 * @description: OLED显示任务
 * @param {void} *pvParameters
 * @return {*}
 */
void App_Task_Display(void *pvParameters) {
    DisplayData_t displayData;

    while (1) {
        if (xQueueReceive(displayQueue, &displayData, portMAX_DELAY) == pdPASS) {
            OLED_ShowString(1, 1, "L:");
            OLED_ShowSignedNum(1, 3, displayData.L_Speed, 2);
            OLED_ShowString(1, 9, "R:");
            OLED_ShowSignedNum(1, 11, displayData.R_Speed, 2);
            OLED_ShowString(2, 1, "x:");
//            OLED_ShowSignedNum(2, 3, displayData.pitch, 2);
            OLED_ShowString(2, 9, "y:");
            OLED_ShowSignedNum(2, 11, displayData.roll, 2);
            OLED_ShowString(3, 1, "Blue:");
            OLED_ShowNum(3, 6, displayData.Bluetooth_data, 4);
        }
    }
}

void EXTI9_5_IRQHandler(void) {
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    if (EXTI_GetITStatus(EXTI_Line8) == SET) {
//            printf("PWM" );
        // 发送通知前检查任务句柄有效性
        if (data_task_handle != NULL) {
            xTaskNotifyFromISR(data_task_handle, 0, eNoAction, &xHigherPriorityTaskWoken);
        }
        EXTI_ClearITPendingBit(EXTI_Line8);
        portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
    }
}


//u8 Fore,Back,Left,Right;
void USART2_IRQHandler(void) {
       BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    int received_data = 0;  // 使用局部变量暂存接收数据
    
    if(USART_GetITStatus(USART2, USART_IT_RXNE) != RESET) {
        received_data = USART_ReceiveData(USART2);
        Bluetooth_data = received_data;  // 更新全局变量
        xQueueSendFromISR(bluetoothQueue, &received_data, &xHigherPriorityTaskWoken);
        portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
    }
}

写回答
好问题 0 提建议
关注问题
分享
邀请回答
编辑收藏删除
收藏举报

5条回答默认最新

关注

码龄粉丝数原力等级 --

被采纳

被点赞

采纳率
阿里嘎多学长 2025-03-14 18:43
关注
阿里嘎多学长整理AIGC生成，因移动端显示问题导致当前答案未能完全显示，请使用PC端查看更加详细的解答过程

STM32及FreeRTOS的平衡小车

你想将STM32的裸机程序改为FreeRTOS的三个任务，分别负责数据读取、PID控制和OLED显示。裸机程序在每次接收到6050的中断中执行，数据读取、PID输出PWM，进行控制。

解决方案：

首先，需要安装FreeRTOS库，并将其集成到STM32项目中。
创建三个任务：数据读取任务、PID控制任务和OLED显示任务。
在数据读取任务中，使用中断处理函数来处理6050的中断，读取数据，并将数据传递给PID控制任务。
在PID控制任务中，使用PID算法来控制小车的速度和方向，并将控制信号传递给PWM输出任务。
在OLED显示任务中，使用OLED显示屏来显示小车的状态信息，例如速度、方向等。
使用FreeRTOS的调度机制来调度三个任务，确保任务之间的同步和协作。

核心代码：

#include "FreeRTOS.h" #include "task.h" #include "queue.h" // 数据读取任务 void dataReadTask(void *pvParameter) { while (1) { // 读取6050的数据 uint16_t data = read6050(); // 将数据传递给PID控制任务 xQueueSend(pidQueue, &data, portMAX_DELAY); } } // PID控制任务 void pidTask(void *pvParameter) { while (1) { // 从队列中读取数据 uint16_t data = xQueueReceive(pidQueue, NULL, portMAX_DELAY); // 使用PID算法来控制小车的速度和方向 float pidOutput = pidAlgorithm(data); // 将控制信号传递给PWM输出任务 xQueueSend(pwmQueue, &pidOutput, portMAX_DELAY); } } // OLED显示任务 void oledTask(void *pvParameter) { while (1) { // 从队列中读取控制信号 float pidOutput = xQueueReceive(pwmQueue, NULL, portMAX_DELAY); // 使用OLED显示屏来显示小车的状态信息 oledDisplay(pidOutput); } }

注意：上述代码只是一个示例，需要根据实际情况进行修改和优化。
本回答被题主选为最佳回答 , 对您是否有帮助呢?

解决无用
评论打赏
分享
举报

评论

按下Enter换行，Ctrl+Enter发表内容

查看更多回答(4条)

报告相同问题？

关注问题

STM32+FreeRTOS智能小车项目
2025-08-18 10:39

本项目基于STM32F407ZGT6微控制器和FreeRTOS实时操作系统，设计了一款多功能智能小车系统，集成了环境感知、自主导航、无线控制和机器视觉等先进功能。硬件系统采用模块化架构设计，主控芯片通过CAN总线协调四个直流...
stm32-freertos系统小车keil5工程
2024-11-21 11:39

STM32 控制器：作为核心部件，例如 STM32F103 或 STM32F4 系列。它负责运行 FreeRTOS 操作系统和控制智能小车的各个硬件模块。其内部的 Cortex - M 内核具有足够的处理能力来应对多任务调度和复杂的控制算法。电机...
STM32F103+FreeRTOS智能小车项目
2025-08-22 15:14

本项目基于高性能的ARM Cortex-M3内核微控制器STM32F103作为核心控制单元，并移植了开源的FreeRTOS实时操作系统，构建了一个稳定、高效且功能丰富的智能小车平台。在硬件架构上，STM32F103负责统筹管理各类外围...
基于STM32及FreeRTOS的平衡小车，微信小程序控制
2023-11-27 14:40

驱动层负责处理STM32的硬件接口，中间件层如FreeRTOS提供任务调度，应用层则包含平衡算法、用户界面（微信小程序）通信等功能。 2. **AD设计图**：AD（AutoCAD或Altium Designer）设计图用于电路板设计，包括元器件...
亚博智能STM32蓝牙平衡小车代码
2022-01-30 18:40

在这个项目中，"亚博智能STM32蓝牙平衡小车代码" 提供了一个使用STM32实现的具有蓝牙功能的自平衡小车的软件解决方案。首先，我们要理解平衡小车的工作原理。平衡小车主要依赖陀螺仪和加速度计来感知车辆的姿态，...
基于stm32和freertos的智能小车.zip
2025-10-30 11:47

对于学生或爱好者来说，制作基于STM32和FreeRTOS的智能小车是一个很好的学习项目。这个项目不仅能够帮助他们理解嵌入式系统的架构，还能提供实践中的问题解决经验。在不断调试和优化智能小车的过程中，他们将学会...
基于FreeRTOS的STM32平衡小车.zip
2025-10-31 13:35

基于FreeRTOS的STM32平衡小车项目是一套针对STM32微控制器的嵌入式开发实战项目，该项目采用实时操作系统FreeRTOS来驱动STM32微控制器。STM32作为高性能、低功耗的ARM Cortex-M系列微控制器，广泛应用于工业控制、...
基于FreeRTOS+STM32设计的超声波智能避障平衡小车-实现了小车的自平衡、超声波避障以及通过智能手机远程控制的功能
2024-03-29 10:06

基于FreeRTOS的STM32超声波智能避障平衡小车，实现了小车的自平衡、超声波避障以及通过智能手机远程控制的功能。本工程基于FreeRTOS开发嵌入式优质项目，资源经过严格测试可直接运行成功且功能正常的情况才上传，可...
基于stm32和freertos的wifi智能小车2.zip
2025-10-30 11:47

开发基于STM32和FreeRTOS的WiFi智能小车，不仅要掌握嵌入式系统的开发技能，还需要对机械结构和电子电路有一定的了解。小车的机械结构设计要保证足够的稳定性和灵活性，电子电路设计则需要考虑电源管理、信号处理等...
stm32f4平衡小车
2021-01-11 21:15

STM32F4平衡小车项目是一个典型的嵌入式系统应用，主要利用STM32F4系列微控制器的高性能和丰富的外设接口来实现小车的动态平衡控制。在这个项目中，我们将深入探讨STM32F4微控制器、传感器技术、电机驱动、PID控制...
没有解决我的问题, 去提问

问题事件

关注

码龄粉丝数原力等级 --

被采纳

被点赞

采纳率
系统已结题 8月10日
关注

码龄粉丝数原力等级 --

被采纳

被点赞

采纳率
已采纳回答 8月2日
关注

码龄粉丝数原力等级 --

被采纳

被点赞

采纳率
修改了问题 3月15日
关注

码龄粉丝数原力等级 --

被采纳

被点赞

采纳率
创建了问题 3月14日

STM32及FreeRTOS的平衡小车

5条回答 默认 最新

STM32及FreeRTOS的平衡小车

问题事件

5条回答默认最新