1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

QSPI_HandleTypeDef hqspi;
UART_HandleTypeDef huart1;
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_USART1_UART_Init(void);
static void MX_QUADSPI_Init(void);
typedef  void (*pFunction)(void);

int main(void)
{
	SCB_EnableICache();		// 使能ICache
	SCB_EnableDCache();		// 使能DCache
    HAL_Init();
    SystemClock_Config();
    MX_GPIO_Init();
    MX_USART1_UART_Init();
    MX_QUADSPI_Init();
	QSPI_W25Qxx_Init();
	
	QSPI_W25Qxx_MemoryMappedMode(); 	 // 配置QSPI为内存映射模式
	SCB_DisableICache();		// 关闭ICache
	SCB_DisableDCache();		// 关闭Dcache
	SysTick->CTRL = 0;		// 关闭SysTick
	SysTick->LOAD = 0;		// 清零重载值
	SysTick->VAL = 0;			// 清零计数值
	JumpToApplication = (pFunction) (*(__IO uint32_t*) (W25Qxx_Mem_Addr + 4));	// 设置起始地址
	__set_MSP(*(__IO uint32_t*) W25Qxx_Mem_Addr);	// 设置主堆栈指针
	JumpToApplication();			// 执行跳转
  while (1);
}

1

SCB->VTOR = 0x90000000; // 重定向向量表

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

#include "EventRecorder.h"
int main(void)
{

  /* USER CODE BEGIN 1 */
	//放最前面
	EventRecorderInitialize(EventRecordAll, 1U);
	EventRecorderStart();
  /* USER CODE END 1 */

  /* MPU Configuration--------------------------------------------------------*/
  MPU_Config();
  while (1)
  {
		printf("hello world from SWD");
		HAL_Delay(1000);
  }
  /* USER CODE END 3 */
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

// 设计的板子的外部晶振要与这个一致（25MHz）
#define HSE_VALUE    (25000000UL)
// 注意滴答定时器的优先级，如果你需要在中断函数中使用HAL_Delay()时，因为delay需要基于滴答计时器进行计时，如果优先级较低会卡死。
#define  TICK_INT_PRIORITY            (15UL) /*!< tick interrupt priority */
// STM32H7 的 SDIO 外接支持 UHS-I 模式 (SDR12, SDR25, SDR50, SDR104 和 DDR50)
的 SD 卡， 需要 1.8 的电平转换器， 此选项就是来使能此功能用的
#define  USE_SD_TRANSCEIVER           0U               /*!< use uSD Transceiver */


// 使能断言函数（需要自己重写void assert_failed(uint8_t *file, uint32_t line)）默认关闭
#define USE_FULL_ASSERT    1U
#ifdef  USE_FULL_ASSERT
/**
  * @brief  The assert_param macro is used for function's parameters check.
  * @param  expr: If expr is false, it calls assert_failed function
  *         which reports the name of the source file and the source
  *         line number of the call that failed.
  *         If expr is true, it returns no value.
  * @retval None
  */
  #define assert_param(expr) ((expr) ? (void)0U : assert_failed((uint8_t *)__FILE__, __LINE__))
/* Exported functions ------------------------------------------------------- */
  void assert_failed(uint8_t *file, uint32_t line);
#else
  #define assert_param(expr) ((void)0U)
#endif /* USE_FULL_ASSERT */

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104

/*
******************************************************************************************************
*        函 数 名: bsp_Init
*        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。
*              只需要调用一次
*        形    参：无
*        返 回 值: 无
******************************************************************************************************
*/
void bsp_Init(void)
{
    		/* 配置MPU(内存保护) */
        MPU_Config();
        
        /* 使能L1 Cache */
        CPU_CACHE_Enable();

        /* 
       STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
           - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
           - 设置NVIV优先级分组为4。
         */
        HAL_Init();

        /* 
       配置系统时钟到400MHz
       - 切换使用HSE。
       - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
       - 它会开启滴答定时器中断，如果用户也要使用滴答定时器中断，此问
题就要引起注意。（见下面代码）
    */
        SystemClock_Config();

        
        bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
        bsp_InitTimer();          /* 初始化滴答定时器 */
        bsp_InitUart();        /* 初始化串口 */
        bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
        bsp_InitLed();            /* 初始化LED */        
        
        bsp_InitLPTIMOutPWM(); /* 低功耗定时器PWM输出 */
}

/*
*********************************************************************************************************
*        函 数 名: SysTick_Handler
*        功能说明: 系统嘀嗒定时器中断服务程序。启动文件中引用了该函数。
*        形    参:  无
*        返 回 值: 无
*********************************************************************************************************
*/
void SysTick_Handler(void)
{
        HAL_IncTick();        /* ST HAL库的滴答定时中断服务程序 */
        
        if (g_ucEnableSystickISR == 0) /* bsp配置的bsp层SysTickHandle使能标志，调用了函数bsp_InitTimer才置位此变量 */
        {
                return;
        }
        
        SysTick_ISR();        /* 安富莱bsp库的滴答定时中断服务程序 */
}

// 上面的函数注释
__weak void HAL_IncTick(void)
{
  uwTick += (uint32_t)uwTickFreq;
}
void SysTick_ISR(void)
{
	static uint8_t s_count = 0;
	uint8_t i;
	
	/* 每隔1ms进来1次 （仅用于 bsp_DelayMS） */
	if (s_uiDelayCount > 0)
	{
		if (--s_uiDelayCount == 0)
		{
			s_ucTimeOutFlag = 1;
		}
	}

	/* 每隔1ms，对软件定时器的计数器进行减一操作 */
	for (i = 0; i < TMR_COUNT; i++)
	{
		bsp_SoftTimerDec(&s_tTmr[i]);
	}

	/* 全局运行时间每1ms增1 */
	g_iRunTime++;
	if (g_iRunTime == 0x7FFFFFFF)	/* 这个变量是 int32_t 类型，最大数为 0x7FFFFFFF */
	{
		g_iRunTime = 0;
	}

	bsp_RunPer1ms();		/* 每隔1ms调用一次此函数，此函数在 bsp.c */

	if (++s_count >= 10)
	{
		s_count = 0;

		bsp_RunPer10ms();	/* 每隔10ms调用一次此函数，此函数在 bsp.c */
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

HAL_UART_Init()->__weak HAL_UART_MspInit();// 在此进行初始化

void HAL_UART_MspInit(UART_HandleTypeDef* huart)
{
        GPIO_InitTypeDef GPIO_InitStruct = {0};
        
        if(huart->Instance==USART1)
        {
                __HAL_RCC_USART1_CLK_ENABLE();

                __HAL_RCC_GPIOB_CLK_ENABLE();

                GPIO_InitStruct.Pin = GPIO_PIN_7;
                GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
                GPIO_InitStruct.Pull = GPIO_NOPULL;
                GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
                GPIO_InitStruct.Alternate = GPIO_AF7_USART1;
                HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

                GPIO_InitStruct.Pin = GPIO_PIN_14;
                GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
                GPIO_InitStruct.Pull = GPIO_NOPULL;
                GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
                GPIO_InitStruct.Alternate = GPIO_AF4_USART1;
                HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
        }
        else if(huart->Instance==USART2)
        {
                __HAL_RCC_USART2_CLK_ENABLE();

                __HAL_RCC_GPIOD_CLK_ENABLE();
                __HAL_RCC_GPIOA_CLK_ENABLE();

                GPIO_InitStruct.Pin = GPIO_PIN_6;
                GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
                GPIO_InitStruct.Pull = GPIO_NOPULL;
                GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
                GPIO_InitStruct.Alternate = GPIO_AF7_USART2;
                HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);

                GPIO_InitStruct.Pin = GPIO_PIN_2;
                GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
                GPIO_InitStruct.Pull = GPIO_NOPULL;
                GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
                GPIO_InitStruct.Alternate = GPIO_AF7_USART2;
                HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
        }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

HAL_UART_TxHalfCpltCallback()  //DMA 发送模式下，发送缓冲区前半部分传输完成
HAL_UART_TxCpltCallback()  //中断或 DMA 模式下，整个发送完成
HAL_UART_RxHalfCpltCallback()  //DMA 接收模式下，接收缓冲区前半部分接收完成
//中断模式：单次接收完成；
//DMA 模式：整个缓冲区接收完成
HAL_UART_RxCpltCallback()
HAL_UART_ErrorCallback()

//调用 HAL_UART_Abort() 后，发送和接收都中止完成时调用
HAL_UART_AbortCpltCallback(UART_HandleTypeDef *huart)	
// 调用 HAL_UART_AbortTransmit() 后，发送中止完成
HAL_UART_AbortTransmitCpltCallback(UART_HandleTypeDef *huart)	
//调用 HAL_UART_AbortReceive() 后，接收中止完成
HAL_UART_AbortReceiveCpltCallback(UART_HandleTypeDef *huart)	

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

HAL_UART_Transmit_DMA()
HAL_UART_Receive_DMA()
HAL_UART_DMAPause()
HAL_UART_DMAResume()
HAL_UART_DMAStop()

// 针对外设的 DMA 函数基本都有开启中断， 如果用户使能此外设的 NVIC， 使用
中务必别忘了写 DMA 的中断服务程序
void DMA1_Stream1_IRQHandler(void)
{
/* 参数是 DMA 句柄 */
HAL_DMA_IRQHandler(&hdma_usart1_tx);
}

1
2
3
4
5
6
7

硬件复位后：
设置堆栈指针 SP = __initial_sp。
- 设置 PC 指针 = Reset_Handler。
- 设置中断向量表。
- 配置系统时钟。
- 配置外部 SRAM/SDRAM 用于程序变量等数据存储（这是可选的） 。
- 跳转到 C 库中的 __main ，最终会调用用户程序的 main()函数

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191

; Amount of memory (in bytes) allocated for Stack
; Tailor this value to your application needs
; <h> Stack Configuration
;   <o> Stack Size (in Bytes) <0x0-0xFFFFFFFF:8>
; </h>

Stack_Size      EQU     0x00001000

                AREA    STACK, NOINIT, READWRITE, ALIGN=3
Stack_Mem       SPACE   Stack_Size
__initial_sp

0x00001000 表示栈大小，注意这里是以字节为单位

ARER 伪指令表示下面将开始定义一个代码段或者数据段。此处是定义数据段。 
STACK ：表示这个段的名字，可以任意命名。
NOINIT：表示此数据段不需要填入初始数据。
READWRITE：表示此段可读可写。
ALIGN=3 ：表示首地址按照 2 的 3 次方对齐，也就是按照 8 字节对齐(地址对 8 求余数等于 0)

SPACE 这行指令告诉汇编器给 STACK 段分配 0x00000400 字节的连续内存空间。

initial_sp 紧接着 SPACE 语句放置，表示了栈顶地址。 __initial_sp只是一个标号，标号主
要用于表示一片内存空间的某个位置



; <h> Heap Configuration
;   <o>  Heap Size (in Bytes) <0x0-0xFFFFFFFF:8>
; </h>

Heap_Size       EQU     0x0000800

                AREA    HEAP, NOINIT, READWRITE, ALIGN=3
__heap_base
Heap_Mem        SPACE   Heap_Size
__heap_limit

__heap_base 表示堆的开始地址。武汉安富莱电子有限公司
__heap_limit 表示堆的结束地址




                PRESERVE8
                THUMB


; Vector Table Mapped to Address 0 at Reset
                AREA    RESET, DATA, READONLY
                EXPORT  __Vectors
                EXPORT  __Vectors_End
                EXPORT  __Vectors_Size

PRESERVE8 指定当前文件保持堆栈八字节对齐。
THUMB 表示后面的指令是 THUMB 指令集 ， CM7 采用的是 THUMB - 2 指令集。
AREA 定义一块数据段，只读，段名字是 RESET。 READONLY 表示只读，缺省就表示代码段了。
3 行 EXPORT 语句将 3 个标号申明为可被外部引用， 主要提供给链接器用于连接库文件或
其他文件。



__Vectors       DCD     __initial_sp                      ; Top of Stack
                DCD     Reset_Handler                     ; Reset Handler
                DCD     NMI_Handler                       ; NMI Handler
                DCD     HardFault_Handler                 ; Hard Fault Handler
                DCD     MemManage_Handler                 ; MPU Fault Handler
                DCD     PendSV_Handler                    ; PendSV Handler
                DCD     SysTick_Handler                   ; SysTick Handler

                ; External Interrupts
                DCD     WWDG_IRQHandler                   ; Window WatchDog interrupt ( wwdg1_it)                                         
                DCD     PVD_AVD_IRQHandler                ; PVD/AVD through EXTI Line detection                        
                DCD     TAMP_STAMP_IRQHandler             ; Tamper and TimeStamps through the EXTI line            
                DCD     RTC_WKUP_IRQHandler               ; RTC Wakeup through the Reserved                                    
                DCD     WAKEUP_PIN_IRQHandler             ; Interrupt for all 6 wake-up pins 
                

__Vectors_End

__Vectors_Size  EQU  __Vectors_End - __Vectors

建立中断向量表，中断向量表定位在代码段的最前面。具体的物理地址由链接器的
配置参数（IROM1 的地址）决定。如果程序在 Flash 运行，则中断向量表的起始地址是 0x08000000。



                AREA    |.text|, CODE, READONLY

; Reset handler
Reset_Handler    PROC
                 EXPORT  Reset_Handler                    [WEAK]
        IMPORT  SystemInit
        IMPORT  __main

                 LDR     R0, =SystemInit
                 BLX     R0
                 LDR     R0, =__main
                 BX      R0
                 ENDP
第 1 行： AREA 定义一块代码段，只读，段名字是 .text 。 READONLY 表示只读。
第 4 行： 利用 PROC、 ENDP这一对伪指令把程序段分为若干个过程，使程序的结构加清晰。
第 5 行： WEAK 声明其他的同名标号优先于该标号被引用,就是说如果外面声明了的话会调用外面的。 这个声明很重要，它让我们可以在 C文件中任意地方放置中断服务程序，只要保证 C 函数的名字和向量表中的名字一致即可。
第 6 行： IMPORT：伪指令用于通知编译器要使用的标号在其他的源文件中定义。但要在当前源文件中引用，而且无论当前源文件是否引用该标号，该标号均会被加入到当前源文件的符号表中。
第 9 行： SystemInit 函数在文件 system_stm32h7xx.c 里面，主要实现 RCC相关寄存器复位和中断向量表位置设置。
第 11 行： __main 标号表示 C/C++标准实时库函数里的一个初始化子程序__main的入口地址。该程序的一个主要作用是初始化堆栈(跳转__user_initial_stackheap标号进行初始化堆栈的，下面会讲到这个标号)，并初始化映像文件，最后跳转到 C 程序中的 main 函数。这就解释了为何所有的 C 程序必须有一个 main 函数作为程序的起点。因为这是由 C/C++标准实时库所规，并且不能更改



; Dummy Exception Handlers (infinite loops which can be modified)

NMI_Handler     PROC
                EXPORT  NMI_Handler                      [WEAK]
                B       .
                ENDP
HardFault_Handler\
                PROC
                EXPORT  HardFault_Handler                [WEAK]
                B       .
                ENDP
MemManage_Handler\
                PROC
                EXPORT  MemManage_Handler                [WEAK]
                B       .
                ENDP                                     

                EXPORT  WWDG_IRQHandler                   [WEAK]                                       
                EXPORT  PVD_AVD_IRQHandler                [WEAK]                         
                EXPORT  TAMP_STAMP_IRQHandler             [WEAK]   
                EXPORT  RTC_WKUP_IRQHandler               [WEAK]             
                EXPORT  FLASH_IRQHandler                  [WEAK]

WWDG_IRQHandler                                                          
PVD_AVD_IRQHandler                                             
TAMP_STAMP_IRQHandler                
RTC_WKUP_IRQHandler                            
FLASH_IRQHandler                                                          
RCC_IRQHandler                                                              
EXTI0_IRQHandler                                                              
EXTI1_IRQHandler                                                             
EXTI2_IRQHandler                                                              
EXTI3_IRQHandler                                                              
EXTI4_IRQHandler 
DMA1_Stream0_IRQHandler                                                         
SAI4_IRQHandler      
WAKEUP_PIN_IRQHandler

                B       .

                ENDP

                ALIGN

第 5 行： 死循环，用户可以在此实现自己的中断服务程序。 不过很少在这里实现中断服务程序，一般多是在其它的 C 文件里面重新写一个同样名字的中断服务程序， 因为这里是 WEEK 弱定义的。 如果没有在其它文件中写中断服务器程序，且使能了此中断，进入到这里后，会让程序卡在这个地方。
第 14 行： 缺省中断服务程序（开始）
第 23 行： 死循环， 如果用户使能中断服务程序，而没有在 C 文件里面写中断服务程序的话，都会进入到
这里。 比如在程序里面使能了串口 1 中断，而没有写中断服务程序 USART1_IRQHandle， 那么串口中断来了，会进入到这个死循环。
第 25 行： 缺省中断服务程序（结束） 。



;*******************************************************************************
; User Stack and Heap initialization
;*******************************************************************************
                 IF      :DEF:__MICROLIB
                
                 EXPORT  __initial_sp
                 EXPORT  __heap_base
                 EXPORT  __heap_limit
                
                 ELSE
                
                 IMPORT  __use_two_region_memory
                 EXPORT  __user_initial_stackheap
                 
__user_initial_stackheap

                 LDR     R0, =  Heap_Mem
                 LDR     R1, =(Stack_Mem + Stack_Size)
                 LDR     R2, = (Heap_Mem +  Heap_Size)
                 LDR     R3, = Stack_Mem
                 BX      LR

                 ALIGN

                 ENDIF

                 END

第 4 行： 简单的汇编语言实现 IF…….ELSE…………语句。如果定义了 MICROLIB，那么程序是不会执行 ELSE分支的代码。 __MICROLIB 可能大家并不陌生，就在 MDK 的 Target Option 里面设置。武汉安富莱电子有限公司
第 5 行： __user_initial_stackheap 将由__main 函数进行调用。

1
2
3
4

#define GPIO_SPEED_FREQ_LOW          ((uint32_t)0x00000000U)  /*!< Low speed    */
#define GPIO_SPEED_FREQ_MEDIUM       ((uint32_t)0x00000001U)  /*!< Medium speed */
#define GPIO_SPEED_FREQ_HIGH         ((uint32_t)0x00000002U)  /*!< Fast speed   */
#define GPIO_SPEED_FREQ_VERY_HIGH    ((uint32_t)0x00000003U)  /*!< High speed   */

1
2
3
4
5
6
7
8

__weak void HAL_IncTick(void)
__weak uint32_t HAL_GetTick(void)
uint32_t HAL_GetTickPrio(void)
HAL_StatusTypeDef HAL_SetTickFreq(HAL_TickFreqTypeDef Freq)
HAL_TickFreqTypeDef HAL_GetTickFreq(void)
__weak void HAL_Delay(uint32_t Delay)
__weak void HAL_SuspendTick(void)
__weak void HAL_ResumeTick(void)

1

void HAL_SYSCFG_AnalogSwitchConfig (uint32_t SYSCFG_AnalogSwitch, uint32_t SYSCFG_SwitchState)

1
2
3
4
5
6

void HAL_EnableCompensationCell(void)
void HAL_DisableCompensationCell (void)       // 分别用于使能或者禁止 IO 补偿，只有在供电电压范围是 2.4V 到 3.6V 之间时，使用此功能才有意义
void HAL_SYSCFG_EnableIOSpeedOptimize (void)
void HAL_SYSCFG_DisableIOSpeedOptimize (void)     // 分别用于优化 IO 速度或者禁止优化，不过仅在供电电压低于 2.5V 时可用，高于 2.5V 是不可以使用的，另外使用这个功能的前提是用户使能了 PRODUCT_BELOW_25V（是可选字节配置选项里面的一个 bit） 。
void HAL_SYSCFG_CompensationCodeSelect (uint32_t SYSCFG_CompCode)     // IO 补偿单元的选择， 函数形参可以是 SYSCFG_CELL_CODE，即寄存器 SYSCFG_CCVR，也可以是SYSCFG_REGISTER_CODE，即寄存器 SYSCFG_CCCR。
void HAL_SYSCFG_CompensationCodeConfig (uint32_t SYSCFG_PMOSCode, uint32_t SYSCFG_NMOSCode)       // 用于设置 GPIO 内部构造中 NMOS 和 PMOS 的补偿值，两个形参的范围都是 0-15。根据用户调用函数 HAL_SYSCFG_CompensationCodeSelect 选择的寄存器，这里仅有一个形参的设置是有效的。

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295

#define KEY_FILTER_TIME   5
#define KEY_LONG_TIME     100     /* 单位10ms， 持续1秒，认为长按事件 */

#define ALL_KEY_GPIO_CLK_ENABLE() { \
    __HAL_RCC_GPIOB_CLK_ENABLE(); \
    __HAL_RCC_GPIOC_CLK_ENABLE(); \
    __HAL_RCC_GPIOG_CLK_ENABLE(); \
    __HAL_RCC_GPIOH_CLK_ENABLE(); \
    __HAL_RCC_GPIOI_CLK_ENABLE(); \
  };
// 初始化
typedef struct
{
  /* 下面是一个函数指针，指向判断按键手否按下的函数 */
  uint8_t (*IsKeyDownFunc)(void); /* 按键按下的判断函数,1表示按下 */

  uint8_t  Count;     /* 滤波器计数器 */
  uint16_t LongCount;   /* 长按计数器 */
  uint16_t LongTime;    /* 按键按下持续时间, 0表示不检测长按 */
  uint8_t  State;     /* 按键当前状态（按下还是弹起） */
  uint8_t  RepeatSpeed; /* 连续按键周期 */
  uint8_t  RepeatCount; /* 连续按键计数器 */
}KEY_T;

#define KEY_FIFO_SIZE 10
typedef struct
{
  uint8_t Buf[KEY_FIFO_SIZE];   /* 键值缓冲区 */
  uint8_t Read;         /* 缓冲区读指针1 */
  uint8_t Write;          /* 缓冲区写指针 */
  uint8_t Read2;          /* 缓冲区读指针2 */
}KEY_FIFO_T;

typedef struct
{
  GPIO_TypeDef* gpio;
  uint16_t pin;
  uint8_t ActiveLevel;  /* 激活电平 */
}X_GPIO_T;
// 注册
static const X_GPIO_T s_gpio_list[HARD_KEY_NUM] = {
  {GPIOI, GPIO_PIN_8, 0},   /* K1 */
  {GPIOC, GPIO_PIN_13, 0},  /* K2 */
  {GPIOH, GPIO_PIN_4, 0},   /* K3 */
  {GPIOG, GPIO_PIN_2, 0},   /* JOY_U */ 
  {GPIOB, GPIO_PIN_0, 0},   /* JOY_D */
  {GPIOG, GPIO_PIN_3, 0},   /* JOY_L */ 
  {GPIOG, GPIO_PIN_7, 0},   /* JOY_R */ 
  {GPIOI, GPIO_PIN_11, 0},  /* JOY_OK */
};

void bsp_InitKey(void);
void bsp_KeyScan10ms(void);
void bsp_PutKey(uint8_t _KeyCode);
uint8_t bsp_GetKey(void);
uint8_t bsp_GetKey2(void);
uint8_t bsp_GetKeyState(KEY_ID_E _ucKeyID);
void bsp_SetKeyParam(uint8_t _ucKeyID, uint16_t _LongTime, uint8_t  _RepeatSpeed);
void bsp_ClearKey(void);

void bsp_InitKey(void)
{
  bsp_InitKeyVar();   /* 初始化按键变量 */
  bsp_InitKeyHard();    /* 初始化按键硬件 */
}

static void bsp_InitKeyHard(void)
{ 
  GPIO_InitTypeDef gpio_init;
  uint8_t i;

  /* 第1步：打开GPIO时钟 */
  ALL_KEY_GPIO_CLK_ENABLE();
  
  /* 第2步：配置所有的按键GPIO为浮动输入模式(实际上CPU复位后就是输入状态) */
  gpio_init.Mode = GPIO_MODE_INPUT;         /* 设置输入 */
  gpio_init.Pull = GPIO_NOPULL;                 /* 上下拉电阻不使能 */
  gpio_init.Speed = GPIO_SPEED_FREQ_VERY_HIGH;  /* GPIO速度等级 */
  
  for (i = 0; i < HARD_KEY_NUM; i++)
  {
    gpio_init.Pin = s_gpio_list[i].pin;
    HAL_GPIO_Init(s_gpio_list[i].gpio, &gpio_init); 
  }
}

static void bsp_InitKeyVar(void)
{
  uint8_t i;

  /* 对按键FIFO读写指针清零 */
  s_tKey.Read = 0;
  s_tKey.Write = 0;
  s_tKey.Read2 = 0;

  /* 给每个按键结构体成员变量赋一组缺省值 */
  for (i = 0; i < KEY_COUNT; i++)
  {
    s_tBtn[i].LongTime = KEY_LONG_TIME;     /* 长按时间 0 表示不检测长按键事件 */
    s_tBtn[i].Count = KEY_FILTER_TIME / 2;    /* 计数器设置为滤波时间的一半 */
    s_tBtn[i].State = 0;              /* 按键缺省状态，0为未按下 */
    s_tBtn[i].RepeatSpeed = 0;            /* 按键连发的速度，0表示不支持连发 */
    s_tBtn[i].RepeatCount = 0;            /* 连发计数器 */
  }

  /* 如果需要单独更改某个按键的参数，可以在此单独重新赋值 */
  
  /* 摇杆上下左右，支持长按1秒后，自动连发 */
  bsp_SetKeyParam(KID_JOY_U, 100, 6);
  bsp_SetKeyParam(KID_JOY_D, 100, 6);
  bsp_SetKeyParam(KID_JOY_L, 100, 6);
  bsp_SetKeyParam(KID_JOY_R, 100, 6);
}

// 下面只pin一些重要的
//判断按键是否按下
static uint8_t KeyPinActive(uint8_t _id)
{
  uint8_t level;
  if ((s_gpio_list[_id].gpio->IDR & s_gpio_list[_id].pin) == 0){
    level = 0;
  }else{
    level = 1;
  }
  if (level == s_gpio_list[_id].ActiveLevel){
    return 1;
  }else{
    return 0;
  }
}
// 封装KeyPinActive,支持判断多个按键同时按下的情况
static uint8_t IsKeyDownFunc(uint8_t _id)
{
  /* 实体单键 */
  if (_id < HARD_KEY_NUM)
  {
    uint8_t i;
    uint8_t count = 0;
    uint8_t save = 255; 
    /* 判断有几个键按下 */
    for (i = 0; i < HARD_KEY_NUM; i++)
    {
      if (KeyPinActive(i)) 
      {
        count++;
        save = i;
      }
    }
    if (count == 1 && save == _id)
    {
      return 1; /* 只有1个键按下时才有效 */
    }   
    return 0;
  }
  /* 组合键 K1K2 */
  if (_id == HARD_KEY_NUM + 0)
  {
    if (KeyPinActive(KID_K1) && KeyPinActive(KID_K2))
    {
      return 1;
    }
    else
    {
      return 0;
    }
  }
  return 0;
}

// 数据入队
void bsp_PutKey(uint8_t _KeyCode)
{
  s_tKey.Buf[s_tKey.Write] = _KeyCode;

  if (++s_tKey.Write  >= KEY_FIFO_SIZE)
  {
    s_tKey.Write = 0;
  }
}

// 数据出队（消费）
uint8_t bsp_GetKey(void)
{
  uint8_t ret;

  if (s_tKey.Read == s_tKey.Write)
  {
    return KEY_NONE;
  }
  else
  {
    ret = s_tKey.Buf[s_tKey.Read];

    if (++s_tKey.Read >= KEY_FIFO_SIZE)
    {
      s_tKey.Read = 0;
    }
    return ret;
  }
}

// 直接读取状态
uint8_t bsp_GetKeyState(KEY_ID_E _ucKeyID)
{
  return s_tBtn[_ucKeyID].State;
}

// 带消抖的单个检测
static void bsp_DetectKey(uint8_t i)
{
  KEY_T *pBtn;

  pBtn = &s_tBtn[i];
  if (IsKeyDownFunc(i))
  {
    if (pBtn->Count < KEY_FILTER_TIME)
    {
      pBtn->Count = KEY_FILTER_TIME;      // 让它在T-2T之间抖动
    }
    else if(pBtn->Count < 2 * KEY_FILTER_TIME)
    {
      pBtn->Count++;        // 当按下后开始计数，如果大于它说明按下
    }
    else
    {
      if (pBtn->State == 0)
      {
        pBtn->State = 1;

        /* 发送按钮按下的消息 */
        bsp_PutKey((uint8_t)(3 * i + 1));
      }

      if (pBtn->LongTime > 0)
      {
        if (pBtn->LongCount < pBtn->LongTime)
        {
          /* 发送按钮持续按下的消息 */
          if (++pBtn->LongCount == pBtn->LongTime)
          {
            /* 键值放入按键FIFO */
            bsp_PutKey((uint8_t)(3 * i + 3));
          }
        }
        else
        {
          if (pBtn->RepeatSpeed > 0)
          {
            if (++pBtn->RepeatCount >= pBtn->RepeatSpeed)
            {
              pBtn->RepeatCount = 0;
              /* 常按键后，每隔10ms发送1个按键 */
              bsp_PutKey((uint8_t)(3 * i + 1));
            }
          }
        }
      }
    }
  }
  else    // 如果停止按下
  {
    if(pBtn->Count > KEY_FILTER_TIME)
    {
      pBtn->Count = KEY_FILTER_TIME;    // 消抖，防止快速回落
    }
    else if(pBtn->Count != 0)
    {
      pBtn->Count--;        // 如果一直没有按下，则慢慢减少
    }
    else
    {
      if (pBtn->State == 1)
      {
        pBtn->State = 0;

        /* 发送按钮弹起的消息 */
        bsp_PutKey((uint8_t)(3 * i + 2));
      }
    }

    pBtn->LongCount = 0;
    pBtn->RepeatCount = 0;
  }
}

// 基于SysTick中断的扫描函数
void bsp_KeyScan10ms(void)
{
  uint8_t i;

  for (i = 0; i < KEY_COUNT; i++)
  {
    bsp_DetectKey(i);
  }
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

#define TMR_COUNT 4   /* 软件定时器的个数 （定时器ID范围 0 - 3) */

/* 定时器结构体，成员变量必须是 volatile, 否则C编译器优化时可能有问题 */
typedef enum
{
  TMR_ONCE_MODE = 0,    /* 一次工作模式 */
  TMR_AUTO_MODE = 1   /* 自动定时工作模式 */
}TMR_MODE_E;

/* 定时器结构体，成员变量必须是 volatile, 否则C编译器优化时可能有问题 */
typedef struct
{
  volatile uint8_t Mode;    /* 计数器模式，1次性 */
  volatile uint8_t Flag;    /* 定时到达标志  */
  volatile uint32_t Count;  /* 计数器 */
  volatile uint32_t PreLoad;  /* 计数器预装值 */
}SOFT_TMR;

/* 提供给其他C文件调用的函数 */
void bsp_InitTimer(void);
void bsp_DelayMS(uint32_t n);
void bsp_DelayUS(uint32_t n);
void bsp_StartTimer(uint8_t _id, uint32_t _period);
void bsp_StartAutoTimer(uint8_t _id, uint32_t _period);
void bsp_StopTimer(uint8_t _id);
uint8_t bsp_CheckTimer(uint8_t _id);
int32_t bsp_GetRunTime(void);
int32_t bsp_CheckRunTime(int32_t _LastTime);

void bsp_InitHardTimer(void);
void bsp_StartHardTimer(uint8_t _CC, uint32_t _uiTimeOut, void * _pCallBack);

void bsp_StartTimer(uint8_t _id, uint32_t _period)
{
  if (_id >= TMR_COUNT)
  {
    /* 打印出错的源代码文件名、函数名称 */
    BSP_Printf("Error: file %s, function %s()\r\n", __FILE__, __FUNCTION__);
    while(1); /* 参数异常，死机等待看门狗复位 */
  }

  DISABLE_INT();        /* 关中断 */

  s_tTmr[_id].Count = _period;    /* 实时计数器初值 */
  s_tTmr[_id].PreLoad = _period;    /* 计数器自动重装值，仅自动模式起作用 */
  s_tTmr[_id].Flag = 0;       /* 定时时间到标志 */
  s_tTmr[_id].Mode = TMR_ONCE_MODE; /* 1次性工作模式 */

  ENABLE_INT();         /* 开中断 */
}

void bsp_StartAutoTimer(uint8_t _id, uint32_t _period)
{
  if (_id >= TMR_COUNT)
  {
    /* 打印出错的源代码文件名、函数名称 */
    BSP_Printf("Error: file %s, function %s()\r\n", __FILE__, __FUNCTION__);
    while(1); /* 参数异常，死机等待看门狗复位 */
  }

  DISABLE_INT();      /* 关中断 */

  s_tTmr[_id].Count = _period;      /* 实时计数器初值 */
  s_tTmr[_id].PreLoad = _period;    /* 计数器自动重装值，仅自动模式起作用 */
  s_tTmr[_id].Flag = 0;       /* 定时时间到标志 */
  s_tTmr[_id].Mode = TMR_AUTO_MODE; /* 自动工作模式 */

  ENABLE_INT();       /* 开中断 */
}

void bsp_StopTimer(uint8_t _id)
{
  if (_id >= TMR_COUNT)
  {
    /* 打印出错的源代码文件名、函数名称 */
    BSP_Printf("Error: file %s, function %s()\r\n", __FILE__, __FUNCTION__);
    while(1); /* 参数异常，死机等待看门狗复位 */
  }

  DISABLE_INT();    /* 关中断 */

  s_tTmr[_id].Count = 0;        /* 实时计数器初值 */
  s_tTmr[_id].Flag = 0;       /* 定时时间到标志 */
  s_tTmr[_id].Mode = TMR_ONCE_MODE; /* 自动工作模式 */

  ENABLE_INT();     /* 开中断 */
}

uint8_t bsp_CheckTimer(uint8_t _id)
{
  if (_id >= TMR_COUNT)
  {
    return 0;
  }

  if (s_tTmr[_id].Flag == 1)
  {
    s_tTmr[_id].Flag = 0;
    return 1;
  }
  else
  {
    return 0;
  }
}


void SysTick_ISR(void)
{
  static uint8_t s_count = 0;
  uint8_t i;
  
  /* 每隔1ms进来1次 （仅用于 bsp_DelayMS） */
  if (s_uiDelayCount > 0)
  {
    if (--s_uiDelayCount == 0)
    {
      s_ucTimeOutFlag = 1;
    }
  }

  /* 每隔1ms，对软件定时器的计数器进行减一操作 */
  for (i = 0; i < TMR_COUNT; i++)
  {
    bsp_SoftTimerDec(&s_tTmr[i]);
  }

  /* 全局运行时间每1ms增1 */
  g_iRunTime++;
  if (g_iRunTime == 0x7FFFFFFF) /* 这个变量是 int32_t 类型，最大数为 0x7FFFFFFF */
  {
    g_iRunTime = 0;
  }

  bsp_RunPer1ms();    /* 每隔1ms调用一次此函数，此函数在 bsp.c */

  if (++s_count >= 10)
  {
    s_count = 0;

    bsp_RunPer10ms(); /* 每隔10ms调用一次此函数，此函数在 bsp.c */
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

SCB_EnableICache()
SCB_DisableICache()
SCB_InvalidateICache()

SCB_EnableDCache()
SCB_DisableDCache()
SCB_InvalidateDCache()
SCB_CleanDCache()
// Clean+ Invaildate两个函数一起用
SCB_CleanInvalidateDCache()
SCB_InvalidateDCache_by_Addr()
SCB_CleanDCache_by_Addr()
SCB_CleanInvalidateDCache_by_Addr()

1
2
3
4
5

#if 0
  __HAL_RCC_D2SRAM1_CLK_ENABLE();
  __HAL_RCC_D2SRAM2_CLK_ENABLE();
  __HAL_RCC_D2SRAM3_CLK_ENABLE();
#endif

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

LR_IROM1 0x08000000 0x00200000  {  ; load region size_region
  ER_IROM1 0x08000000 0x00200000  { ; load address = execution address
   *o (RESET, +First)
   *(InRoot$$Sections)
   .ANY (+RO)
  }
}
; RW data - 128KB DTCM
RW_IRAM1 0x20000000 0x00020000  {
  .ANY (+RW +ZI)
}
; RW data - 512KB AXI SRAM
RW_IRAM2 0x24000000 0x00080000  {
  *(RAM_D1)
}
; RW data - 128KB SRAM1(0x30000000) + 128KB SRAM2(0x3002 0000) + 32KB SRAM3(0x30040000)
RW_IRAM3 0x30000000 0x00048000  {
  *(RAM_D2)
}
; RW data - 64KB SRAM4(0x38000000)
RW_IRAM4 0x38000000 0x00010000  {
  *(RAM_D3)
}

1
2
3
4
5

// 将一个大数组放入 512KB 的 AXI SRAM (RAM_D1)
__attribute__((section("RAM_D1"))) float signal_buffer[16384];

// 将一个结构体放入 288KB 的 D2 域 SRAM (RAM_D2)
__attribute__((section("RAM_D2"))) my_peripheral_state_t device_state;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

/* DTCM, 64KB的 */
/* 用于获取当前使用的空间大小 */
mem_head_t *DTCMUsed;
/* 定义为64位变量，首地址是8字节对齐 */
uint64_t AppMallocDTCM[64*1024/8];


/* D1域, AXI SRAM, 512KB */
/* 用于获取当前使用的空间大小 */
mem_head_t *AXISRAMUsed;
/* 定义为64位变量，首地址是8字节对齐 */
uint64_t AppMallocAXISRAM[512*1024/8]__attribute__((at(0x24000000)));


osRtxMemoryInit(AppMallocDTCM,   sizeof(AppMallocDTCM));
osRtxMemoryInit(AppMallocAXISRAM, sizeof(AppMallocAXISRAM));

uint32_t *DTCM_Address0, *AXISRAM_Address0;


/* 从DTCM申请280字节空间，使用指针变量DTCM_Address0操作这些空间时不要超过280字节大小 */
DTCM_Address0 = osRtxMemoryAlloc(AppMallocDTCM, 280, 0);
DTCMUsed = MemHeadPtr(AppMallocDTCM);
printf("DTCM总大小 = %d 字节，申请大小 = 0280字节，当前共使用大小 = %d 字节\r\n", 
       DTCMUsed->size, DTCMUsed->used);

/* 从AXI SRAM申请160字节空间，使用指针变量AXISRAM_Address0操作这些空间时不要超过160字节大小 */
AXISRAM_Address0 = osRtxMemoryAlloc(AppMallocAXISRAM, 160, 0);
AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
printf("AXI SRAM总大小 = %d 字节，申请大小 = 0162字节，当前共使用大小 = %d 字节\r\n", 
       AXISRAMUsed->size, AXISRAMUsed->used);


/* 释放从DTCM申请的280字节空间 */
osRtxMemoryFree(AppMallocDTCM, DTCM_Address0);
DTCMUsed = MemHeadPtr(AppMallocDTCM);
printf("释放DTCM动态内存区申请的0280字节，当前共使用大小 = %d 字节\r\n", DTCMUsed->used);

/* 释放从AXI SRAM申请的160字节空间 */
osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Address0);
AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
printf("释放AXI SRAM动态内存区申请的0160字节，当前共使用大小 = %d 字节\r\n", AXISRAMUsed->used);

1
2
3
4
5
6
7
8

int main(){
  uint32_t *SouceAddr = (uint32_t *)FLASH_BANK1_BASE;
  uint32_t *DestAddr = (uint32_t *)D1_DTCMRAM_BASE;
  memcpy(DestAddr, SouceAddr, 0x400);
  /* 设置中断向量表到 ITCM 里面 */
  SCB->VTOR = D1_DTCMRAM_BASE;
  MAIN_RAM();
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338

typedef struct
{
  USART_TypeDef *uart;    /* STM32内部串口设备指针 */
  uint8_t *pTxBuf;      /* 发送缓冲区 */
  uint8_t *pRxBuf;      /* 接收缓冲区 */
  uint16_t usTxBufSize;   /* 发送缓冲区大小 */
  uint16_t usRxBufSize;   /* 接收缓冲区大小 */
  __IO uint16_t usTxWrite;  /* 发送缓冲区写指针 */
  __IO uint16_t usTxRead;   /* 发送缓冲区读指针 */
  __IO uint16_t usTxCount;  /* 等待发送的数据个数 */

  __IO uint16_t usRxWrite;  /* 接收缓冲区写指针 */
  __IO uint16_t usRxRead;   /* 接收缓冲区读指针 */
  __IO uint16_t usRxCount;  /* 还未读取的新数据个数 */

  void (*SendBefor)(void);  /* 开始发送之前的回调函数指针（主要用于RS485切换到发送模式） */
  void (*SendOver)(void);   /* 发送完毕的回调函数指针（主要用于RS485将发送模式切换为接收模式） */
  void (*ReciveNew)(uint8_t _byte); /* 串口收到数据的回调函数指针 */
  uint8_t Sending;      /* 正在发送中 */
}UART_T;

void bsp_InitUart(void);
void comSendBuf(COM_PORT_E _ucPort, uint8_t *_ucaBuf, uint16_t _usLen);
void comSendChar(COM_PORT_E _ucPort, uint8_t _ucByte);
uint8_t comGetChar(COM_PORT_E _ucPort, uint8_t *_pByte);
void comSendBuf(COM_PORT_E _ucPort, uint8_t *_ucaBuf, uint16_t _usLen);
void comClearTxFifo(COM_PORT_E _ucPort);
void comClearRxFifo(COM_PORT_E _ucPort);
void comSetBaud(COM_PORT_E _ucPort, uint32_t _BaudRate);

void USART_SetBaudRate(USART_TypeDef* USARTx, uint32_t BaudRate);
void bsp_SetUartParam(USART_TypeDef *Instance,  uint32_t BaudRate, uint32_t Parity, uint32_t Mode);

void RS485_SendBuf(uint8_t *_ucaBuf, uint16_t _usLen);
void RS485_SendStr(char *_pBuf);
void RS485_SetBaud(uint32_t _baud);
uint8_t UartTxEmpty(COM_PORT_E _ucPort);


void comSendBuf(COM_PORT_E _ucPort, uint8_t *_ucaBuf, uint16_t _usLen)
{
  UART_T *pUart;

  pUart = ComToUart(_ucPort);
  if (pUart == 0)
  {
    return;
  }

  if (pUart->SendBefor != 0)
  {
    pUart->SendBefor();   /* 如果是RS485通信，可以在这个函数中将RS485设置为发送模式 */
  }

  UartSend(pUart, _ucaBuf, _usLen);
}

void comSendChar(COM_PORT_E _ucPort, uint8_t _ucByte)
{
  comSendBuf(_ucPort, &_ucByte, 1);
}

uint8_t comGetChar(COM_PORT_E _ucPort, uint8_t *_pByte)
{
  UART_T *pUart;

  pUart = ComToUart(_ucPort);
  if (pUart == 0)
  {
    return 0;
  }

  return UartGetChar(pUart, _pByte);
}

void comClearTxFifo(COM_PORT_E _ucPort)
{
  UART_T *pUart;

  pUart = ComToUart(_ucPort);
  if (pUart == 0)
  {
    return;
  }

  pUart->usTxWrite = 0;
  pUart->usTxRead = 0;
  pUart->usTxCount = 0;
}

void comClearRxFifo(COM_PORT_E _ucPort)
{
  UART_T *pUart;

  pUart = ComToUart(_ucPort);
  if (pUart == 0)
  {
    return;
  }

  pUart->usRxWrite = 0;
  pUart->usRxRead = 0;
  pUart->usRxCount = 0;
}

void comSetBaud(COM_PORT_E _ucPort, uint32_t _BaudRate)
{
  USART_TypeDef* USARTx;
  
  USARTx = ComToUSARTx(_ucPort);
  if (USARTx == 0)
  {
    return;
  }
  
  bsp_SetUartParam(USARTx,  _BaudRate, UART_PARITY_NONE, UART_MODE_TX_RX);
}

/* 如果是RS485通信，请按如下格式编写函数， 我们仅举了 USART3作为RS485的例子 */
void RS485_InitTXE(void)
{
  GPIO_InitTypeDef gpio_init;
  
  /* 打开GPIO时钟 */
  RS485_TXEN_GPIO_CLK_ENABLE();
  
  /* 配置引脚为推挽输出 */
  gpio_init.Mode = GPIO_MODE_OUTPUT_PP;     /* 推挽输出 */
  gpio_init.Pull = GPIO_NOPULL;         /* 上下拉电阻不使能 */
  gpio_init.Speed = GPIO_SPEED_FREQ_VERY_HIGH;  /* GPIO速度等级 */
  gpio_init.Pin = RS485_TXEN_PIN;
  HAL_GPIO_Init(RS485_TXEN_GPIO_PORT, &gpio_init);  
}

void RS485_SetBaud(uint32_t _baud)
{
  comSetBaud(COM3, _baud);
}

void RS485_SendBefor(void)
{
  RS485_TX_EN();  /* 切换RS485收发芯片为发送模式 */
}

void RS485_SendOver(void)
{
  RS485_RX_EN();  /* 切换RS485收发芯片为接收模式 */
}

void RS485_SendBuf(uint8_t *_ucaBuf, uint16_t _usLen)
{
  comSendBuf(COM3, _ucaBuf, _usLen);
}

static void UartIRQ(UART_T *_pUart)
{
  uint32_t isrflags   = READ_REG(_pUart->uart->ISR);
  uint32_t cr1its     = READ_REG(_pUart->uart->CR1);
  uint32_t cr3its     = READ_REG(_pUart->uart->CR3);
  
  /* 处理接收中断  */
  if ((isrflags & USART_ISR_RXNE) != RESET)
  {
    /* 从串口接收数据寄存器读取数据存放到接收FIFO */
    uint8_t ch;

    ch = READ_REG(_pUart->uart->RDR);
    _pUart->pRxBuf[_pUart->usRxWrite] = ch;
    if (++_pUart->usRxWrite >= _pUart->usRxBufSize)
    {
      _pUart->usRxWrite = 0;
    }
    if (_pUart->usRxCount < _pUart->usRxBufSize)
    {
      _pUart->usRxCount++;
    }

    /* 回调函数,通知应用程序收到新数据,一般是发送1个消息或者设置一个标记 */
    //if (_pUart->usRxWrite == _pUart->usRxRead)
    //if (_pUart->usRxCount == 1)
    {
      if (_pUart->ReciveNew)
      {
        _pUart->ReciveNew(ch); /* 比如，交给MODBUS解码程序处理字节流 */
      }
    }
  }

  /* 处理发送缓冲区空中断 */
  if ( ((isrflags & USART_ISR_TXE) != RESET) && (cr1its & USART_CR1_TXEIE) != RESET)
  {
    //if (_pUart->usTxRead == _pUart->usTxWrite)
    if (_pUart->usTxCount == 0)
    {
      /* 发送缓冲区的数据已取完时， 禁止发送缓冲区空中断 （注意：此时最后1个数据还未真正发送完毕）*/
      //USART_ITConfig(_pUart->uart, USART_IT_TXE, DISABLE);
      CLEAR_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);

      /* 使能数据发送完毕中断 */
      //USART_ITConfig(_pUart->uart, USART_IT_TC, ENABLE);
      SET_BIT(_pUart->uart->CR1, USART_CR1_TCIE);
    }
    else
    {
      _pUart->Sending = 1;
      
      /* 从发送FIFO取1个字节写入串口发送数据寄存器 */
      //USART_SendData(_pUart->uart, _pUart->pTxBuf[_pUart->usTxRead]);
      _pUart->uart->TDR = _pUart->pTxBuf[_pUart->usTxRead];
      if (++_pUart->usTxRead >= _pUart->usTxBufSize)
      {
        _pUart->usTxRead = 0;
      }
      _pUart->usTxCount--;
    }

  }
  /* 数据bit位全部发送完毕的中断 */
  if (((isrflags & USART_ISR_TC) != RESET) && ((cr1its & USART_CR1_TCIE) != RESET))
  {
    //if (_pUart->usTxRead == _pUart->usTxWrite)
    if (_pUart->usTxCount == 0)
    {
      /* 如果发送FIFO的数据全部发送完毕，禁止数据发送完毕中断 */
      //USART_ITConfig(_pUart->uart, USART_IT_TC, DISABLE);
      CLEAR_BIT(_pUart->uart->CR1, USART_CR1_TCIE);

      /* 回调函数, 一般用来处理RS485通信，将RS485芯片设置为接收模式，避免抢占总线 */
      if (_pUart->SendOver)
      {
        _pUart->SendOver();
      }
      
      _pUart->Sending = 0;
    }
    else
    {
      /* 正常情况下，不会进入此分支 */

      /* 如果发送FIFO的数据还未完毕，则从发送FIFO取1个数据写入发送数据寄存器 */
      //USART_SendData(_pUart->uart, _pUart->pTxBuf[_pUart->usTxRead]);
      _pUart->uart->TDR = _pUart->pTxBuf[_pUart->usTxRead];
      if (++_pUart->usTxRead >= _pUart->usTxBufSize)
      {
        _pUart->usTxRead = 0;
      }
      _pUart->usTxCount--;
    }
  }
  
  /* 清除中断标志 */
  SET_BIT(_pUart->uart->ICR, UART_CLEAR_PEF);
  SET_BIT(_pUart->uart->ICR, UART_CLEAR_FEF);
  SET_BIT(_pUart->uart->ICR, UART_CLEAR_NEF);
  SET_BIT(_pUart->uart->ICR, UART_CLEAR_OREF);
  SET_BIT(_pUart->uart->ICR, UART_CLEAR_IDLEF);
  SET_BIT(_pUart->uart->ICR, UART_CLEAR_TCF);
  SET_BIT(_pUart->uart->ICR, UART_CLEAR_LBDF);
  SET_BIT(_pUart->uart->ICR, UART_CLEAR_CTSF);
  SET_BIT(_pUart->uart->ICR, UART_CLEAR_CMF);
  SET_BIT(_pUart->uart->ICR, UART_CLEAR_WUF);
  SET_BIT(_pUart->uart->ICR, UART_CLEAR_TXFECF);  
}


static void UartSend(UART_T *_pUart, uint8_t *_ucaBuf, uint16_t _usLen)
{
  uint16_t i;

  for (i = 0; i < _usLen; i++)
  {
    /* 如果发送缓冲区已经满了，则等待缓冲区空 */
    while (1)
    {
      __IO uint16_t usCount;

      DISABLE_INT();
      usCount = _pUart->usTxCount;
      ENABLE_INT();

      if (usCount < _pUart->usTxBufSize)
      {
        break;
      }
      else if(usCount == _pUart->usTxBufSize)/* 数据已填满缓冲区 */
      {
        if((_pUart->uart->CR1 & USART_CR1_TXEIE) == 0)
        {
          SET_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);
        }  
      }
    }

    /* 将新数据填入发送缓冲区 */
    _pUart->pTxBuf[_pUart->usTxWrite] = _ucaBuf[i];

    DISABLE_INT();
    if (++_pUart->usTxWrite >= _pUart->usTxBufSize)
    {
      _pUart->usTxWrite = 0;
    }
    _pUart->usTxCount++;
    ENABLE_INT();
  }

  SET_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);  /* 使能发送中断（缓冲区空） */
}

static uint8_t UartGetChar(UART_T *_pUart, uint8_t *_pByte)
{
  uint16_t usCount;

  /* usRxWrite 变量在中断函数中被改写，主程序读取该变量时，必须进行临界区保护 */
  DISABLE_INT();
  usCount = _pUart->usRxCount;
  ENABLE_INT();

  /* 如果读和写索引相同，则返回0 */
  //if (_pUart->usRxRead == usRxWrite)
  if (usCount == 0) /* 已经没有数据 */
  {
    return 0;
  }
  else
  {
    *_pByte = _pUart->pRxBuf[_pUart->usRxRead];   /* 从串口接收FIFO取1个数据 */

    /* 改写FIFO读索引 */
    DISABLE_INT();
    if (++_pUart->usRxRead >= _pUart->usRxBufSize)
    {
      _pUart->usRxRead = 0;
    }
    _pUart->usRxCount--;
    ENABLE_INT();
    return 1;
  }
}