1
#include "motor.h"
2
#include <iso646.h>
3

4
/**
5
  * @brief      电机启动
6
  * @param        None
7
  * @retval     None
8
  */
9
void Motor_On(void)
10
{
11
    DL_GPIO_setPins(GPIO_MOTOR_PIN_FSTBY_PORT, GPIO_MOTOR_PIN_FSTBY_PIN);//置位对应端口->引脚电平,STBY
12
}
13

14
/**
15
  * @brief        电机关闭
16
  * @param        None
17
  * @retval     None
18
  */
19
void Motor_Off(void)
20
{
21
    DL_GPIO_clearPins(GPIO_MOTOR_PIN_FSTBY_PORT, GPIO_MOTOR_PIN_FSTBY_PIN);//清除对应端口->引脚电平，STBY
22
    //逻辑口电平清除
23
    DL_GPIO_clearPins(GPIO_MOTOR_PIN_FL1_PORT, GPIO_MOTOR_PIN_FL1_PIN);
24
    DL_GPIO_clearPins(GPIO_MOTOR_PIN_FL2_PORT, GPIO_MOTOR_PIN_FL2_PIN);
25
    DL_GPIO_clearPins(GPIO_MOTOR_PIN_FR1_PORT, GPIO_MOTOR_PIN_FR1_PIN);
26
    DL_GPIO_clearPins(GPIO_MOTOR_PIN_FR2_PORT, GPIO_MOTOR_PIN_FR2_PIN);
27
}
28

29
/**
30
  * @brief      速度设置
31
  * @param        左右轮占空比（百分值）
32
  * @retval       None
33
  */
34
void Set_Speed(float duty1,float duty2)
35
{
36
    uint32_t compareValue = 0;//比较值最大为3199，最小值为0
37
    if(duty1 < 0)
38
    {
39
        //PWM定时器向下计数，比较值计算
40
        compareValue = 3199 - 3199 * (-duty1/100.0);
41
        //比较值设置
42
        DL_TimerA_setCaptureCompareValue(PWM_MOTOR_INST, compareValue, DL_TIMER_CC_0_INDEX);
43
        //电机逻辑引脚设置
44
        DL_GPIO_setPins(GPIO_MOTOR_PIN_FL2_PORT, GPIO_MOTOR_PIN_FL2_PIN);
45
        DL_GPIO_clearPins(GPIO_MOTOR_PIN_FL1_PORT, GPIO_MOTOR_PIN_FL1_PIN);
46

47
    }
48
    else if(duty1 > 0)
49
    {
50
        compareValue = 3199 - 3199 * (duty1/100.0);
51
        DL_TimerA_setCaptureCompareValue(PWM_MOTOR_INST, compareValue, DL_TIMER_CC_0_INDEX);
52
        DL_GPIO_setPins(GPIO_MOTOR_PIN_FL1_PORT, GPIO_MOTOR_PIN_FL1_PIN);
53
        DL_GPIO_clearPins(GPIO_MOTOR_PIN_FL2_PORT, GPIO_MOTOR_PIN_FL2_PIN);
54
    }
55
    else
56
    {
57
        DL_GPIO_clearPins(GPIO_MOTOR_PIN_FL1_PORT, GPIO_MOTOR_PIN_FL1_PIN);
58
        DL_GPIO_clearPins(GPIO_MOTOR_PIN_FL2_PORT, GPIO_MOTOR_PIN_FL2_PIN);
59
    }
60

61
    if(duty2 < 0)
62
    {
63
        compareValue = 3199 - 3199 * (-duty2/100.0);
64
        DL_TimerA_setCaptureCompareValue(PWM_MOTOR_INST, compareValue, DL_TIMER_CC_1_INDEX);
65
        DL_GPIO_setPins(GPIO_MOTOR_PIN_FR2_PORT, GPIO_MOTOR_PIN_FR2_PIN);
66
        DL_GPIO_clearPins(GPIO_MOTOR_PIN_FR1_PORT, GPIO_MOTOR_PIN_FR1_PIN);
67

68

69
    }
70
    else if(duty2 > 0)
71
    {
72
        compareValue = 3199 - 3199 * (duty2/100.0);
73
        DL_TimerA_setCaptureCompareValue(PWM_MOTOR_INST, compareValue, DL_TIMER_CC_1_INDEX);
74
        DL_GPIO_setPins(GPIO_MOTOR_PIN_FR1_PORT, GPIO_MOTOR_PIN_FR1_PIN);
75
        DL_GPIO_clearPins(GPIO_MOTOR_PIN_FR2_PORT, GPIO_MOTOR_PIN_FR2_PIN);
76
    }
77
    else
78
    {
79
        DL_GPIO_clearPins(GPIO_MOTOR_PIN_FR1_PORT, GPIO_MOTOR_PIN_FR1_PIN);
80
        DL_GPIO_clearPins(GPIO_MOTOR_PIN_FR2_PORT, GPIO_MOTOR_PIN_FR2_PIN);
81
    }
82
}

1
#include "ti_msp_dl_config.h"
2

3
//宏定义简化写法
4
#define AIN1(x)   x?DL_GPIO_setPins(GPIO_MOTOR_PIN_FL1_PORT, GPIO_MOTOR_PIN_FL1_PIN):DL_GPIO_clearPins(GPIO_MOTOR_PIN_FL1_PORT, GPIO_MOTOR_PIN_FL1_PIN)
5
#define AIN2(x)   x?DL_GPIO_setPins(GPIO_MOTOR_PIN_FL2_PORT, GPIO_MOTOR_PIN_FL2_PIN):DL_GPIO_clearPins(GPIO_MOTOR_PIN_FL2_PORT, GPIO_MOTOR_PIN_FL2_PIN)
6
#define BIN1(x)   x?DL_GPIO_setPins(GPIO_MOTOR_PIN_FR1_PORT, GPIO_MOTOR_PIN_FR1_PIN):DL_GPIO_clearPins(GPIO_MOTOR_PIN_FR1_PORT, GPIO_MOTOR_PIN_FR1_PIN)
7
#define BIN2(x)   x?DL_GPIO_setPins(GPIO_MOTOR_PIN_FR2_PORT, GPIO_MOTOR_PIN_FR2_PIN):DL_GPIO_clearPins(GPIO_MOTOR_PIN_FR2_PORT, GPIO_MOTOR_PIN_FR2_PIN)
8

9
void Motor_On(void);
10
void Motor_Off(void);
11
void Set_Speed(float duty1,float duty2);

1
#include "ti_msp_dl_config.h"
2
#include "Delay.h"
3

4
// 定义接收变量
5
uint8_t RollL, RollH, PitchL, PitchH, YawL, YawH, VL, VH, SUM;
6
float Pitch,Roll,Yaw;
7
// 串口接收状态标识
8
#define WAIT_HEADER1 0
9
#define WAIT_HEADER2 1
10
#define RECEIVE_DATA 2
11

12
uint8_t RxState_JY = WAIT_HEADER1;
13
uint8_t receivedData[9];
14
uint8_t dataIndex = 0;
15

16
//发送置偏航角置零命令
17
void Serial_JY61P_Zero_Yaw(void){
18
    DL_UART_Main_transmitDataBlocking(UART_JY61P_INST,0XFF);
19
  DL_UART_Main_transmitDataBlocking(UART_JY61P_INST,0XAA);
20
  DL_UART_Main_transmitDataBlocking(UART_JY61P_INST,0X69);
21
  DL_UART_Main_transmitDataBlocking(UART_JY61P_INST,0X88);
22
  DL_UART_Main_transmitDataBlocking(UART_JY61P_INST,0XB5);
23
  delay_ms(100);
24
  DL_UART_Main_transmitDataBlocking(UART_JY61P_INST,0XFF);
25
  DL_UART_Main_transmitDataBlocking(UART_JY61P_INST,0XAA);
26
  DL_UART_Main_transmitDataBlocking(UART_JY61P_INST,0X01);
27
  DL_UART_Main_transmitDataBlocking(UART_JY61P_INST,0X04);
28
  DL_UART_Main_transmitDataBlocking(UART_JY61P_INST,0X00);
29
  delay_ms(100);
30
  DL_UART_Main_transmitDataBlocking(UART_JY61P_INST,0XFF);
31
  DL_UART_Main_transmitDataBlocking(UART_JY61P_INST,0XAA);
32
  DL_UART_Main_transmitDataBlocking(UART_JY61P_INST,0X00);
33
  DL_UART_Main_transmitDataBlocking(UART_JY61P_INST,0X00);
34
  DL_UART_Main_transmitDataBlocking(UART_JY61P_INST,0X00);
35

36
}

1
#ifndef __JY61P_H
2
#define __JY61P_H
3

4
void Serial_JY61P_Zero_Yaw(void);
5
void UART_JY61P_INST_IRQHandler(void);
6
extern float Pitch,Roll,Yaw;
7
#endif

1
//系统串口初始化
2
void SYS_UART0_Init(void)
3
{
4
  NVIC_ClearPendingIRQ(UART_0_INST_INT_IRQN);
5
  NVIC_EnableIRQ(UART_0_INST_INT_IRQN);
6
    DL_UART_clearInterruptStatus(UART_0_INST,DL_UART_INTERRUPT_RX);//清除中断标志位
7
}
8

9
//SOC通信串口初始化
10
void SOC_UART1_Init(void)
11
{
12
  NVIC_ClearPendingIRQ(UART_SOC_INST_INT_IRQN);
13
  NVIC_EnableIRQ(UART_SOC_INST_INT_IRQN);
14
    DL_UART_clearInterruptStatus(UART_SOC_INST,DL_UART_INTERRUPT_RX);//清除中断标志位
15
}
16

17
//发送字符串给SOC
18
void SOC_SendString(char *str)
19
{
20
    while(*str != '\0')
21
    {
22
        DL_UART_Main_transmitDataBlocking(UART_SOC_INST, *str++);
23
    }
24
}
25

26
//串口屏通信串口初始化
27
void Screen_UART2_Init(void)
28
{
29
  NVIC_ClearPendingIRQ(UART_Screen_INST_INT_IRQN);
30
  NVIC_EnableIRQ(UART_Screen_INST_INT_IRQN);
31
    DL_UART_clearInterruptStatus(UART_Screen_INST,DL_UART_INTERRUPT_RX);//清除中断标志位
32
}
33

34
//发送字符串给串口屏
35
void Screen_SendString(char *str)
36
{
37
    while(*str != '\0')
38
    {
39
        DL_UART_Main_transmitDataBlocking(UART_Screen_INST, *str++);
40
    }
41
}
42

43
void int_to_binary_string(uint32_t value, char *binary_str, int max_bits)
44
{
45
    // 生成二进制字符串
46
    for (int i = max_bits - 1; i >= 0; --i)
47
    {
48
        binary_str[i] = (value & (1U << i)) ? '1' : '0';
49
    }
50
    binary_str[max_bits] = '\0'; // 确保字符串以 null 结尾
51
}
52

53
// 将浮点数转换为字符串
54
void float_to_string(float value, char *str, size_t size)
55
{
56
    snprintf(str, size, "%.2f", value); // 格式化为两位小数
57
}
58

59
void HMI_send_string(char *name, char *showdata)
60
{
61
    char buffer[BUFFER_SIZE];
62
    int length;
63

64
    // 构造要发送的字符串，确保缓冲区足够大
65
    length = snprintf(buffer, sizeof(buffer), "%s=\"%s\"\xff\xff\xff", name, showdata);
66

67
    // 检查是否发生了缓冲区溢出
68
    if (length >= sizeof(buffer))
69
    {
70
        // 缓冲区溢出处理，例如可以通过截断字符串或者增加缓冲区大小来解决
71
        // 这里只是简单地截断字符串以确保不会发送超出缓冲区的内容
72
        buffer[sizeof(buffer) - 1] = '\0'; // 确保字符串以 null 结尾
73
    }
74

75
    // 使用 Screen_SendString 发送构造好的字符串
76
    Screen_SendString(buffer);
77
}
78

79
void HMI_send_number(char* name, int num)
80
{
81
    char buffer[BUFFER_SIZE];
82
    int length = snprintf(buffer, sizeof(buffer), "%s=%d\xff\xff\xff", name, num);
83
    if (length >= BUFFER_SIZE)
84
    {
85
        // 缓冲区溢出处理
86
    }
87
    Screen_SendString(buffer);
88
}
89

90
void HMI_send_float(char* name, float num)
91
{
92
    char buffer[BUFFER_SIZE];
93
    int num_int = (int)(num * 100);
94
    int length = snprintf(buffer, sizeof(buffer), "%s=%d\xff\xff\xff", name, num_int);
95
    if (length >= BUFFER_SIZE)
96
    {
97
        // 缓冲区溢出处理
98
    }
99
    Screen_SendString(buffer);
100
}
101

102
void HMI_Wave(char* name, int ch, int val)
103
{
104
    char buffer[BUFFER_SIZE];
105
    int length = snprintf(buffer, sizeof(buffer), "add %s,%d,%d\xff\xff\xff", name, ch, val);
106
    if (length >= BUFFER_SIZE)
107
    {
108
        // 缓冲区溢出处理
109
    }
110
    Screen_SendString(buffer);
111
}
112

113
void HMI_Wave_Fast(char* name, int ch, int count, int* show_data)
114
{
115
    char buffer[BUFFER_SIZE];
116
    int length = snprintf(buffer, sizeof(buffer), "addt %s,%d,%d\xff\xff\xff", name, ch, count);
117
    if (length >= BUFFER_SIZE)
118
    {
119
        // 缓冲区溢出处理
120
    }
121
    Screen_SendString(buffer);
122

123
    delay_ms(100);
124

125
    for (int i = 0; i < count; i++)
126
    {
127
        // 发送每个字符
128
        DL_UART_Main_transmitDataBlocking(UART_Screen_INST, (char)show_data[i]);
129
    }
130
    // 发送结束标志
131
    Screen_SendString("\xff\xff\xff");
132
}
133

134
void HMI_Wave_Clear(char* name, int ch)
135
{
136
    char buffer[BUFFER_SIZE];
137
    int length = snprintf(buffer, sizeof(buffer), "cle %s,%d\xff\xff\xff", name, ch);
138
    if (length >= BUFFER_SIZE)
139
    {
140
        // 缓冲区溢出处理
141
    }
142
    Screen_SendString(buffer);
143
}

1
void UART_0_INST_IRQHandler(void)
2
{
3
    switch (DL_UART_Main_getPendingInterrupt(UART_0_INST)) {//判断中断的类型，DL_UART_Main_getPendingInterrupt(UART_0_INST)调用具有清空标志位的功能？
4
        case DL_UART_MAIN_IIDX_RX://如果触发串口接收事件
5
       RxData = DL_UART_Main_receiveData(UART_0_INST);
6
    if(RxState

1
// 串口中断处理函数
2
void UART_JY61P_INST_IRQHandler(void) {
3
    uint8_t uartdata = DL_UART_Main_receiveData(UART_JY61P_INST); // 接收一个uint8_t数据
4

5
    switch (RxState_JY) {
6
    case WAIT_HEADER1:
7
        if (uartdata

1
/*******************************路线进程***********************************/
2
//要求1
3
void LX_Proc_1()
4
{
5
    uint8_t temp_hd_sum;
6
    static uint8_t LX_state = 0;
7

8
    temp_hd_sum =  Huidu_Counter();
9

10
    if(LX_state ==0)
11
    {
12
        Speed_midset = 30 - NEncoder.right_motor_total_cnt/8000 * 15.0;
13

14
        if(temp_hd_sum >=1)
15
        {
16
            beep_flag = 1;
17
            LX_state = 1;
18
            Motor_Off();
19
        }
20
    }
21
}

1
//要求2
2
void LX_Proc_2()
3
{
4
    uint8_t temp_hd_sum;
5
    static uint8_t LX_state = 0;
6
    static uint32_t LuChen_Counter;
7

8
    temp_hd_sum =  Huidu_Counter();
9

10
    //LuChen_Counter = (NEncoder.left_motor_total_cnt + NEncoder.right_motor_total_cnt)/2;
11

12
    if(LX_state

1
//要求3
2
void LX_Proc_3()
3
{
4
    uint8_t temp_hd_sum;
5
    static uint8_t LX_state = 0;
6
    static uint8_t i;
7

8

9
    temp_hd_sum =  Huidu_Counter();
10

11
    if(LX_state

1
//要求4
2
void LX_Proc_4()
3
{
4
    uint8_t temp_hd_sum;
5
    static uint8_t LX_state = 0;
6
    static uint8_t i;
7

8
    temp_hd_sum =  Huidu_Counter();
9
    K_ZX = 1-(20/Speed_ZX);
10

11
    if(LX_state

1
#include "main.h"
2
#include "OLED.h"
3
#include "Serial.h"
4
#include "nqei.h"
5
#include "ti/driverlib/dl_gpio.h"
6
#include "ti_msp_dl_config.h"
7
#include <stdlib.h>
8
#include "Path.c"
9

10
uint32_t Key_Number;//按键调试
11
uint8_t Key_Val,Key_Down,Key_Up,Key_Old;
12

13
//PS:PWM可调范围，0~100以内任意浮点数
14
float MT_L = 20.0;//左轮速度初值
15
float MT_R = 20.0;//右轮速度初值
16

17
uint8_t RxData;//串口接收寄存器存储变量
18
uint8_t MID_Speed;//基准速度
19

20
float yaw_val;//记录Yaw角
21
float yaw_detect;//预测yaw角
22

23
static float Velocity_IL,Velocity_IR;//左右轮速度环PID输入
24
static float Dif_Out;//差速环PID输出
25

26
uint8_t Motor_flag;//电机使能标志位
27

28
float M_Speed_L;//左轮测速
29
float M_Speed_R;//右轮测速
30

31
uint32_t Timer_Angel_Sleep;
32
uint8_t Timer_Angel_Sleep_flag;
33

34
//外设列表：
35
//1.GPIO        LED
36
//2.PWM         定时器G0,两路PWM
37
//3.定时器      定时器A0
38
//4.串口        USART0:调试串口
39
//5.按键
40
//6.OLED      硬件IIC
41
//7.MPU6050   硬件IIC
42
//8.串口屏
43
//9.陀螺仪串口
44

45
uint8_t beep_flag = 0;//声光提示标志位
46
uint8_t beep_key_flag;//按键提示音
47
uint8_t beep_timer = 0;//声光提示持续时间
48

49
uint8_t flag = 0;
50
char hmi_speed[]="n1.txt";//测速
51
char hmi_yaw[]="n2.txt";//测角度
52
char hmi_trace[]="n3.txt";//测循迹
53
char hmi_totol[]="n4.txt";//测里程
54
char hmi_imu[]="n5.txt";//测记忆角度
55
char data_HMI[]="";//串口屏数据存储空间
56
uint8_t Key_Timer;
57

58
uint32_t Timer_1ms_counter;
59
uint8_t System_Mode;
60

61
uint8_t WD_Protect_Flag;
62
uint8_t WD_Protect_time;
63
uint8_t WD_Protect_err;
64

65
float K_ZX = 0;
66
/*初始加速函数*/
67
void Speed_InitPro(uint8_t x)
68
{
69
    uint8_t temp;
70
    uint8_t i;
71
    for(i=0;i<x;i++)
72
    {
73
        Set_Speed(i,i);
74
    }
75
}

1
/*初始加速函数*/
2
void Speed_InitPro(uint8_t x)
3
{
4
    uint8_t temp;
5
    uint8_t i;
6
    for(i=0;i<x;i++)
7
    {
8
        Set_Speed(i,i);
9
    }
10
}
11

12
/*开启系统时钟中断，会导致串口工作异常或者程序卡死*/
13
int main(void)
14
{
15
    SYSCFG_DL_init();//syscfg初始化
16
    delay_ms(100);//等待初始化稳定
17
    OLED_Init();//OLED初始化
18
    OLED_ShowString(16,8,"OK",8);
19
    delay_ms(100);//等待陀螺仪稳定
20
    Motor_Off();//初始电机关闭，等待按键控制
21

22
    SYS_UART0_Init();//串口0初始化
23
    Screen_UART2_Init();//串口2初始化
24

25
    BP_Encoder_Init();//编码器初始化
26
    PID_Init();
27
    delay_ms(1000);//等待初始化稳定
28
    //Speed_InitPro(Speed_midset*0.8);
29

30
  //编码器中断使能
31
    delay_ms(50);//等待初始化稳定
32
    TIMER_1_Init();//定时器1初始化
33
    TIMER_2_Init();
34

35
    NVIC_EnableIRQ(UART_JY61P_INST_INT_IRQN);
36
    while (1)
37
    {
38
        Oled_Proc();
39
        HMI_Proc();
40
    }
41
}