void go_to_xy(float target_x, float target_y) 的函数发现执行时，只执行了第一阶段。考虑运用switch函数解决，可以使用别的方法#include <math.h> // 添加数学库用于fabs函数
#include "board.h"
#include "my_key.h"
#include "my_time.h"
#include "ti_msp_dl_config.h"
#include "oled.h"
#define _USE_MATH_DEFINES
#define WHEEL_BASE 80.0f
#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif
void BUZZY_OFF(void) { DL_GPIO_setPins(BUZZY_PORT, BUZZY_PIN_PIN); }
void BUZZY_ON(void) { DL_GPIO_clearPins(BUZZY_PORT, BUZZY_PIN_PIN); }
void refresh_oled(void);
void key(void);
void go_straight(int dis);
void go_arc_ccd(hsu_time_t);
void go_brc_ccd(hsu_time_t);
void turn_90_degrees(int direction);
void turn_in_place(float angle);
void go_to_xy(float target_x, float target_y);
void sound_light_alert(void);
void show_task_now(void);
u8 Car_Mode = Diff_Car;
int Motor_Left, Motor_Right; // 电机PWM变量 应是Motor的
u8 PID_Send; // 延时和调参相关变量
float RC_Velocity = 200, RC_Turn_Velocity, Move_X, Move_Y, Move_Z, PS2_ON_Flag; // 遥控控制的速度
float Velocity_Left, Velocity_Right; // 车轮速度(mm/s)
u16 test_num, show_cnt;
float Voltage = 0;
extern float Yaw; // 声明外部YAW角度变量
int64_t left_encoder = 0, right_encoder = 0;
void SysTick_Handler(void) { hsu_time_systick_handler(); }
typedef enum { BEGIN, T1, T2, T3, T4 } TaskState;
typedef enum { STOP, GO_STRAIGHT, GO_CCD, TURN_IN_PLACE, TURN_90_DEGREES, WAIT_ALERT } DoingWhat;
typedef struct __TASK_NAMESPACE {
uint8_t is;
uint8_t is_running;
uint8_t finish;
uint8_t sub_finish;
uint8_t running_state; // 0: 停止, 1: 运行中
TaskState state;
DoingWhat doing_what;
float target;
float vx;
float vz;
// 用于复杂任务
uint8_t sub_task_stage; // 子任务阶段
uint8_t lap_count; // 圈数计数
int64_t start_encoder; // 起始编码器值
uint32_t alert_start_time; // 声光提示开始时间
float start_yaw; // 起始YAW角度
float target_yaw_diff; // 目标YAW角度差
hsu_time_t ccd_end_time;
float target_x; // 目标X坐标 (毫米)
float target_y; // 目标Y坐标 (毫米)
float current_x; // 当前X坐标 (毫米)
float current_y; // 当前Y坐标 (毫米)
int64_t rotation_start_left; // 旋转开始时左轮编码器值
int64_t rotation_start_right; // 旋转开始时右轮编码器值
float target_rotation; // 目标旋转量（弧度）
} TaskNamespace;
void reset_task_namespace(TaskNamespace *t) {
t->is_running = 0;
t->finish = 0;
t->sub_finish = 0;
t->state = BEGIN;
t->doing_what = STOP;
t->vx = 0;
t->vz = 0;
t->sub_task_stage = 0;
t->lap_count = 0;
t->start_encoder = left_encoder;
t->alert_start_time = 0;
t->start_yaw = 0;
t->target_yaw_diff = 0;
t->running_state = 0; // 明确重置运行状态为0
t->ccd_end_time = 0;
t->is = 0;
// 初始化坐标
t->target_x = 0.0f;
t->target_y = 0.0f;
t->current_x = 0.0f;
t->current_y = 0.0f;
t->rotation_start_left = 0;
t->rotation_start_right = 0;
t->target_rotation = 0.0f;
}
void next_state(TaskNamespace *t) {
TaskState last_state = t->state;
reset_task_namespace(t);
if (last_state < T4) {
t->state = last_state + 1;
}
}
TaskNamespace task_namespace;
void show_task_now(void) {
//OLED_ShowString(0, 0, "Task Now:");
switch (task_namespace.state) {
case BEGIN:
OLED_ShowString(1, 10,"0");
break;
case T1:
OLED_ShowString(1, 10,"1");
break;
case T2:
OLED_ShowString(1, 10,"2");
break;
case T3:
OLED_ShowString(1, 10,"3");
break;
case T4:
OLED_ShowString(1, 10,"4");
break;
default:
break;
}
}
void main_task(void);
int main(void) {
// 系统初始化
SYSCFG_DL_init(); // 初始化系统配置
hsu_time_init(); // 时间
// 清除所有外设的中断挂起状态
NVIC_ClearPendingIRQ(ENCODERA_INT_IRQN); // 编码器A中断
NVIC_ClearPendingIRQ(ENCODERB_INT_IRQN); // 编码器B中断
NVIC_ClearPendingIRQ(UART_0_INST_INT_IRQN); // UART0串口中断
// 使能各外设的中断
NVIC_EnableIRQ(ENCODERA_INT_IRQN); // 开启编码器A中断
NVIC_EnableIRQ(ENCODERB_INT_IRQN); // 开启编码器B中断
NVIC_EnableIRQ(UART_0_INST_INT_IRQN); // 开启UART0中断
reset_task_namespace(&task_namespace);
task_namespace.state = BEGIN; // 明确设置初始状态
// 定时器和ADC相关中断配置
NVIC_ClearPendingIRQ(TIMER_0_INST_INT_IRQN); // 清除定时器0中断挂起
NVIC_EnableIRQ(TIMER_0_INST_INT_IRQN); // 开启定时器0中断
NVIC_EnableIRQ(ADC12_VOLTAGE_INST_INT_IRQN);
NVIC_EnableIRQ(ADC12_CCD_INST_INT_IRQN);
OLED_Init(); // 初始化OLED显示屏
OLED_ShowString(1, 1, "Task Now:");
OLED_ShowString(2, 1, "state:");
OLED_ShowString(3, 1, "yaw:");
OLED_ShowString(4, 1, "x:");
OLED_ShowString(4, 6, "y:");
//MPU6050_initialize();
//DMP_Init();
BUZZY_ON();
// 主循环
// printf("Test delay 500us\n");
// hsu_time_delay_us(500);
// printf("Test delay 500us end\n");
uint8_t main_task_timer = hsu_time_timer_create(10, true, main_task);
hsu_time_timer_start(main_task_timer);
uint8_t refresh_oled_timer = hsu_time_timer_create(5, true, refresh_oled);
hsu_time_timer_start(refresh_oled_timer);
uint8_t key_timer = hsu_time_timer_create(2, true, key);
hsu_time_timer_start(key_timer);
while (1) {
hsu_time_timer_process();
RD_TSL(); // 读取CCD数据
Find_CCD_Median(); // 计算CCD数据中值
Read_DMP();
show_task_now();
//DL_GPIO_togglePins(LED_PORT, LED_led_PIN);
// printf("L=%lld R=%lld YAW=%.1f\n", left_encoder, right_encoder, Yaw);
}
}
void task_no(void);
void task_1(void);
void task_2(void);
void task_3(void);
void task_4(void);
void main_task(void) {
if (!(task_namespace.is)) return;
printf("main task\n");
switch (task_namespace.state) {
case BEGIN:
task_no();
break;
case T1:
task_1();
break;
case T2:
task_2();
break;
case T3:
task_3();
break;
case T4:
task_4();
break;
default:
break;
}
switch (task_namespace.doing_what) {
case STOP:
Get_Target_Encoder(0, 0);
break;
case GO_STRAIGHT:
if ((left_encoder * 1.f) < task_namespace.target) {
Get_Target_Encoder(0.6, 0); // 提高速度到600mm/s
} else {
Get_Target_Encoder(0, 0);
task_namespace.doing_what = STOP;
task_namespace.finish = 1;
}
break;
case GO_CCD:
if (task_namespace.ccd_end_time < hsu_time_get_ms()) {
Get_Target_Encoder(0, 0);
task_namespace.doing_what = STOP;
task_namespace.finish = 1;
} else {
CCD_Mode();
}
break;
case TURN_IN_PLACE:
// 原地转向控制
if (task_namespace.target_yaw_diff != 0) {
float current_yaw_diff = Yaw - task_namespace.start_yaw;
// 处理角度跨越±180度的情况
if (current_yaw_diff > 180) {
current_yaw_diff -= 360;
} else if (current_yaw_diff < -180) {
current_yaw_diff += 360;
}
printf("Turn: Start=%.1f Current=%.1f Diff=%.1f Target=%.1f\n", task_namespace.start_yaw, Yaw, current_yaw_diff,
task_namespace.target_yaw_diff);
// 检查是否达到目标角度
if ((task_namespace.target_yaw_diff > 0 && current_yaw_diff >= task_namespace.target_yaw_diff) ||
(task_namespace.target_yaw_diff < 0 && current_yaw_diff <= task_namespace.target_yaw_diff)) {
Get_Target_Encoder(0, 0); // 停止转向
task_namespace.doing_what = STOP;
task_namespace.finish = 1;
} else {
// 继续转向
float turn_speed = (task_namespace.target_yaw_diff > 0) ? 0.1 : -0.1;
Get_Target_Encoder(0, turn_speed);
}
}
break;
case TURN_90_DEGREES: {
// 计算当前旋转角度（使用编码器差值）
float rotation = (left_encoder - task_namespace.rotation_start_left -
(right_encoder - task_namespace.rotation_start_right))
* M_PI / (2 * WHEEL_BASE);
// 检查是否达到目标角度（允许±0.1弧度误差）
if (fabs(rotation - task_namespace.target_rotation) < 0.1f) {
Get_Target_Encoder(0, 0); // 停止旋转
task_namespace.doing_what = STOP;
task_namespace.finish = 1;
} else {
// 控制旋转速度（根据方向调整）
float turn_speed = (task_namespace.target_rotation > 0) ? 0.1f : -0.1f;
Get_Target_Encoder(-turn_speed, turn_speed); // 左右轮反向运动
}
break;
}
case WAIT_ALERT:
Get_Target_Encoder(0, 0); // 停车
if (hsu_time_get_ms() - task_namespace.alert_start_time > 1000) { // 声光提示1秒
task_namespace.doing_what = STOP;
task_namespace.finish = 1;
}
break;
default:
break;
}
}
void task_no(void) { return; }
// 任务1：A点到B点直线行驶
void task_1(void) {
if (!task_namespace.is_running) {
task_namespace.is_running = 1;
task_namespace.sub_task_stage = 0;
task_namespace.finish = 1;
return;
}
if (task_namespace.finish) {
switch (task_namespace.sub_task_stage) {
case 0: // 开始第一阶段：A到B
go_straight(3300);
break;
case 1: // 完成亮灯
DL_GPIO_togglePins(LED_PORT, LED_led_PIN);
break;
case 2: //任务结束
reset_task_namespace(&task_namespace);
task_namespace.running_state = 0; // 重置为停止状态
break;
}
task_namespace.finish = 0;
task_namespace.sub_task_stage++;
}
return;
}
// 任务2：X Y坐标行驶
void task_2(void) {
if (!task_namespace.is_running) {
task_namespace.is_running = 1;
task_namespace.sub_task_stage = 0;
task_namespace.finish = 1;
return;
}
if (task_namespace.finish) {
switch (task_namespace.sub_task_stage) {
case 0: // 运动到XY坐标
go_to_xy(3000.0f, 3000.0f);
break;
case 1: // 完成灯亮
DL_GPIO_togglePins(LED_PORT, LED_led_PIN);
break;
case 2: // 任务结束
sound_light_alert();
reset_task_namespace(&task_namespace);
break;
}
task_namespace.finish = 0;
task_namespace.sub_task_stage++;
}
return;
}
// 任务3：A->C->B->D->A循环
void task_3(void) {
if (!task_namespace.is_running) {
task_namespace.is_running = 1;
task_namespace.sub_task_stage = 0;
task_namespace.finish = 1;
return;
}
if (task_namespace.finish) {
switch (task_namespace.sub_task_stage) {
case 0:
turn_in_place(-31.0f);
break;
case 1:
go_straight(4060);
break;
case 2:
turn_in_place(30.0f);
break;
case 3: // 开始C到B弧线
sound_light_alert();
//go_straight(40);
go_brc_ccd(3550);
break;
case 4:
turn_in_place(36.0f);
break;
case 5:
sound_light_alert();
go_straight(3985);
break;
case 6:
turn_in_place(-40.0f);
break;
case 7: // 开始C到B弧线
sound_light_alert();
go_arc_ccd(3600);
break;
case 8: // D到A弧线完成，任务结束
sound_light_alert();
reset_task_namespace(&task_namespace);
break;
}
task_namespace.finish = 0;
task_namespace.sub_task_stage++;
}
return;
}
// 任务4：重复任务3路径4圈
void task_4(void) {
if (!task_namespace.is_running) {
task_namespace.is_running = 1;
task_namespace.sub_task_stage = 0;
task_namespace.finish = 1;
return;
}
if (task_namespace.finish) {
switch (task_namespace.sub_task_stage) {
case 0:
turn_in_place(-30.0f);
break;
case 1:
go_straight(4045);
break;
case 2:
turn_in_place(29.0f);
break;
case 3: // 开始C到B弧线
sound_light_alert();
//go_straight(40);
go_brc_ccd(5000);
break;
case 4:
turn_in_place(34.0f);
break;
case 5:
sound_light_alert();
go_straight(4035);
break;
case 6:
turn_in_place(-33.0f);
break;
case 7: // 开始C到B弧线
sound_light_alert();
go_arc_ccd(5000);
break;
case 8: // D到A弧线完成，任务结束
sound_light_alert();
reset_task_namespace(&task_namespace);
break;
}
task_namespace.finish = 0;
task_namespace.sub_task_stage++;
}
}
void TIMER_0_INST_IRQHandler(void) {
if (DL_TimerA_getPendingInterrupt(TIMER_0_INST)) {
if (DL_TIMER_IIDX_ZERO) {
Get_Velocity_From_Encoder(Get_Encoder_countA, Get_Encoder_countB);
Get_Encoder_countA = Get_Encoder_countB = 0;
MotorA.Motor_Pwm = Incremental_PI_Left(MotorA.Current_Encoder, MotorA.Target_Encoder);
MotorB.Motor_Pwm = Incremental_PI_Right(MotorB.Current_Encoder, MotorB.Target_Encoder);
if (!Flag_Stop) {
Set_PWM(-MotorA.Motor_Pwm, -MotorB.Motor_Pwm);
} else {
Set_PWM(0, 0);
}
}
}
}
uint32_t gpio_interrup1, gpio_interrup2;
int64_t B1, B2, B3, B4;
int64_t A1, A2, A3, A4;
void GROUP1_IRQHandler(void) {
// 获取中断信号
gpio_interrup1 = DL_GPIO_getEnabledInterruptStatus(ENCODERA_PORT, ENCODERA_E1A_PIN | ENCODERA_E1B_PIN);
gpio_interrup2 = DL_GPIO_getEnabledInterruptStatus(ENCODERB_PORT, ENCODERB_E2A_PIN | ENCODERB_E2B_PIN);
// encoderB
if ((gpio_interrup1 & ENCODERA_E1A_PIN) == ENCODERA_E1A_PIN) {
if (!DL_GPIO_readPins(ENCODERA_PORT, ENCODERA_E1B_PIN)) {
right_encoder--;
Get_Encoder_countB--;
} else {
right_encoder++;
Get_Encoder_countB++;
}
} else if ((gpio_interrup1 & ENCODERA_E1B_PIN) == ENCODERA_E1B_PIN) {
if (!DL_GPIO_readPins(ENCODERA_PORT, ENCODERA_E1A_PIN)) {
right_encoder++;
Get_Encoder_countB++;
} else {
right_encoder--;
Get_Encoder_countB--;
}
}
// encoderA
if ((gpio_interrup2 & ENCODERB_E2A_PIN) == ENCODERB_E2A_PIN) {
if (!DL_GPIO_readPins(ENCODERB_PORT, ENCODERB_E2B_PIN)) {
left_encoder++;
Get_Encoder_countA--;
} else {
left_encoder--;
Get_Encoder_countA++;
}
} else if ((gpio_interrup2 & ENCODERB_E2B_PIN) == ENCODERB_E2B_PIN) {
if (!DL_GPIO_readPins(ENCODERB_PORT, ENCODERB_E2A_PIN)) {
left_encoder--;
Get_Encoder_countA++;
} else {
left_encoder++;
Get_Encoder_countA--;
}
}
DL_GPIO_clearInterruptStatus(ENCODERA_PORT, ENCODERA_E1A_PIN | ENCODERA_E1B_PIN);
DL_GPIO_clearInterruptStatus(ENCODERB_PORT, ENCODERB_E2A_PIN | ENCODERB_E2B_PIN);
}
// 直线行驶函数
void go_straight(int dis) {
task_namespace.doing_what = GO_STRAIGHT;
task_namespace.target = left_encoder + dis;
task_namespace.finish = 0;
}
// 原地转向函数
void turn_in_place(float angle) {
task_namespace.doing_what = TURN_IN_PLACE;
task_namespace.start_yaw = Yaw;
task_namespace.target_yaw_diff = angle; // 正值右转，负值左转
task_namespace.finish = 0;
}
// CCD巡线函数（需要外部条件结束）
void go_ccd_line(void) {
task_namespace.doing_what = GO_CCD;
task_namespace.start_encoder = left_encoder;
task_namespace.finish = 0;
// 设置一个安全的最大距离，防止无限巡线
// 可以根据实际场地调整这个值
static uint32_t ccd_end_time = 0;
if (ccd_end_time == 0) {
ccd_end_time = hsu_time_get_ms();
}
// 如果巡线时间超过10秒或距离超过2000mm，强制结束
if (hsu_time_get_ms() - ccd_end_time > 10000 || (left_encoder * 1.f - task_namespace.start_encoder) > 2000) {
task_namespace.finish = 1;
ccd_end_time = 0;
}
}
// 弧线CCD巡线函数
void go_arc_ccd(hsu_time_t time) {
task_namespace.doing_what = GO_CCD;
task_namespace.start_encoder = left_encoder;
task_namespace.ccd_end_time = hsu_time_get_ms() + time;
}
void go_brc_ccd(hsu_time_t time) {
task_namespace.doing_what = GO_CCD;
task_namespace.start_encoder = right_encoder;
task_namespace.ccd_end_time = hsu_time_get_ms() + time;
}
// 旋转90度函数
/*void turn_90_degrees(int direction) {
// direction: 1为顺时针，-1为逆时针
turn_in_place(90.0f * direction);
}*/
// 运动到指定坐标函数
void go_to_xy(float target_x, float target_y) {
task_namespace.sub_task_stage = 0; // 重置子任务阶段
// 第一阶段：运动到X坐标
float x_distance = target_x - task_namespace.current_x;
go_straight((int)fabs(x_distance)); // 使用绝对值距离
// 更新当前坐标
task_namespace.current_x = target_x;
// 第二阶段：旋转90度（方向根据Y坐标位置决定）
int direction = (target_y > task_namespace.current_y) ? 1 : -1;
turn_90_degrees(direction);
// 第三阶段：运动到Y坐标
float y_distance = target_y - task_namespace.current_y;
go_straight((int)fabs(y_distance)); // 使用绝对值距离
// 更新当前坐标
task_namespace.current_y = target_y;
}
// 旋转90度函数（使用编码器计算）
void turn_90_degrees(int direction) {
// 保存旋转开始时的编码器值
task_namespace.rotation_start_left = left_encoder;
task_namespace.rotation_start_right = right_encoder;
// 计算目标旋转量（90度 = π/2 弧度）
// 假设轮距为120mm（根据实际小车尺寸调整）
#define WHEEL_BASE 80.0f
task_namespace.target_rotation = (direction > 0) ? (M_PI/2) : (-M_PI/2);
// 设置状态为旋转
task_namespace.doing_what = TURN_90_DEGREES;
task_namespace.finish = 0;
}
// 声光提示函数
void sound_light_alert(void) {
DL_GPIO_togglePins(LED_PORT, LED_led_PIN);
DL_GPIO_setPins(BUZZY_PORT, BUZZY_PIN_PIN);
uint32_t start_time = hsu_time_get_ms();
while (hsu_time_get_ms() - start_time < 1000) {
// 空循环等待1秒
}
//hsu_time_delay_ms(200);
DL_GPIO_togglePins(LED_PORT, LED_led_PIN);
DL_GPIO_clearPins(BUZZY_PORT, BUZZY_PIN_PIN);
}
// callback
void refresh_oled(void) {
show_task_now();
OLED_ShowString(2, 1, "state:");
if (task_namespace.running_state) {
OLED_ShowString(2, 7, "1"); // 运行中
} else {
OLED_ShowString(2, 7, "0"); // 停止
}
}
uint32_t key_get_tick_ms(void) { return hsu_time_get_ms(); }
void key(void) {
key_event_t event = key_scan();
//uint8_t key_value = key_read_pin(); // 获取按键状态
//S1
switch (event) {
case KEY_EVENT_SINGLE_CLICK:
next_state(&task_namespace);
break;
case KEY_EVENT_DOUBLE_CLICK:
task_namespace.is = 1;
task_namespace.running_state = 1;
task_namespace.is_running = 0; // 重置任务运行标志
break;
}
}
扫一扫
257
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
