STM32 su 温度 超声波 蓝牙 延时 定时器 电机 LED 有源蜂鸣器 流控 sys main

已于 2023-05-16 10:02:51 修改
阅读量358 收藏 3
点赞数
分类专栏： STM32 文章标签： stm32 单片机 嵌入式硬件
于 2023-05-11 07:37:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_50859743/article/details/130613450
版权

目录

温度

#include "stm32f10x.h"                  // Device header
#include "MYDelay.h"
#include "MYTemper.h"

double sqrt(double a) {
	double b=a/2.0;
	for(int i=0;i<10;i++) b=(b+a/b)/2.0;
	return b;
}

int MYTemper_quickpow(int base, int power) {
	int ans=1;
	while(power>0) {
		if(power&1)ans*=base;
		power>>=1;
		base*=base;
	}
	return ans;
}

//DS DS18B20

#define DS_PIN GPIO_Pin_15
#define DS_PORT GPIOA

#define DS_LOW GPIO_ResetBits(DS_PORT, DS_PIN)
#define DS_HIGH GPIO_SetBits(DS_PORT, DS_PIN)

void MYTemper_Init(void) {
	GPIO_InitTypeDef GPIO_InitStructure;
	//先随便配置一个
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
	//
	GPIO_InitStructure.GPIO_Mode=GPIO_Mode_Out_PP;
	GPIO_InitStructure.GPIO_Pin=DS_PIN;
	GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
	
	GPIO_Init(DS_PORT, &GPIO_InitStructure);
}

//DQ输入输出选择
void MYTemper_IOCmd(uint8_t flag) {
	GPIO_InitTypeDef GPIO_InitStructure;
	
	if(flag) {//1 输出
		GPIO_InitStructure.GPIO_Mode=GPIO_Mode_Out_PP;
		GPIO_InitStructure.GPIO_Pin=DS_PIN;
		GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
	} else {  //0 输入	
		GPIO_InitStructure.GPIO_Mode=GPIO_Mode_IPU;
		GPIO_InitStructure.GPIO_Pin=DS_PIN;
//		GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
	}
	GPIO_Init(DS_PORT, &GPIO_InitStructure);
}

//启动并查询启动状态
uint8_t MYTemper_StateUP(void) {
	//存储DQ响应数据
	uint8_t Data;
	
	//主机询问
	MYTemper_IOCmd(1);
	DS_LOW;
	MYDelayUs(480);
	DS_HIGH;
	MYDelayUs(30);
	
	//从机响应
	MYTemper_IOCmd(0);
	Data=GPIO_ReadInputDataBit(DS_PORT, DS_PIN);
	MYDelayUs(200);
	
	//响应成功为0 失败为1
	return Data;
}

//按位发送 8 从低到高
void MYTemper_WriteByte(uint8_t str) {
	for(int i=0;i<8;i++) {
		MYTemper_IOCmd(1);//写
		//拉低等待
		DS_LOW;
		MYDelayUs(2);
		
		//低位先行
		if(str&0x01) DS_HIGH;
		else DS_LOW;
		
		MYDelayUs(45);//等待DS存放
		//拉高释放
		DS_HIGH;
		//右移 从低到高
		str>>=1;
	}
}

//按位接收 8 从低到高
uint8_t MYTemper_ReadByte(void) {
	uint8_t str=0x00;

	for(int i=0;i<8;i++) {
		str>>=1;
		
		MYTemper_IOCmd(1);//写
		//拉低等待
		DS_LOW;
		MYDelayUs(2);
		//拉高释放
		DS_HIGH;
		MYTemper_IOCmd(0);//读
		if(GPIO_ReadInputDataBit(DS_PORT, DS_PIN) == SET) {
			//高位或 再右移
			str|=0x80;
		}//自动补0
		
		MYDelayUs(45);//等待DS存放
	}
	return str;
}

//查询温度
double MYTemper_GetTemp(void) {
//	int ans=0.0;
	double tans=0.0;
	uint8_t TMPL=0x00;
	uint8_t TMPH=0x00;
	uint16_t TMP=0x0000;	
	//温度转换
	MYTemper_StateUP();
	MYTemper_WriteByte(0xCC);
	MYTemper_WriteByte(0x44);
	MYDelayUs(750);
	//读取寄存器0 1
	MYTemper_StateUP();
	MYTemper_WriteByte(0xCC);
	MYTemper_WriteByte(0xBE);
	//接收温度
	TMPL=MYTemper_ReadByte();
	TMPH=MYTemper_ReadByte();
	
	TMP=(TMPH<<8)|TMPL;
	
	
	int flag=0;//是否为负 默认否
	if(TMPH>7) {//是负值
		flag=1;
		TMP=~TMP+1;
	}
	
	int TTMPL=TMP;
	int TTMPH=(TMP>>8);
	for(int i=0;i<4;i++) {//小数 TMPL低4位
		tans+=((double)(TTMPL&0x01))/((double)MYTemper_quickpow(2,4-i));
		TTMPL>>=1;
	}
	
	for(int i=0; i<4; i++) {//整数 TMPL高4位
		tans+=((double)(TTMPL&0x01))*((double)MYTemper_quickpow(2,i));
		TTMPL>>=1;
	}
	
	for(int i=4; i<7; i++) {//整数 TMPH 低3位
		tans+=((double)(TTMPH&0x01))*((double)MYTemper_quickpow(2,i));
		TTMPH>>=1;
	}
	
	if(flag==1) {//确定是负
		tans*=-1;
	}
	
//	ans=(int)tans;//取整
//	return ans;
	return tans;
}

double MYTemper_GetVel(void) {
	return 331.45*sqrt(1.0+MYTemper_GetTemp()/273.15);
}


#ifndef __MYTEMPER_H
#define __MYTEMPER_H

void MYTemper_Init(void);
uint8_t MYTemper_StateUP(void);	
double MYTemper_GetTemp(void);	
double MYTemper_GetVel(void);
#endif

超声波

#include "stm32f10x.h"                  // Device header
#include "MYTimer.h"
#include "MYDelay.h"
#include "MYTemper.h"
#include "MYLed.h"

/*
原理为通过脉冲触发超声波，超声波发射触发一次中断，开始定时器，
超声波接收又触发一次中断，关闭定时器，计算时间，通过温度补偿算出距离
*/

//中断分组在MYSerial中 MYSerial_NVIC_PriorityGroupConfig_Init

#define TRIG_PORT GPIOB
#define TRIG_PIN GPIO_Pin_10

#define ECHO_PORT GPIOB
#define ECHO_PIN GPIO_Pin_11

uint32_t time=0;
uint32_t etime=0;

uint16_t Dis=0;

//AFIO 选择GPIOx的Pinx的全部引脚 接到 EXTI 这16个通过EXTI配置中断  这16个再连到NVIC确定优先级
//
void MYSound_Init(void) {
	
	//先使能时钟 GPIO AFIO	 其中 EXTI NVIC 默认开启了
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);
	
	//先配置GPIO
	GPIO_InitTypeDef GPIO_InitStructure;
	//Echo 也就是 外部中断的触发引脚 输入模式
	GPIO_InitStructure.GPIO_Mode=GPIO_Mode_IN_FLOATING;
	GPIO_InitStructure.GPIO_Pin=ECHO_PIN;
	GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
	GPIO_Init(ECHO_PORT, &GPIO_InitStructure);
	//Trig
	GPIO_InitStructure.GPIO_Mode=GPIO_Mode_Out_PP;
	GPIO_InitStructure.GPIO_Pin=TRIG_PIN;
	GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
	GPIO_Init(TRIG_PORT, &GPIO_InitStructure);
	
	//配置AFIO
	GPIO_EXTILineConfig(GPIO_PortSourceGPIOB, GPIO_PinSource11);//PB11
	
	//配置EXTI
	EXTI_InitTypeDef EXTI_InitStructure;
	EXTI_InitStructure.EXTI_Line=EXTI_Line11;
	EXTI_InitStructure.EXTI_LineCmd=ENABLE;
	EXTI_InitStructure.EXTI_Mode=EXTI_Mode_Interrupt;
	EXTI_InitStructure.EXTI_Trigger=EXTI_Trigger_Rising_Falling;//上升 下降 沿触发
	EXTI_Init(&EXTI_InitStructure);
	EXTI_ClearFlag(EXTI_Line11);
	
	//配置NVIC
	NVIC_InitTypeDef NVIC_InitStructure;
	NVIC_InitStructure.NVIC_IRQChannel=EXTI15_10_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=0;
	NVIC_InitStructure.NVIC_IRQChannelSubPriority=2;
	NVIC_InitStructure.NVIC_IRQChannelCmd=ENABLE;
	NVIC_Init(&NVIC_InitStructure);
}

void MYSound_StartUP(void) {
	GPIO_SetBits(TRIG_PORT, TRIG_PIN);//高电平触发 
	MYDelayUs(15);
	GPIO_ResetBits(TRIG_PORT, TRIG_PIN);//电平拉低 
}

//返回探头到障碍物的距离 单位厘米 cm  射程 2cm~450cm
uint16_t MYSound_GetDistance(void) {
	uint16_t dis=0;
	uint16_t tmp=0;
	for(int i=0;i<3;i++) {
		MYSound_StartUP();
		
		dis=(uint16_t)((MYTemper_GetVel()/10000)*etime);//cm
		tmp+=dis;
		MYDelayMs(60);//减少超声波回波的影响
	}
	Dis=tmp/3;//cm		
	return Dis;//cm	
}

void TIM2_IRQHandler(void) {
    if(TIM_GetITStatus(TIM2, TIM_IT_Update)==SET) {
        time++;
        TIM_ClearITPendingBit(TIM2, TIM_IT_Update);
    }
}

void EXTI15_10_IRQHandler(void) {
	if(EXTI_GetITStatus(EXTI_Line11)==SET) {
		
		if(GPIO_ReadInputDataBit(ECHO_PORT, ECHO_PIN)==SET) {//上升沿触发
			time=0;
			TIM_SetCounter(TIM2, 0);
			TIM_Cmd(TIM2, ENABLE);
		}
		if(GPIO_ReadInputDataBit(ECHO_PORT, ECHO_PIN)==RESET) {//下降沿触发
			TIM_Cmd(TIM2, DISABLE);
			
			etime=(time*10+TIM_GetCounter(TIM2))/2;//us
		}

		EXTI_ClearITPendingBit(EXTI_Line11);
	}
}


#ifndef __MYSOUND_H
#define __MYSOUND_H

//PB10 触发 PB11 接收

void MYSound_Init(void);
uint16_t MYSound_GetDistance(void);

#endif

蓝牙

#include "stm32f10x.h"                  // Device header

#include "MYSerial.h"

uint8_t USART1_NVIC_IRQChannelPreemptionPriority = 1;
uint8_t USART1_NVIC_IRQChannelSubPriority = 1;

uint8_t USART2_NVIC_IRQChannelPreemptionPriority = 0;
uint8_t USART2_NVIC_IRQChannelSubPriority = 1;

void MYSerial_NVIC_PriorityGroupConfig_Init(void) { //一个项目只用一次
    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2); //分组2 2抢断优先级 2响应优先级
}

//USART1
void MYSerial_USART1_Init(void) {
    //串口设置 1
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE); //IO口时钟使能
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE); //开启USART1的时钟

    //GPIO初始化配置
    GPIO_InitTypeDef GPIO_InitStructure;

    GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;

    GPIO_InitStructure.GPIO_Pin=GPIO_Pin_9;
    GPIO_InitStructure.GPIO_Mode=GPIO_Mode_AF_PP; //推挽复用输出 TX
    GPIO_Init(GPIOA, &GPIO_InitStructure);

    GPIO_InitStructure.GPIO_Pin=GPIO_Pin_10;
    GPIO_InitStructure.GPIO_Mode=GPIO_Mode_IPU; //上拉输入 RX
    GPIO_Init(GPIOA, &GPIO_InitStructure);

    //USART初始化配置
    USART_InitTypeDef USART_InitStructure;

    USART_InitStructure.USART_BaudRate=9600; //9600波特率
    USART_InitStructure.USART_HardwareFlowControl=USART_HardwareFlowControl_None; //无流控
    USART_InitStructure.USART_Mode=USART_Mode_Rx|USART_Mode_Tx; //发送 接收 双 模式
    USART_InitStructure.USART_Parity=USART_Parity_No; //无校验
    USART_InitStructure.USART_StopBits=USART_StopBits_1; //停止位为1
    USART_InitStructure.USART_WordLength=USART_WordLength_8b; //八位字长
    USART_Init(USART1, &USART_InitStructure);

    //开启中断
    USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);

    NVIC_InitTypeDef NVIC_InitStructure;

    NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = USART1_NVIC_IRQChannelPreemptionPriority;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = USART1_NVIC_IRQChannelSubPriority;
    NVIC_Init(&NVIC_InitStructure);

    //最后
    USART_Cmd(USART1, ENABLE); //串口使能
}

//发送一个字节
void MYSerial_USART1_SentByte(uint8_t byte) {
    USART_SendData(USART1, byte);
    while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);
}

//发送数组
void MYSerial_USART1_SentArray(uint8_t* Arr, uint16_t Length) {
    for(int i=0; i<Length; i++) MYSerial_USART1_SentByte(Arr[i]);
}

//发送字符串
void MYSerial_USART1_SentString(char* Str) {
    for(int i=0; Str[i]!='\0'; i++) MYSerial_USART1_SentByte(Str[i]);
}

//以字符串形式发送数字
void MYSerial_USART1_SentNumber(int Num) {
    char Snum[10];
    int flag=0;
    int i=0;
    int b=0;
    if(Num<0) {
        Num/=-1;
        flag=1;
    }
    while(Num!=0) {
        b=Num%10;
        Snum[i++]='0'+b;
        if(i>9) i=0;
        Num/=10;
    }
    if(flag==1) MYSerial_USART1_SentByte('-');
    while(i>=0) MYSerial_USART1_SentByte(Snum[i--]);
}

//接收数据包
char MYSerial_USART1_RxPacketHead = '@'; // 包头
char MYSerial_USART1_RxPacketTail_A = '\r'; // 包尾
char MYSerial_USART1_RxPacketTail_B = '\n'; // 包尾

char MYSerial_USART1_RxPacketData[100]; // 接收的数据包
uint8_t MYSerial_USART1_RxPacketFlag=0; // 接收的 数据包的 标志位

//获取 接收的 数据包的 标志位
uint8_t MYSerial_USART1_GetRxPacketFlag(void) {
    uint8_t tmpFlag=0;
    if(MYSerial_USART1_RxPacketFlag == 1) {
        tmpFlag=1;
        MYSerial_USART1_RxPacketFlag=0;
    }
    return tmpFlag;
}

//USART1中断服务函数
void USART1_IRQHandler(void) {
    static uint8_t flag=0;
    static uint8_t pData=0;
    uint8_t rxData;
    if(USART_GetFlagStatus(USART1, USART_FLAG_RXNE) == SET) {

        rxData = USART_ReceiveData(USART1);

        switch(flag) {
        case 0:
            if(rxData == MYSerial_USART1_RxPacketHead) flag=1;
            break;
        case 1:
            if(rxData !=MYSerial_USART1_RxPacketTail_A) MYSerial_USART1_RxPacketData[pData++] = rxData;
            else flag=2;
            break;
        case 2:
            if(rxData == MYSerial_USART1_RxPacketTail_B) {
                flag=0;
                MYSerial_USART1_RxPacketFlag=1;

                MYSerial_USART1_RxPacketData[pData] = '\0';
                pData=0;
            }
            break;
        }
        USART_ClearITPendingBit(USART1, USART_FLAG_RXNE);
    }
}

/***************************************************************************************/
//USART2
//串口初始化
void MYSerial_USART2_Init(void) {
	
    GPIO_InitTypeDef GPIO_InitStructure;
	USART_InitTypeDef USART_InitStructure;
	NVIC_InitTypeDef NVIC_InitStructure;
	
    
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE); //IO口时钟使能
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2,ENABLE);  //开启USART2的时钟
    
	//GPIO初始化配置
    GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
    GPIO_InitStructure.GPIO_Pin=GPIO_Pin_2;
    GPIO_InitStructure.GPIO_Mode=GPIO_Mode_AF_PP; //推挽复用输出 TX
    GPIO_Init(GPIOA, &GPIO_InitStructure); //初始化PA2
	
    GPIO_InitStructure.GPIO_Pin=GPIO_Pin_3;
    GPIO_InitStructure.GPIO_Mode=GPIO_Mode_IN_FLOATING; //浮空输入 RX
    GPIO_Init(GPIOA, &GPIO_InitStructure); //初始化PA3

    //USART初始化配置
    USART_InitStructure.USART_BaudRate=9600; //9600波特率
    USART_InitStructure.USART_HardwareFlowControl=USART_HardwareFlowControl_None; //无流控
    USART_InitStructure.USART_Mode=USART_Mode_Rx|USART_Mode_Tx; //发送 接收 双 模式
    USART_InitStructure.USART_Parity=USART_Parity_No; //无校验
    USART_InitStructure.USART_StopBits=USART_StopBits_1; //停止位为1
    USART_InitStructure.USART_WordLength=USART_WordLength_8b; //八位字长
    USART_Init(USART2, &USART_InitStructure); //初始化串口2

    //开启中断
    USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);
		
	NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = USART2_NVIC_IRQChannelPreemptionPriority; //抢占优先级
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = USART2_NVIC_IRQChannelSubPriority;		//子优先级
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;			//IRQ通道使能
	NVIC_Init(&NVIC_InitStructure);	//根据指定的参数初始化NVIC寄存器

    //最后
    USART_Cmd(USART2, ENABLE); //串口使能
}

//发送一个字节
void MYSerial_USART2_SentByte(uint8_t byte) {
    USART_SendData(USART2, byte);
    while(USART_GetFlagStatus(USART2, USART_FLAG_TXE) == RESET);
}

//发送数组
void MYSerial_USART2_SentArray(uint8_t* Arr, uint16_t Length) {
    for(int i=0; i<Length; i++) MYSerial_USART2_SentByte(Arr[i]);
}

//发送字符串
void MYSerial_USART2_SentString(char* Str) {
    for(int i=0; Str[i]!='\0'; i++) MYSerial_USART2_SentByte(Str[i]);
}

//以字符串形式发送数字
void MYSerial_USART2_SentNumber(int Num) {
    char Snum[10];
    int flag=0;
    int i=0;
    int b=0;
    if(Num<0) {
        Num/=-1;
        flag=1;
    }
    while(Num!=0) {
        b=Num%10;
        Snum[i++]='0'+b;
        if(i>9) i=0;
        Num/=10;
    }
    if(flag==1) MYSerial_USART2_SentByte('-');
    while(i>=0) MYSerial_USART2_SentByte(Snum[i--]);
}

//接收数据包
char MYSerial_USART2_RxPacketHead = '@'; // 包头
char MYSerial_USART2_RxPacketTail = '%'; // 包尾

char MYSerial_USART2_RxPacketData[100]; // 接收的数据包
uint8_t MYSerial_USART2_RxPacketFlag=0; // 接收的 数据包的 标志位

//获取 接收的 数据包的 标志位
uint8_t MYSerial_USART2_GetRxPacketFlag(void) {
    uint8_t tmpFlag=0;
    if(MYSerial_USART2_RxPacketFlag == 1) {
        tmpFlag=1;
        MYSerial_USART2_RxPacketFlag=0;
    }
    return tmpFlag;
}

//USART2中断服务函数
void USART2_IRQHandler(void) {
    static uint8_t flag=0;
    static uint8_t pData=0;
    uint8_t rxData;
    if(USART_GetFlagStatus(USART2, USART_FLAG_RXNE) == SET) {

        rxData = USART_ReceiveData(USART2);

        if(flag==0) {
            if(rxData == MYSerial_USART2_RxPacketHead) {
                flag=1;
            }
        } else if(flag==1) {
            if(rxData !=MYSerial_USART2_RxPacketTail) {
                MYSerial_USART2_RxPacketData[pData++] = rxData;
            } else {
                flag=0;
                MYSerial_USART2_RxPacketFlag=1;
                MYSerial_USART2_RxPacketData[pData] = '\0';
                pData=0;
            }
        }
        USART_ClearITPendingBit(USART2, USART_FLAG_RXNE);
    }
}
/***************************************************************************************/


#ifndef __MYSERIAL_H
#define __MYSERIAL_H

void MYSerial_NVIC_PriorityGroupConfig_Init(void);

//USART1
extern char MYSerial_USART1_RxPacketData[100];

uint8_t MYSerial_USART1_GetRxPacketFlag(void);

void MYSerial_USART1_Init(void);

void MYSerial_USART1_SentByte(uint8_t byte);
void MYSerial_USART1_SentArray(uint8_t* Arr, uint16_t Length);
void MYSerial_USART1_SentString(char* Str);
void MYSerial_USART1_SentNumber(int Num);

//USART2
extern char MYSerial_USART2_RxPacketData[100];
uint8_t MYSerial_USART2_GetRxPacketFlag(void);

void MYSerial_USART2_Init(void);

void MYSerial_USART2_SentByte(uint8_t byte);
void MYSerial_USART2_SentArray(uint8_t* Arr, uint16_t Length);
void MYSerial_USART2_SentString(char* Str);
void MYSerial_USART2_SentNumber(int Num);

#endif

延时

#include "stm32f10x.h"                  // Device header

#include "MYDelay.h"

static u8 fac_us=0; //9
static u16 fac_ms=0;//9000

//初始化
void MYDelay_Init(void) {
    SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8); //f=9M
    fac_us=SystemCoreClock/8000000;
    fac_ms=(u16)fac_us*1000;
}

//微秒延时
void MYDelayUs(uint32_t t) {
    u32 tmp;

    SysTick->LOAD=t*fac_us; //倒计时
    SysTick->VAL=0x00;	//清空当前的
    SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk; //始能

    do {
        tmp=SysTick->CTRL;
    } while((tmp&0x01)&&!(tmp&(1<<16)));
    SysTick->CTRL&=~SysTick_CTRL_ENABLE_Msk;
    SysTick->VAL=0x00;

}

//毫秒延时
void MYDelayMs(uint16_t t) {
    u32 tmp;

    SysTick->LOAD=t*fac_ms; //倒计时
    SysTick->VAL=0x00;	//清空当前的
    SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk; //始能

    do {
        tmp=SysTick->CTRL;
    } while((tmp&0x01)&&!(tmp&(1<<16)));
    SysTick->CTRL&=~SysTick_CTRL_ENABLE_Msk;
    SysTick->VAL=0x00;
}

//秒延时
void MYDelayS(uint16_t t) {
    for(int i=0; i<1000; i++) MYDelayMs(t);
}

//void delaymms(uint32_t t) {
//    t=t*8000;
//    for(; t>0; t--) ;
//}


#ifndef __MYDEALY_H
#define __MYDEALY_H

void MYDelay_Init(void);
void MYDelayUs(uint32_t t);
void MYDelayMs(uint16_t t);
void MYDelayS(uint16_t t);
//void delaymms(uint32_t t);

#endif

定时器

#include "stm32f10x.h"                  // Device header

void MYTimer2_Internal_Init(void) {

    //使能时钟
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);

    //TIM2的时基单元由内部时钟驱动
    TIM_InternalClockConfig(TIM2);

    //初始化时基单元
    TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStructure;
    TIM_TimeBaseInitStructure.TIM_ClockDivision=TIM_CKD_DIV1;//采样用的分频
    TIM_TimeBaseInitStructure.TIM_CounterMode=TIM_CounterMode_Up;//向上的

    //定时频率=72兆/(PSC+1)/(ARR+1)
    TIM_TimeBaseInitStructure.TIM_Period=10-1;//计数 10us计数一次 中断一次
    TIM_TimeBaseInitStructure.TIM_Prescaler=72-1;//72分频  就是数10^6下就是1s
    TIM_TimeBaseInitStructure.TIM_RepetitionCounter=DISABLE;//高级的 不用

    TIM_TimeBaseInit(TIM2, &TIM_TimeBaseInitStructure);

    //手动清除更新中断标志位
    TIM_ClearFlag(TIM2, TIM_IT_Update);

    //使能中断
    TIM_ITConfig(TIM2, TIM_IT_Update, ENABLE);

    //NVIC配置
    //优先级分组在MYSerial已经设置 为分组2
    NVIC_InitTypeDef NVIC_InitStructure;
    NVIC_InitStructure.NVIC_IRQChannel=TIM2_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelCmd=ENABLE;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=2;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority=0;
    NVIC_Init(&NVIC_InitStructure);

    //启动定时器
//	TIM_Cmd(TIM2, ENABLE);
}

//void TIM2_IRQHandler(void) {
//    if(TIM_GetITStatus(TIM2, TIM_IT_Update)==SET) {
//        time++;
//        TIM_ClearITPendingBit(TIM2, TIM_IT_Update);
//    }
//}


#ifndef __MYTIMER_H
#define __MYTIMER_H

void MYTimer2_Internal_Init(void);

#endif

电机

#include "stm32f10x.h"                  // Device header

#include "MYDelay.h"
#include "MYMotor.h"

//当前角度
int MYAngle_now=0;
//当前是哪一相
static uint8_t step=0;

//初始化电机连接的端口
void MYMotor_Init(void) {
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_Port, ENABLE);

    GPIO_InitTypeDef GPIO_Structure;
    GPIO_Structure.GPIO_Mode=GPIO_Mode_Out_PP;
    GPIO_Structure.GPIO_Speed=GPIO_Speed_50MHz;
    GPIO_Structure.GPIO_Pin=A|B|C|D;
    GPIO_Init(GPIO_Port, &GPIO_Structure);

    MYMotor_Stop();
}

//8相控制 1为逆时针转 0为顺时针转
void MYMotor_Control(uint8_t flag) {
    if(flag==1) {
        if(step==8) step=0;
        step++;
    } else if(flag==0) {
        if(step==0||step==1) step=9;
        step--;
    }
    switch(step) {
    case 1:
        MAH;
        MBL;
        MCL;
        MDL;
        break;
    case 2:
        MAH;
        MBH;
        MCL;
        MDL;
        break;
    case 3:
        MAL;
        MBH;
        MCL;
        MDL;
        break;
    case 4:
        MAL;
        MBH;
        MCH;
        MDL;
        break;
    case 5:
        MAL;
        MBL;
        MCH;
        MDL;
        break;
    case 6:
        MAL;
        MBL;
        MCH;
        MDH;
        break;
    case 7:
        MAL;
        MBL;
        MCL;
        MDH;
        break;
    case 8:
        MAH;
        MBL;
        MCL;
        MDH;
        break;
    }
}

//电机速度控制 最快为1000us延时 最慢至少为20000us
void MYMotor_Speed(uint32_t speed) {
    MYDelayUs(speed);
}

//多少度 正反 多快
void MYMotor_Start(int16_t angle, uint8_t flag, uint32_t speed) {
    int pulse=(int)((double)(angle/5.625)*64);
    for(int i=0; i<pulse; i++) {
        MYMotor_Control(flag);
        MYMotor_Speed(speed);
    }
}

//停止
void MYMotor_Stop(void) {
    MAL;
    MBL;
    MCL;
    MDL;
}

//启动加减速函数 减少失步问题
void MYMotor_ADceleration(uint8_t adflag, uint8_t fflag, uint32_t speed) {//为保证操作的直观性，仅适用于自动巡查和自定义巡查
	if(adflag==1) {//加速
		if(speed*4>20000) MYMotor_Start(1, fflag, 20000);
		else MYMotor_Start(1, fflag, speed*4);
		if(speed*2>10000) MYMotor_Start(1, fflag, 10000);
		else MYMotor_Start(1, fflag, speed*2);
		
		MYMotor_Start(1, fflag, speed/2*3);//1.5
		MYMotor_Start(1, fflag, speed/5*6);//1.2
		MYMotor_Start(1, fflag, speed/20*21);//1.05
	}
	
	else if(adflag==0) {//减速
		MYMotor_Start(1, fflag, speed/20*21);//1.05
		MYMotor_Start(1, fflag, speed/5*6);//1.2
		MYMotor_Start(1, fflag, speed/2*3);//1.5
		
		if(speed*2>10000) MYMotor_Start(1, fflag, 10000);
		else MYMotor_Start(1, fflag, speed*2);
		if(speed*4>20000) MYMotor_Start(1, fflag, 20000);
		else MYMotor_Start(1, fflag, speed*4);
	}
} //adflag为加减速flag fflag为旋转方向flag speed 就是speed


#ifndef __MYMOTOR_H
#define __MYMOTOR_H

//端口选择
#define GPIO_Port GPIOA
#define RCC_APB2Periph_Port RCC_APB2Periph_GPIOA

//端口针脚选择
#define A GPIO_Pin_7
#define B GPIO_Pin_6
#define C GPIO_Pin_5
#define D GPIO_Pin_4

//端口针脚电平设置
#define MAL GPIO_ResetBits(GPIO_Port, A)
#define MAH GPIO_SetBits(GPIO_Port, A)

#define MBL GPIO_ResetBits(GPIO_Port, B)
#define MBH GPIO_SetBits(GPIO_Port, B)

#define MCL GPIO_ResetBits(GPIO_Port, C)
#define MCH GPIO_SetBits(GPIO_Port, C)

#define MDL GPIO_ResetBits(GPIO_Port, D)
#define MDH GPIO_SetBits(GPIO_Port, D)

extern int MYAngle_now;

void MYMotor_Init(void);
void MYMotor_Control(uint8_t flag);//8相
void MYMotor_Start(int16_t angle, uint8_t flag, uint32_t speed);
void MYMotor_Stop(void);
void MYMotor_ADceleration(uint8_t adflag, uint8_t fflag, uint32_t speed);
	
void MYMotor_Speed(uint32_t speed);//1000~20000 //1000最快了

#endif

LED

#include "stm32f10x.h"                  // Device header

#include "MYLed.h"

//初始化stm32系统板自带led pc13
void MYLed_Init(void) {
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);

    GPIO_InitTypeDef GPIO_Structure;
    GPIO_Structure.GPIO_Mode=GPIO_Mode_Out_PP;
    GPIO_Structure.GPIO_Pin=GPIO_Pin_13;
    GPIO_Structure.GPIO_Speed=GPIO_Speed_50MHz;

    GPIO_Init(GPIOC, &GPIO_Structure);

    MYLed_OFF();
}

//开
void MYLed_ON(void) {
    GPIO_ResetBits(GPIOC, GPIO_Pin_13);
}

//关
void MYLed_OFF(void) {
    GPIO_SetBits(GPIOC, GPIO_Pin_13);
}


#ifndef __MYLED_H
#define __MYLED_H

void MYLed_Init(void);
void MYLed_ON(void);
void MYLed_OFF(void);

#endif

有源蜂鸣器

#include "stm32f10x.h"                  // Device header

#include "MYBuzzer.h"

void MYBuzzer_Init(void) {
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);

    GPIO_InitTypeDef GPIO_Structure;
    GPIO_Structure.GPIO_Mode=GPIO_Mode_Out_PP;
    GPIO_Structure.GPIO_Pin=GPIO_Pin_8;
    GPIO_Structure.GPIO_Speed=GPIO_Speed_50MHz;

    GPIO_Init(GPIOA, &GPIO_Structure);

    MYBuzzer_OFF();
}

//开
void MYBuzzer_ON(void) {
    GPIO_SetBits(GPIOA, GPIO_Pin_8);
}

//关
void MYBuzzer_OFF(void) {
    GPIO_ResetBits(GPIOA, GPIO_Pin_8);
}


#ifndef __MYBUZZER_H
#define __MYBUZZER_H

void MYBuzzer_Init(void);
void MYBuzzer_ON(void);
void MYBuzzer_OFF(void);

#endif

流控

#include "stm32f10x.h"                  // Device header
#include <string.h>

#include "MYDelay.h"
#include "MYBuzzer.h"
#include "MYSerial.h"
#include "MYMOtor.h"
#include "MYOrder.h"
#include "MYSound.h"

int SYSSTART=0;//系统是否启动，默认否

const uint8_t minAngle=2;//向左 向右按钮的最小旋转角度
uint8_t judgeINITflag=0;//调整电机初始角度flag 默认为关
uint8_t judgeBuzzerflag=1;//报警蜂鸣开关flag 默认为开

int Ospeed=1000;//电机旋转速度 最快900 最慢20000

int MAUTO_A_L=-90;//自定义旋转角度 -90
int MAUTO_A_R=90;//自定义旋转角度 +90

uint8_t S_DISTANCE=200;//安全距离 默认为200cm

int bufferAngle=5;//缓冲加减速所需角度 单个
int motorBufferflag=0;//是否使用缓冲加减速函数 默认不使用

void motorBuffer(uint8_t adflag, uint8_t fflag, uint32_t speed) {//缓冲加减速函数
    MYMotor_ADceleration(adflag, fflag, speed);
}

int quickpow(int base, int power) {//快速幂
    int ans=1;
    while(power>0) {
        if(power&1) ans=ans*base;
        power>>=1;
        base=base*base;
    }
    return ans;
}

inline int abs(int num) {//绝对值
    if(num<0) num*=-1;
    return num;
}

int MYStrCmpSetting(char str[], char ans[]) {//判断是否是设置
    if(str[0]==ans[0]&&str[1]==ans[1]) return 1;
    else return 0;
}

int zhuanhuan(int s,int e) {//计算最小旋转角 负数逆时针 正数顺时针 感谢邹公子的代码
    if(s==e) return 0;
    int flag=1,temp;
    if(s>e) {
        flag=-1;
        temp=s;
        s=e;
        e=temp;
    }
    int temp1=e-s,temp2=360+s-e;
    return flag*(temp1>=temp2?(-1*temp2):temp1);
}



void MYOrder_Judge(char str[]) {
    if(str[0]=='O') {
        MYOrder_Setting("NO");
        MYOrder_Order(str);
    } else if(str[0]=='S') {
        MYOrder_Order("NO");
        MYOrder_Setting(str);
    }
}

int MYF_GoZero(char str[]) {
    //校准与系统巡查沟通flag 是否同方向
    int bridgeflag=1;//默认先逆时针

    if(MYAngle_now!=0) {
        int jiaozhunflag=0;
        int abs_MYAngle_now=abs(MYAngle_now);

        if(MYAngle_now<0) jiaozhunflag=0;//0~-180 顺时针转回到0
        else jiaozhunflag=1;//0~180 逆时针转回到0

        bridgeflag=jiaozhunflag;//芜湖

        if(abs_MYAngle_now>(bufferAngle*2)) {//需要缓冲 角度预先支付
            motorBufferflag=1;//置一

            if(jiaozhunflag==0) MYAngle_now+=(bufferAngle*2);
            else MYAngle_now-=(bufferAngle*2);
        }

        if(motorBufferflag==1) {
            motorBuffer(1,jiaozhunflag,Ospeed);
        }
        int jiaozhunbreakflag=1;//是否顺利完成校准 即 无跳出 命令未改变 默认完成
        while(1) {
            MYMotor_Start(1,jiaozhunflag,Ospeed);
            if(jiaozhunflag==1) MYAngle_now--;
            else MYAngle_now++;

            if(strcmp(str, "OAUTO")!=0) {//被撅了
                jiaozhunbreakflag=0;
                break;
            }
            if(motorBufferflag==1) {//有缓冲函数
                if(bridgeflag==1) {//即归0后继续逆时针到左极限 不需要减速
                    if(MYAngle_now==0) break;//校准成功后退出while
                } else {//即归0后减速，然后反向到左极限
                    if(MYAngle_now==-1*bufferAngle) {
                        motorBuffer(0,0,Ospeed);
                        break;//校准成功后退出while
                    }
                }

            } else {
                if(MYAngle_now==0) break;//校准成功后退出while
            }

        }

        if(jiaozhunbreakflag==0) {//未顺利完成 补偿MYAngle_now 如果要的话
            if(motorBufferflag==1) {
                if(jiaozhunflag==0) MYAngle_now-=bufferAngle;
                else MYAngle_now+=bufferAngle;
            }
        }
    }
    return bridgeflag;
}

void MYOrder_Order(char str[]) {
    if(!strcmp(str, "NO")) {//无事发生

    } else if(!strcmp(str, "OSTART")) {//启动系统
		SYSSTART=1;
        MYBuzzer_ON();
        MYDelayMs(500);
        MYBuzzer_OFF();

    } else if(!strcmp(str, "ONSTART")) {//关闭系统
		SYSSTART=0;
        MYBuzzer_ON();
        MYDelayMs(200);
        MYBuzzer_OFF();

    } else if(!strcmp(str, "OAUTO")) {//开启系统巡查模式

        //校准与系统巡查沟通flag 是否同方向
        int bridgeflag=MYF_GoZero(str);

        int i=0; //经过上面的调整后，默认开始角度为0
        int tflag=1;//只会在最开始转到-90 然后就是右转180 左转180循环
        int flag=1; //默认先逆时针

        int syspolicebreakflag=1;//是否顺利完成巡查 即 无跳出 命令未改变

        if(bridgeflag==0) motorBuffer(1,1,Ospeed);//需缓冲

        while(1) {
            MYMotor_Start(1,flag,Ospeed);//转动 1度 flag控制转向 1逆时针转 0顺时针转
            i++;
            if(flag==0) {
                MYAngle_now++;
                if(MYAngle_now>=180) MYAngle_now=-180;
            } else {
                MYAngle_now--;
                if(MYAngle_now<=-180) MYAngle_now=180;
            }

            if(tflag==1) {//还是第一个-90度
                if(bridgeflag==1) {//无需缓冲
                    if(i==90-bufferAngle) {
                        motorBuffer(0,1,Ospeed);
                        flag=0;//正式开始循环
                        tflag=0;
                        i=0;
                    }
                } else {
                    if(i==90-bufferAngle*2) {
                        motorBuffer(0,1,Ospeed);
                        flag=0;//正式开始循环
                        tflag=0;
                        i=0;
                    }
                }

            } else {
                if(i==0 && flag==0) motorBuffer(1,0,Ospeed);
                if(i==0 && flag==1) motorBuffer(1,1,Ospeed);

                //到180就反向
                if(i==180-bufferAngle*2) {
                    if(flag==0) {
                        motorBuffer(0,0,Ospeed);
                        flag=1;
                    } else {
                        motorBuffer(0,1,Ospeed);
                        flag=0;
                    }
                    i=0;
                }
            }

            if(strcmp(str, "OAUTO")!=0) {//未顺利完成 进行补偿
                syspolicebreakflag=0;
                break;
            }
        }
        if(syspolicebreakflag==0) {
            if(tflag==1) {
                MYAngle_now+=bufferAngle;
            } else { //如果开始了循环
                if(flag==1) { //如果是逆时针
                    MYAngle_now-=bufferAngle;
                } else {
                    MYAngle_now+=bufferAngle;
                }
            }
        }


    } else if(!strcmp(str, "ONAUTO")) {//关闭系统巡查模式
        MYMotor_Stop();
    } else if(!strcmp(str, "OMAUTO")) {//开启个人巡查模式

        //校准与系统巡查沟通flag 是否同方向
        int bridgeflag=MYF_GoZero(str);

        if(bridgeflag==0) {
            motorBuffer(1,1,Ospeed);//需缓冲
            MYAngle_now-=bufferAngle;
        }

        int flag=1;//默认逆时针
        while(1) {
            MYMotor_Start(1,flag,Ospeed);//转动 1度 flag控制转向 1逆时针转 0顺时针转
            if(flag==1) {
                MYAngle_now--;
                if(MYAngle_now<=-180) MYAngle_now=180;
            } else {
                MYAngle_now--;
                if(MYAngle_now<=-180) MYAngle_now=180;
            }

            if(MYAngle_now==MAUTO_A_L+bufferAngle && flag==1) {
				flag=0;
				motorBuffer(0,1,Ospeed);
				MYAngle_now-=bufferAngle;
			}
			if(MYAngle_now==MAUTO_A_L && flag==1) {
				flag=0;
				motorBuffer(1,0,Ospeed);
				MYAngle_now+=bufferAngle;
			}
            if(MYAngle_now==MAUTO_A_R-bufferAngle && flag==0) {
                flag=1;
                motorBuffer(0,0,Ospeed);
				MYAngle_now+=bufferAngle;
            }
			if(MYAngle_now==MAUTO_A_R && flag==0) {
                flag=1;
                motorBuffer(1,1,Ospeed);
				MYAngle_now-=bufferAngle;
            }
			
            if(strcmp(str, "OMAUTO")!=0) {
				MYMotor_Stop();
				break;
			}
        }

    } else if(!strcmp(str, "ONMAUTO")) {//关闭个人巡查模式
        MYMotor_Stop();
    } else if(!strcmp(str, "OBUZZER")) {//开启报警蜂鸣器
        judgeBuzzerflag=1;
    } else if(!strcmp(str, "ONBUZZER")) {//关闭报警蜂鸣器
        judgeBuzzerflag=0;
    } else if(!strcmp(str, "OLEFT")) {//向左 逆时针
        MYMotor_Start(minAngle,1,Ospeed);
        if(judgeINITflag==0) {
            MYAngle_now-=minAngle;
            if(MYAngle_now<=-180) MYAngle_now=180;
        }
        MYMotor_Stop();
    } else if(!strcmp(str, "ORIGHT")) {//向右 顺时针
        MYMotor_Start(minAngle,0,Ospeed);
        if(judgeINITflag==0) {
            MYAngle_now+=minAngle;
            if(MYAngle_now>=180) MYAngle_now=-180;
        }
        MYMotor_Stop();
    } else if(!strcmp(str, "OLLEFT")) {//持续向左
        while(1) {
            MYMotor_Start(1,1,Ospeed);
            if(strcmp(str, "OLLEFT")!=0) break;
            if(judgeINITflag==0) {
                MYAngle_now-=1;
                if(MYAngle_now<=-180) MYAngle_now=180;
            }
        }
    } else if(!strcmp(str, "ORRIGHT")) {//持续向右
        while(1) {
            MYMotor_Start(1,0,Ospeed);
            if(strcmp(str, "ORRIGHT")!=0) break;
            if(judgeINITflag==0) {
                MYAngle_now+=1;
                if(MYAngle_now>=180) MYAngle_now=-180;
            }
        }
    } else if(!strcmp(str, "ONLLEFT")) {//停止持续向左
        MYMotor_Stop();
    } else if(!strcmp(str, "ONRRIGHT")) {//停止持续向右
        MYMotor_Stop();
    } else if(!strcmp(str, "OMINIT")) {//电机初始位置调节开
        judgeINITflag=1;
        MYAngle_now=0;
    } else if(!strcmp(str, "ONMINIT")) {//电机初始位置调节关
        judgeINITflag=0;
    }
}

void MYOrder_Setting(char str[]) {

    if(MYStrCmpSetting(str,"NO")) {//无事发生

    } else if(MYStrCmpSetting(str,"ST")) {//转动到某个角度 格式为ST角度


        int STAngle=0;//转动的角度 带正负
        char STAngleStr[100];//先将数字存在str中，倒序取出
        int STLength=0;//数字长度

        char STSettingBefore[100];
        for(int i=0; str[i]!='\0'; i++) STSettingBefore[i]=str[i];

        int STRoll=0;//转动方向 根据str[2]确定 0顺1逆

        for(int i=3; str[i]!='\0'; i++) STAngleStr[STLength++]=str[i]; //得到数字长度
        for(int i=STLength, j=0; i>0; i--) STAngle+=((STAngleStr[i-1]-'0')*quickpow(10,j++));
        if(str[2]=='-') STAngle*=-1;//添加符号

        int STChangeAngle=zhuanhuan(MYAngle_now, STAngle);//需变换的角度

        int ifSTChangeAngleZero=0;

        if(STChangeAngle<0) STRoll=1; //负数向左 逆时针
        else if(STChangeAngle>0) STRoll=0; //反之
        else if(STChangeAngle==0) {	
            STRoll=0;
            ifSTChangeAngleZero=1;
        }
        STChangeAngle=abs(STChangeAngle);//变为数值

        int STCont=0;
        if(ifSTChangeAngleZero!=1) {
            while(1) {
                MYMotor_Start(1,STRoll,Ospeed);
                STCont++;
                if(STRoll==1) {
                    MYAngle_now-=1;
                    if(MYAngle_now<=-180) MYAngle_now=180;
                } else if(STRoll==0) {
                    MYAngle_now+=1;
                    if(MYAngle_now>=180) MYAngle_now=-180;
                }
                if(strcmp(str,STSettingBefore)!=0) {
                    memset(STSettingBefore,0,100);
                    for(int i=0; str[i]!='\0'; i++) STSettingBefore[i]=str[i];
                    break;
                }
                if(STCont==STChangeAngle) {
                    MYMotor_Stop();
                    break;
                }
            }
        } else MYMotor_Stop();

    } else if(MYStrCmpSetting(str,"SA")) {//旋转角度设置 格式为SA负角度#正角度

		int SALengthL=0;
		int SALengthR=0;
		char SAStr[100];
		MAUTO_A_L=0;
		MAUTO_A_R=0;
		memset(SAStr,0,100);
		for(int i=2;str[i]!='#';i++) {
			SAStr[SALengthL++]=str[i];
		}
		for(int i=SALengthL, j=0;i>0;i--) MAUTO_A_L+=((SAStr[i-1]-'0')*quickpow(10,j++));
		MAUTO_A_L*=-1;
		memset(SAStr,0,100);
		for(int i=SALengthL+3;str[i]!='\0';i++) {
			SAStr[SALengthR++]=str[i];
		}
		for(int i=SALengthR, j=0;i>0;i--) MAUTO_A_R+=((SAStr[i-1]-'0')*quickpow(10,j++));
		
		
    } else if(MYStrCmpSetting(str,"SD")) {//安全距离设置 格式为SD距离
		int SDLength=0;
		char SDStr[100];
		S_DISTANCE=0;
		memset(SDStr,0,100);
		for(int i=2;str[i]!='\0';i++) {
			SDStr[SDLength++]=str[i];
		}
		for(int i=SDLength, j=0;i>0;i--) S_DISTANCE+=((SDStr[i-1]-'0')*quickpow(10,j++));
    }
}

void MYOrder_SentStr(void) {
	char str[10];
	char tstr[10];
	
	int Length=0;
	int gewei=0;
	
	int tMYAngle_now=0;
	
	if(SYSSTART) {
		if(MYAngle_now==0) {
			str[0]='+';
			str[1]='0';
			Length=1;
		} else {
			if(MYAngle_now<0) {
			str[0]='-';
			tMYAngle_now=MYAngle_now*-1;
			} else {
				str[0]='+';
				tMYAngle_now=MYAngle_now;
			}
			while(tMYAngle_now!=0) {
				gewei=tMYAngle_now%10;
				tstr[Length++]=gewei+'0';
				tMYAngle_now/=10;
			}
			for(int i=Length-1, j=1;i>=0;i--) {
				str[j++] = tstr[i];
			}
		}
		str[Length+1]='#';
		if(MYSound_GetDistance()<S_DISTANCE) str[Length+2]='Y';
		else str[Length+2]='N';
		
		MYSerial_USART2_SentString(str);
	}
}


#ifndef __MYORDER_H
#define __MYORDER_H

/*
OSTART		//启动系统
ONSTART		//关闭系统

OAUTO		//开启自动巡查模式
ONAUTO		//关闭自动巡查模式
OMAUTO		//开启自动转动
ONMAUTO		//关闭自动转动

OBUZZER		//开启报警蜂鸣器
ONBUZZER	//关闭报警蜂鸣器

OLEFT		//向左
ORIGHT		//向右

OLLEFT		//持续向左
ORRIGHT		//持续向右
ONLLEFT		//停止持续向左
ONRRIGHT	//停止持续向右
*/

void MYOrder_Judge(char str[]);

void MYOrder_Order(char str[]);
void MYOrder_Setting(char str[]);

void MYOrder_SentStr(void);

#endif

sys

#ifndef __SYS_H_
#define __SYS_H_
 

/********************************************************************/
																    
#define BITBAND(addr, bitnum) ((addr & 0xF0000000)+0x2000000+((addr &0xFFFFF)<<5)+(bitnum<<2)) 
#define MEM_ADDR(addr)  *((volatile unsigned long  *)(addr)) 
#define BIT_ADDR(addr, bitnum)   MEM_ADDR(BITBAND(addr, bitnum)) 
 
/*                    IO口地址映射                    */
#define GPIOA_ODR_Addr    (GPIOA_BASE+12) //0x4001080C 
#define GPIOB_ODR_Addr    (GPIOB_BASE+12) //0x40010C0C 
#define GPIOC_ODR_Addr    (GPIOC_BASE+12) //0x4001100C 
#define GPIOD_ODR_Addr    (GPIOD_BASE+12) //0x4001140C 
#define GPIOE_ODR_Addr    (GPIOE_BASE+12) //0x4001180C 
#define GPIOF_ODR_Addr    (GPIOF_BASE+12) //0x40011A0C    
#define GPIOG_ODR_Addr    (GPIOG_BASE+12) //0x40011E0C    
 
#define GPIOA_IDR_Addr    (GPIOA_BASE+8) //0x40010808 
#define GPIOB_IDR_Addr    (GPIOB_BASE+8) //0x40010C08 
#define GPIOC_IDR_Addr    (GPIOC_BASE+8) //0x40011008 
#define GPIOD_IDR_Addr    (GPIOD_BASE+8) //0x40011408 
#define GPIOE_IDR_Addr    (GPIOE_BASE+8) //0x40011808 
#define GPIOF_IDR_Addr    (GPIOF_BASE+8) //0x40011A08 
#define GPIOG_IDR_Addr    (GPIOG_BASE+8) //0x40011E08 
/****************************************************/
 
/*             IO口操作,只对单一的IO口!             */
#define PAout(n)   BIT_ADDR(GPIOA_ODR_Addr,n)  //输出 
#define PAin(n)    BIT_ADDR(GPIOA_IDR_Addr,n)  //输入 
 
#define PBout(n)   BIT_ADDR(GPIOB_ODR_Addr,n)  //输出 
#define PBin(n)    BIT_ADDR(GPIOB_IDR_Addr,n)  //输入 
 
#define PCout(n)   BIT_ADDR(GPIOC_ODR_Addr,n)  //输出 
#define PCin(n)    BIT_ADDR(GPIOC_IDR_Addr,n)  //输入 
 
#define PDout(n)   BIT_ADDR(GPIOD_ODR_Addr,n)  //输出 
#define PDin(n)    BIT_ADDR(GPIOD_IDR_Addr,n)  //输入 
 
#define PEout(n)   BIT_ADDR(GPIOE_ODR_Addr,n)  //输出 
#define PEin(n)    BIT_ADDR(GPIOE_IDR_Addr,n)  //输入
 
#define PFout(n)   BIT_ADDR(GPIOF_ODR_Addr,n)  //输出 
#define PFin(n)    BIT_ADDR(GPIOF_IDR_Addr,n)  //输入
 
#define PGout(n)   BIT_ADDR(GPIOG_ODR_Addr,n)  //输出 
#define PGin(n)    BIT_ADDR(GPIOG_IDR_Addr,n)  //输入
/****************************************************/
 
#endif

main

#include "stm32f10x.h"                  

#include "MYLed.h"
#include "MYDelay.h"
#include "MYMotor.h"
#include "MYBuzzer.h"
#include "MYSerial.h"
#include "MYOrder.h"
#include "OLED.h"
#include "MYSound.h"
#include "MYTimer.h"
#include "MYTemper.h"

int main(void) {
	
	//取消部分引脚的初始态 PA 13 14 15  PB 3 4
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);
	GPIO_PinRemapConfig(GPIO_Remap_SWJ_Disable, ENABLE);
	
	//默认初始化函数
	MYDelay_Init();
	OLED_Init();
	MYMotor_Init();
	MYLed_Init();
	MYBuzzer_Init();
	MYSound_Init();//包含ECHO的EXTI初始化
	MYTemper_Init();
	
	//中断优先级设置
	MYSerial_NVIC_PriorityGroupConfig_Init(); 
	//中断初始化
//	MYSerial_USART1_Init();
	MYSerial_USART2_Init();
	MYTimer2_Internal_Init();

	extern uint16_t Dis;
	extern int MYAngle_now;
	extern uint8_t S_DISTANCE;
	extern uint8_t judgeBuzzerflag;
	extern int SYSSTART;
	OLED_ShowString(1,1,"UMARAAS");
//	OLED_ShowString(2,1,"temper:");
//	OLED_ShowString(2,10,"cel");
//	OLED_ShowString(3,1,"distance:");
//	OLED_ShowString(3,14,"cm");
//	OLED_ShowString(4,1,"angle:");
//	OLED_ShowString(4,11,"deg");
	while(1) {
		//TODO
		if(MYSerial_USART2_GetRxPacketFlag() == 1) { //蓝牙收到数据
			
			OLED_Clear(); //OLED清屏
			OLED_ShowString(1, 1, MYSerial_USART2_RxPacketData); //显示命令
			
//			MYSerial_USART1_SentString(MYSerial_USART2_RxPacketData); //通过串口发送命令到电脑
//			MYSerial_USART1_SentString("\r\n");
			
			MYOrder_Judge(MYSerial_USART2_RxPacketData);//执行命令
		}
		MYOrder_SentStr();
		
		OLED_ShowString(2,1,"temper:");
		OLED_ShowNum(2,8,MYTemper_GetTemp(), 2);
		OLED_ShowString(2,10,"cel");
		OLED_ShowString(3,1,"distance:");
		OLED_ShowNum(3,10,Dis, 4);
		OLED_ShowString(3,14,"cm");
		OLED_ShowString(4,1,"angle:");
		OLED_ShowSignedNum(4,7,MYAngle_now, 3);
		OLED_ShowString(4,11,"deg");
		
		if(judgeBuzzerflag&&SYSSTART) {
			if(MYSound_GetDistance()<S_DISTANCE) MYBuzzer_ON();
			else MYBuzzer_OFF();
		}
		
	}
}
3000bookworm
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值