code-image-backup-public/fastbee
1
0
Fork 0
mirror of https://gitee.com/beecue/fastbee.git synced 2025-12-18 00:45:55 +08:00
Code Issues Packages Projects Releases Wiki Activity

初始版本

Browse Source
This commit is contained in:
yueming
2021-09-01 14:03:46 +08:00
parent 4e0dc1ed9d
commit 975adfb602
123 changed files with 59901 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

70
firmware/stm32-esp/user/drive/bsp_adc.c Normal file
View File

@@ -0,0 +1,70 @@
#include "bsp_adc.h"
void BSP_ADCInit(void)
{
ADC_InitTypeDef ADC_InitStructure;
GPIO_InitTypeDef GPIO_InitStructure;
RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1 | RCC_APB2Periph_GPIOA, ENABLE);
RCC_ADCCLKConfig(RCC_PCLK2_Div6);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN;
GPIO_Init(GPIOA,&GPIO_InitStructure);
ADC_DeInit(ADC1);
/* ADC1 configuration ------------------------------------------------------*/
ADC_InitStructure.ADC_Mode = ADC_Mode_Independent;
ADC_InitStructure.ADC_ScanConvMode = DISABLE;
ADC_InitStructure.ADC_ContinuousConvMode = DISABLE;
ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None;
ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
ADC_InitStructure.ADC_NbrOfChannel = 1;
ADC_Init(ADC1, &ADC_InitStructure);
ADC_Cmd(ADC1, ENABLE);
ADC_ResetCalibration(ADC1);
while(ADC_GetResetCalibrationStatus(ADC1));
ADC_StartCalibration(ADC1);
while(ADC_GetCalibrationStatus(ADC1));
ADC_SoftwareStartConvCmd(ADC1,ENABLE);
}
float ADC_GetSimpleData(void)
{
float SimpleVoltage = 0;
uint8_t x = 0;
uint32_t total = 0;
for( x = 0;x < 5; x++)
{
// 开启转换,等待DMA传输结束
ADC_RegularChannelConfig(ADC1, ADC_Channel_1, 1, ADC_SampleTime_239Cycles5 );
ADC_SoftwareStartConvCmd(ADC1, ENABLE);
while(!ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC )){}//等待转换结束
total += ADC_GetConversionValue(ADC1);
Delay_ms(2);
}
total = (uint32_t)(total/5);
SimpleVoltage = (float)total*3.3/4096.0*2.0;
return SimpleVoltage;
}

17
firmware/stm32-esp/user/drive/bsp_adc.h Normal file
View File

@@ -0,0 +1,17 @@
#ifndef _BSP_ADC_H_
#define _BSP_ADC_H_
#include "stm32f10x.h"
#include "string.h"
#include "bsp_port.h"
#include "bsp_timer3.h"
#include "basic_data.h"
void BSP_ADCInit(void);
float ADC_GetSimpleData(void);
#endif

53
firmware/stm32-esp/user/drive/bsp_clock.c Normal file
View File

@@ -0,0 +1,53 @@
#include "bsp_clock.h"
static uint8_t fac_us = 0;
static uint16_t fac_ms = 0;
//功能：systick初始化
void BSP_ClockInit(void)
{
SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8); //选择外部时钟 HCLK/8
fac_us=SystemCoreClock/8000000;//为系统时钟的1/8
fac_ms = (uint16_t)fac_us*1000;
}
//功能：毫秒级延时,最多1864ms
void Delay_ms(uint32_t nms)
{
uint32_t temp = 0;
SysTick->LOAD=(uint32_t)nms*fac_ms;//时间加载(SysTick->LOAD为24bit)
SysTick->VAL =0x00; //清空计数器
SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk ; //开始倒数
do
{
temp=SysTick->CTRL;
}
while( (temp&0x01) && (!(temp&(1<<16))) );//等待时间到达
SysTick->CTRL&=~SysTick_CTRL_ENABLE_Msk; //关闭计数器
SysTick->VAL =0X00; //清空计数器
}
//功能：微秒级延时，最多1800ms
void Delay_us(uint32_t nus)
{
uint32_t temp;
SysTick->LOAD=nus*fac_us; //时间加载
SysTick->VAL=0x00; //清空计数器
SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk ; //开始倒数
do
{
temp=SysTick->CTRL;
}
while( (temp&0x01) && (!(temp&(1<<16))) );//等待时间到达
SysTick->CTRL&=~SysTick_CTRL_ENABLE_Msk; //关闭计数器
SysTick->VAL =0X00; //清空计数器
}

12
firmware/stm32-esp/user/drive/bsp_clock.h Normal file
View File

@@ -0,0 +1,12 @@
#ifndef _BSP_CLOCK_H_
#define _BSP_CLOCK_H_
#include "stm32f10x.h"
void Delay_ms(uint32_t nms);
void Delay_us(uint32_t nus);
void BSP_ClockInit(void);
#endif

74
firmware/stm32-esp/user/drive/bsp_port.c Normal file
View File

@@ -0,0 +1,74 @@
#include "bsp_port.h"
// 禁用JTAG引脚,保留SWD引脚
void Sys_DisableJTAGEnableSWD(void)
{
RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO,ENABLE); //开启AFIO时钟
GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable,ENABLE); //禁止JTAG功能
}
// PM 初始化
void BSP_PowerInit(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
EXTI_InitTypeDef EXTI_InitStructure;
NVIC_InitTypeDef NVIC_InitStructure;
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB|RCC_APB2Periph_GPIOC,ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1|GPIO_Pin_12|GPIO_Pin_13;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOB,&GPIO_InitStructure);
Power_PMD4(0); Power_3V3(0); Power_LCD(0);
// 唤醒/正在充电指示/充电完成
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13|GPIO_Pin_14;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
GPIO_Init(GPIOC,&GPIO_InitStructure);
/* Configure one bit for preemption priority */
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1);
/* 配置P[A|B|C|D|E]0为中断源 */
NVIC_InitStructure.NVIC_IRQChannel = EXTI15_10_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_15;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPD;
GPIO_Init(GPIOC,&GPIO_InitStructure);
GPIO_EXTILineConfig(GPIO_PortSourceGPIOC, GPIO_PinSource15);
EXTI_InitStructure.EXTI_Line = EXTI15_10_IRQn;
EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising; //下降沿中断
EXTI_InitStructure.EXTI_LineCmd = ENABLE;
EXTI_Init(&EXTI_InitStructure);
}
void EXTI15_10_IRQHandler(void)
{
if(EXTI_GetITStatus(EXTI_Line15) != RESET)
{
EXTI_ClearITPendingBit(EXTI_Line15);
if(DevParam.RunPhase == 0)
{
BSP_Restart();
}
}
}
// mcu 重新启动
void BSP_Restart(void){
__set_FAULTMASK(1);
NVIC_SystemReset();
}

34
firmware/stm32-esp/user/drive/bsp_port.h Normal file
View File

@@ -0,0 +1,34 @@
#ifndef _BSP_PORT_H_
#define _BSP_PORT_H_
#include "stm32f10x.h"
#include "bsp_clock.h"
#include "bsp_timer3.h"
#include "basic_data.h"
// 禁用JTAG引脚,保留SWD引脚
void Sys_DisableJTAGEnableSWD(void);
#define Power_PMD4(x) (x)?GPIO_SetBits(GPIOB,GPIO_Pin_1) :GPIO_ResetBits(GPIOB,GPIO_Pin_1) // PM2.5
#define Power_LCD(x) (x)?GPIO_SetBits(GPIOB,GPIO_Pin_12):GPIO_ResetBits(GPIOB,GPIO_Pin_12)// LCD
#define Power_3V3(x) (x)?GPIO_SetBits(GPIOB,GPIO_Pin_13):GPIO_ResetBits(GPIOB,GPIO_Pin_13)// 3.3V
#define Read_BatCharging() GPIO_ReadInputDataBit(GPIOC, GPIO_Pin_13)// 电池充电中状态，低电平有效
#define Read_BatComplete() GPIO_ReadInputDataBit(GPIOC, GPIO_Pin_14)// 电池充电完成状态，低电平有效
#define Read_BootKey() GPIO_ReadInputDataBit(GPIOC, GPIO_Pin_15)// 开机按键
void BSP_PowerInit(void);
void Dev_ReadIndicate(void);
// 重启
void BSP_Restart(void);
#endif

123
firmware/stm32-esp/user/drive/bsp_timer3.c Normal file
View File

@@ -0,0 +1,123 @@
#include "bsp_timer3.h"
/*如果Period=N*10，那么每隔N毫秒中断一次。*/
void BSP_Timer3Init(void){
TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
NVIC_InitTypeDef NVIC_InitStructure;
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE); //时钟使能
TIM_TimeBaseStructure.TIM_Period = 9; //设置在下一个更新事件装入活动的自动重装载寄存器周期的值 计数到N*10为Nms
TIM_TimeBaseStructure.TIM_Prescaler =(7200-1); //设置用来作为TIMx时钟频率除数的预分频值 10Khz的计数频率
TIM_TimeBaseStructure.TIM_ClockDivision = 0; //设置时钟分割:TDTS = Tck_tim
TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up; //TIM向上计数模式
TIM_TimeBaseInit(TIM3, &TIM_TimeBaseStructure); //根据TIM_TimeBaseInitStruct中指定的参数初始化TIMx的时间基数单位
TIM_ITConfig( //使能或者失能指定的TIM中断
TIM3, //TIM3
TIM_IT_Update| //TIM 中断源
TIM_IT_Trigger,//TIM 触发中断源
ENABLE //使能
);
/*配置中断优先级*/
NVIC_InitStructure.NVIC_IRQChannel = TIM3_IRQn; //TIM3中断
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0; //先占优先级0级
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3; //从优先级3级
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //IRQ通道被使能
NVIC_Init(&NVIC_InitStructure);//根据NVIC_InitStruct中指定的参数初始化外设NVIC寄存器
TIM_Cmd(TIM3, ENABLE); //使能TIMx外设
}
uint16_t UART2Count = 0;
uint8_t UART2RecTime = 0;
uint16_t UART3Count = 0;
uint8_t UART3RecTime = 0;
void TIM3_IRQHandler(void) //TIM3中断服务程序
{
if (TIM_GetITStatus(TIM3, TIM_IT_Update) != RESET)//检查指定的TIM中断发生与否
{
TIM_ClearITPendingBit(TIM3,TIM_IT_Update); //清除TIMx的中断标志位
// 串口2接收判断
if((UART2ReadFlag!=0)&&(!(UART2ReadFlag&0x8000)))
{
if(UART2RecTime<=200)
UART2RecTime++;
if(UART2RecTime >= 20)
{
if(UART2Count == UART2ReadFlag)
{
UART2ReadFlag |= (1 << 15);
UART2Count = 0;
UART2RecTime = 0;
}
else
{
UART2Count = UART2ReadFlag;
UART2RecTime = 0;
}
}
}
else { UART2RecTime = 0; UART2Count = 0; }
// 串口3接收判断
if((UART3ReadFlag!=0)&&(!(UART3ReadFlag&0x8000)))
{
if(UART3RecTime <= 100)
UART3RecTime++;
if(UART3RecTime >= 20)
{
if(UART3Count == UART3ReadFlag)
{
UART3ReadFlag |= (1 << 15);
UART3Count = 0;
UART3RecTime = 0;
}
else
{
UART3Count = UART3ReadFlag;
UART3RecTime = 0;
}
}
}
else { UART3RecTime = 0; UART3Count = 0; }
// 空气信息获取时间
if(DevParam.AirInforGetTime<65000)
DevParam.AirInforGetTime++;
// 电池图标刷新时间
if(DevParam.BatIconRefreshTime<65000)
DevParam.BatIconRefreshTime++;
// 电池信息获取时间
if(DevParam.BatInforGetTime<65000)
DevParam.BatInforGetTime++;
// 侧边跳动时间
if(DevParam.SideBeatTime<65000)
DevParam.SideBeatTime++;
// 上报到服务器状态时间
if(DevParam.ServerUpdateTime<65000)
DevParam.ServerUpdateTime++;
// 发送时间
if(DevParam.ESP8266SendTime<65000)
DevParam.ESP8266SendTime++;
}
}

15
firmware/stm32-esp/user/drive/bsp_timer3.h Normal file
View File

@@ -0,0 +1,15 @@
#ifndef _BSP_TIMER3_H_
#define _BSP_TIMER3_H_
#include "stm32f10x.h"
#include "bsp_uart3.h"
#include "esp8266_uart2.h"
#include "basic_data.h"
void BSP_Timer3Init(void);
#endif

2
firmware/stm32-esp/user/drive/bsp_tool.c Normal file
View File

@@ -0,0 +1,2 @@
#include "bsp_tool.h"

11
firmware/stm32-esp/user/drive/bsp_tool.h Normal file
View File

@@ -0,0 +1,11 @@
#ifndef _BSP_TOOL_H_
#define _BSP_TOOL_H_
#include "stm32f10x.h"
#include "bsp_clock.h"
#include "basic_data.h"
#endif

107
firmware/stm32-esp/user/drive/bsp_uart1.c Normal file
View File

@@ -0,0 +1,107 @@
#include "bsp_uart1.h"
void BSP_UART1SendStr(char *ch){
uint16_t i = 0,j = 0;
j = strlen(ch);
for(i = 0;i < j;i++)
{
while(USART_GetFlagStatus(USART1,USART_FLAG_TC)==RESET){};
USART_SendData(USART1,ch[i]);
}
while(USART_GetFlagStatus(USART1,USART_FLAG_TC)==RESET);
}
// 发送数据
void BSP_UART1SendData(uint8_t *ch,uint16_t len){
uint16_t i;
for(i = 0;i < len;i++)
{
while(USART_GetFlagStatus(USART1,USART_FLAG_TC)==RESET){};
USART_SendData(USART1,ch[i]);
}
while(USART_GetFlagStatus(USART1,USART_FLAG_TC)==RESET);
}
void BSP_UART1Init(uint32_t bound){
GPIO_InitTypeDef GPIO_InitStructure;
USART_InitTypeDef USART_InitStructure;
NVIC_InitTypeDef NVIC_InitStructure;
//使能USART1,GPIOA
RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1|RCC_APB2Periph_GPIOA,ENABLE);
//USART1_TX GPIOA.9
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_Init(GPIOA, &GPIO_InitStructure);
//USART1_RX GPIOA.10初始化
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
GPIO_Init(GPIOA, &GPIO_InitStructure);
//Usart1 NVIC 配置
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority= 3;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
//USART 初始化设置
USART_InitStructure.USART_BaudRate = bound;
USART_InitStructure.USART_WordLength = USART_WordLength_8b;
USART_InitStructure.USART_StopBits = USART_StopBits_1;
USART_InitStructure.USART_Parity = USART_Parity_No;
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
USART_Init(USART1,&USART_InitStructure);
USART_ITConfig(USART1,USART_IT_RXNE,ENABLE);
USART_Cmd(USART1, ENABLE);
}
// 读取USARTx->SR能避免莫名其妙的错误
uint8_t Usart1ReadBuf[100] = {0};
uint16_t Usart1ReadFlag = 0;
void USART1_IRQHandler(void){
uint8_t res = 0;
if(USART_GetITStatus(USART1,USART_IT_RXNE) != RESET)
{
res =USART_ReceiveData(USART1);
// 是否存在数据没有处理
if( (Usart1ReadFlag&0x8000)==0 )
{
Usart1ReadBuf[Usart1ReadFlag] = res;
Usart1ReadFlag++;
// 判断是否接收结束
if(Usart1ReadFlag>=90)
{
Usart1ReadFlag |= (1 << 15);
}
}
}
//溢出-如果发生溢出需要先读SR,再读DR,则可清除不断入中断的问题
if( USART_GetFlagStatus(USART1,USART_FLAG_ORE)==SET )
{
USART_ReceiveData(USART1);
USART_ClearFlag(USART1,USART_FLAG_ORE);
}
USART_ClearFlag(USART1,USART_IT_RXNE);
}

22
firmware/stm32-esp/user/drive/bsp_uart1.h Normal file
View File

@@ -0,0 +1,22 @@
#ifndef _BSP_UART1_H_
#define _BSP_UART1_H_
#include "stm32f10x.h"
#include "bsp_clock.h"
#include "stdio.h"
#include "string.h"
#include "stdarg.h"
#include "bsp_timer3.h"
void Sys_SendLog(const char *fmt, ...);
// 判断串口01接收完成
void BSP_UART1RecComplete(uint64_t Std_1ms);
void BSP_UART1SendStr(char *ch);
void BSP_UART1SendData(uint8_t *ch,uint16_t len);
void BSP_UART1Init(uint32_t bound);
#endif

111
firmware/stm32-esp/user/drive/bsp_uart2.c Normal file
View File

@@ -0,0 +1,111 @@
#include "bsp_uart2.h"
// 串口2 PA2 TX PA3 RX
void Dev_UART2SendStr(char* fmt,...){
uint8_t tbuf[200] = {0};
uint16_t i = 0,j = 0;
va_list ap;
va_start(ap,fmt);
vsprintf((char*)tbuf, fmt, ap);
va_end(ap);
j = strlen((const char*)tbuf);
for( i = 0; i < j; i++)
{
while(USART_GetFlagStatus(USART2, USART_FLAG_TC)==RESET){};
USART_SendData(USART2, tbuf[i]);
}
while(USART_GetFlagStatus(USART2, USART_FLAG_TC)==RESET);
}
// 发送数据
void Dev_UART2SendData(uint8_t *ch,uint16_t len){
uint16_t i = 0;
for(i = 0;i < len;i++)
{
while(USART_GetFlagStatus(USART2,USART_FLAG_TC)==RESET){};
USART_SendData(USART2,ch[i]);
}
while(USART_GetFlagStatus(USART2,USART_FLAG_TC)==RESET);
}
void BSP_UART2Init(uint32_t bound)
{
GPIO_InitTypeDef GPIO_InitStructure;
USART_InitTypeDef USART_InitStructure;
NVIC_InitTypeDef NVIC_InitStructure;
//使能USART,GPIO
RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2,ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_Init(GPIOA, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
GPIO_Init(GPIOA, &GPIO_InitStructure);
// NVIC 配置
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority= 3;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
// USART 配置
USART_InitStructure.USART_BaudRate = bound;
USART_InitStructure.USART_WordLength = USART_WordLength_8b;
USART_InitStructure.USART_StopBits = USART_StopBits_1;
USART_InitStructure.USART_Parity = USART_Parity_No;
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
USART_Init(USART2, &USART_InitStructure);
USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);//开启串口接受中断
USART_Cmd(USART2, ENABLE); //使能串口
}
/*读取USARTx->SR能避免莫名其妙的错误*/
void USART2_IRQHandler(void)
{
uint8_t res = 0;
if(USART_GetITStatus(USART2, USART_IT_RXNE)!=RESET)
{
res = USART_ReceiveData(USART2);
// 是否存在数据没有处理
if( (UART2ReadFlag&0x8000)==0 )
{
UART2ReadBuf[UART2ReadFlag++] = res;
if(UART2ReadFlag>=90)
{
UART2ReadFlag |= (1 << 15);
}
}
}
/*溢出-如果发生溢出需要先读SR,再读DR寄存器则可清除不断入中断的问题*/
if( USART_GetFlagStatus(USART2, USART_FLAG_ORE)==SET )
{
USART_ReceiveData(USART2);
USART_ClearFlag(USART2, USART_FLAG_ORE);
}
USART_ClearFlag(USART2, USART_IT_RXNE);
}

19
firmware/stm32-esp/user/drive/bsp_uart2.h Normal file
View File

@@ -0,0 +1,19 @@
#ifndef _BSP_UART2_H_
#define _BSP_UART2_H_
#include "stm32f10x.h"
#include "bsp_clock.h"
#include "stdio.h"
#include "string.h"
#include "stdarg.h"
#include "bsp_timer3.h"
#include "basic_data.h"
void Dev_UART2SendStr(char* fmt,...);
void Dev_UART2SendData(uint8_t *ch, uint16_t len);
void BSP_UART2Init(uint32_t bound);
#endif

109
firmware/stm32-esp/user/drive/bsp_uart3.c Normal file
View File

@@ -0,0 +1,109 @@
#include "bsp_uart3.h"
// 串口3 PB10 TX PB11 RX
void BSP_UART3SendStr(char *ch){
uint16_t i = 0,j = 0;
j = strlen(ch);
for(i = 0;i < j;i++)
{
while(USART_GetFlagStatus(USART3,USART_FLAG_TC)==RESET){};
USART_SendData(USART3,ch[i]);
}
while(USART_GetFlagStatus(USART3,USART_FLAG_TC)==RESET);
}
// 发送数据
void BSP_UART3SendData(uint8_t *ch,uint16_t len){
uint16_t i = 0;
for(i = 0;i < len;i++)
{
while(USART_GetFlagStatus(USART3,USART_FLAG_TC)==RESET){};
USART_SendData(USART3,ch[i]);
}
while(USART_GetFlagStatus(USART3,USART_FLAG_TC)==RESET);
}
void BSP_UART3Init(uint32_t bound){
GPIO_InitTypeDef GPIO_InitStructure;
USART_InitTypeDef USART_InitStructure;
NVIC_InitTypeDef NVIC_InitStructure;
//使能USART3,GPIOB
RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3,ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
//USART3_TX GPIOB10
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_Init(GPIOB, &GPIO_InitStructure);
//USART3_RX GPIOB11
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
GPIO_Init(GPIOB, &GPIO_InitStructure);
//Usart3 NVIC 配置
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
NVIC_InitStructure.NVIC_IRQChannel = USART3_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority= 3;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
//USART 初始化设置
USART_InitStructure.USART_BaudRate = bound;
USART_InitStructure.USART_WordLength = USART_WordLength_8b;
USART_InitStructure.USART_StopBits = USART_StopBits_1;
USART_InitStructure.USART_Parity = USART_Parity_No;
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
USART_Init(USART3, &USART_InitStructure);
USART_ITConfig(USART3, USART_IT_RXNE, ENABLE);//开启串口接受中断
USART_Cmd(USART3, ENABLE); //使能串口
}
// 读取USARTx->SR能避免莫名其妙的错误
uint8_t Usart3ReadBuf[60] = {0};
uint16_t Usart3ReadFlag = 0;
void USART3_IRQHandler(void)
{
uint8_t res = 0;
if(USART_GetITStatus(USART3, USART_IT_RXNE) != RESET)
{
res = USART_ReceiveData(USART3);
// 是否存在数据没有处理
if( (Usart3ReadFlag&0x8000)==0 )
{
Usart3ReadBuf[Usart3ReadFlag] = res;
Usart3ReadFlag++;
if(Usart3ReadFlag>=59)
{
Usart3ReadFlag |= (1 << 15);
}
}
}
//溢出-如果发生溢出需要先读SR,再读DR寄存器则可清除不断入中断的问题
if( USART_GetFlagStatus(USART3,USART_FLAG_ORE)==SET )
{
USART_ReceiveData(USART3);
USART_ClearFlag(USART3,USART_FLAG_ORE);
}
USART_ClearFlag(USART3,USART_IT_RXNE);
}

18
firmware/stm32-esp/user/drive/bsp_uart3.h Normal file
View File

@@ -0,0 +1,18 @@
#ifndef _BSP_UART3_H_
#define _BSP_UART3_H_
#include "stm32f10x.h"
#include "bsp_clock.h"
#include "stdio.h"
#include "string.h"
#include "basic_data.h"
// 判断串口03接收完成
void BSP_UART3SendStr(char *ch);
void BSP_UART3SendData(uint8_t *ch,uint16_t len);
void BSP_UART3Init(uint32_t bound);
#endif