[TM4]TM4C123G使用笔记

[TM4]TM4C123G使用笔记

TI的板子真让人头大😓甚至重装了两遍KEIL5

如何用keil5新建工程可以参考如下博客：

https://blog.csdn.net/D_XingGuang/article/details/89390211?spm=1001.2014.3001.5506

记得在榔头里的C/C++勾选C99 Mode和GNU extensions，不然一大堆报错

下面主要是常用外设的使用

GPIO

常用函数

void SysCtlPeripheralEnable(uint32_t ui32Peripheral)

• 功能：使能外设时钟
• 参数：uint32_t ui32Peripheral：需要使能的外设，在本文中需要使能的外设为GPIO（例如SYSCTL_PERIPH_GPIOF）
• 说明：从使能操作开始到完成需要经过五个时钟周期，在此期间不可访问外设，否则会出现总线错误。

void GPIOPinTypeGPIOOutput(uint32_t ui32Port, uint8_t ui8Pins)

• 功能：配置引脚为输出模式

• 参数：参见下面例程

void GPIODirModeSet(uint32_t ui32Port, uint8_t ui8Pins,uint32_t ui32PinIO)

• 功能：设置引脚模式

• 参数：

  #define GPIO_DIR_MODE_IN        0x00000000  // Pin is a GPIO input
  #define GPIO_DIR_MODE_OUT       0x00000001  // Pin is a GPIO output
  #define GPIO_DIR_MODE_HW        0x00000002  // Pin is a peripheral function
  

void GPIOPadConfigSet(uint32_t ui32Port, uint8_t ui8Pins,uint32_t ui32Strength, uint32_t ui32PadType)

• 功能：设置引脚PAD

• 参数：ui32Strength:输出驱动强度，正常设为2MA；ui32PadType:设置上下拉推挽开漏等

  //输出驱动强度
  GPIO_STRENGTH_2MA
  GPIO_STRENGTH_4MA
  GPIO_STRENGTH_8MA
  GPIO_STRENGTH_8MA_SC
  GPIO_STRENGTH_6MA
  GPIO_STRENGTH_10MA
  GPIO_STRENGTH_12MA
      
  //模式
  GPIO_PIN_TYPE_STD          // 推挽
  GPIO_PIN_TYPE_STD_WPU      // 弱上拉
  GPIO_PIN_TYPE_STD_WPD      // 弱下拉
  GPIO_PIN_TYPE_OD           // 开漏
  GPIO_PIN_TYPE_ANALOG       // 模拟
  GPIO_PIN_TYPE_WAKE_HIGH
  GPIO_PIN_TYPE_WAKE_LOW
  

• 注：该函数一般与上面的void GPIODirModeSet(uint32_t ui32Port, uint8_t ui8Pins,uint32_t ui32PinIO)函数连用

void GPIOPinWrite(uint32_t ui32Port, uint8_t ui8Pins, uint8_t ui8Val)

• 功能：写入高低电平

• 参数：ui8Val:低电平为0，高电平为引脚名（这个很特别，在读取电平也是一样的道理）

• 说明：例如GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1|GPIO_PIN_2, GPIO_PIN_1|GPIO_PIN_2);表示Pin1和Pin2输出高电平。若引脚被设置为输入，则向该引脚输出是无效的。

int32_t GPIOPinRead(uint32_t ui32Port, uint8_t ui8Pins)

• 功能：读取电平
• 返回值：低电平为0，高电平为引脚名

例程：

#include <stdint.h>
#include <stdbool.h>
#include "inc/hw_gpio.h"
#include "driverlib/gpio.h"
#include "driverlib/pin_map.h"
#include "inc/hw_memmap.h"
#include "driverlib/sysctl.h"

int main()
{
	// 使能外设时钟
    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
	// 设置输出引脚
    GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_1);
	GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_2);
	GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_3);
	// 设置输入引脚
	GPIODirModeSet(GPIO_PORTF_BASE, GPIO_PIN_4, GPIO_DIR_MODE_IN);	// 设置为输入
	GPIOPadConfigSet(GPIO_PORTF_BASE, GPIO_PIN_4, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU);  // 上拉输入
    while(1)
    {
		if(GPIOPinRead(GPIO_PORTF_BASE, GPIO_PIN_4) == GPIO_PIN_4)  // 读取高电平，即按键没有被按下
		{
			GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2,	0);
		}
		else  // 按键按下
		{
			GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2,	GPIO_PIN_2);
		}
    }
}

外部中断

常用函数

void GPIOIntTypeSet(uint32_t ui32Port, uint8_t ui8Pins, uint32_t ui32IntType)

• 功能：设置引脚中断的触发条件
• 参数：

GPIO_FALLING_EDGE // sets detection to edge and trigger to falling
GPIO_RISING_EDGE  // sets detection to edge and trigger to rising
GPIO_BOTH_EDGES   // sets detection to both edges
GPIO_LOW_LEVEL    // sets detection to low level
GPIO_HIGH_LEVEL   // sets detection to high level

void GPIOIntRegister(uint32_t ui32Port, void (*pfnIntHandler)(void))

• 功能：注册中断回调函数
• 参数：自定义的中断回调函数名称

void GPIOIntEnable(uint32_t ui32Port, uint32_t ui32IntFlags)

• 功能：使能GPIO端口中断
• 参数：ui32IntFlags：

GPIO_INT_PIN_x    
GPIO_INT_DMA

void IntEnable(uint32_t ui32Interrupt)

• 功能：使能中断外设
• 参数：如 INT_GPIOx 等

void IntMasterEnable(void)

• 功能：使能处理器中断

uint32_t GPIOIntStatus(uint32_t ui32Port, bool bMasked)

• 功能：读取中断状态
• 参数：bMasked：指定返回被屏蔽的中断状态(true)还是原始的中断状态(false)
• 说明：被屏蔽的中断状态：就是只返回在GPIOIntEnable函数里被使能的ui32IntFlags的中断状态，其他的被屏蔽。

void GPIOIntClear(uint32_t ui32Port, uint32_t ui32IntFlags)

• 功能：清除指定中断源标志
• 说明：发生中断后，对应的中断标志位置1，进入中断服务函数，在服务函数中务必清除中断标志，否则程序将不停地进入中断服务函数

例程

#include <stdint.h>
#include <stdbool.h>
#include "inc/hw_gpio.h"
#include "inc/hw_ints.h"
#include "driverlib/gpio.h"
#include "driverlib/pin_map.h"
#include "inc/hw_memmap.h"
#include "driverlib/sysctl.h"
#include "driverlib/interrupt.h"

void GPIOFIntHandler(void);

void GPIO_Init()
{
	SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
	// 设置LED的IO引脚
	GPIODirModeSet(GPIO_PORTF_BASE, GPIO_PIN_3 | GPIO_PIN_2 | GPIO_PIN_1, GPIO_DIR_MODE_OUT);
	GPIOPadConfigSet(GPIO_PORTF_BASE, GPIO_PIN_3 | GPIO_PIN_2 | GPIO_PIN_1, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD);
	// 初始化LED
	GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_3 | GPIO_PIN_2 | GPIO_PIN_1, 0);
}

void GPIO_Init_IT()
{
	//使能外设
	SysCtlPeripheralEnable( SYSCTL_PERIPH_GPIOF);
	//配置GPIOF_PIN_4为输入
	GPIODirModeSet(GPIO_PORTF_BASE, GPIO_PIN_4, GPIO_DIR_MODE_IN);	
    //设置GPIOF_PIN_4为推挽上拉输出，驱动强度小点就可以
	GPIOPadConfigSet(GPIO_PORTF_BASE, GPIO_PIN_4, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU);
	//设置为下降沿触发
	GPIOIntTypeSet( GPIO_PORTF_BASE,  GPIO_PIN_4, GPIO_FALLING_EDGE);
	//注册中断回调函数
	GPIOIntRegister( GPIO_PORTF_BASE,GPIOFIntHandler);
    //三个函数用来开启中断
	GPIOIntEnable( GPIO_PORTF_BASE,  GPIO_INT_PIN_4);
    IntEnable(INT_GPIOF);
	IntMasterEnable();
}

int main()
{
    // 时钟设置
	SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_XTAL_16MHZ | SYSCTL_OSC_MAIN);
	GPIO_Init();
	GPIO_Init_IT();
    while(1)
    {
			
    }
}


void GPIOFIntHandler(void)
{
	// 读取中断状态
	uint32_t GPIOF_IT_FLAG = GPIOIntStatus(GPIO_PORTF_BASE, true);
	static int keyFlag;
	// 清除标志位
	GPIOIntClear(GPIO_PORTF_BASE, GPIO_INT_PIN_4);
	// 如果是PIN4触发中断
	if((GPIOF_IT_FLAG & GPIO_PIN_4) == GPIO_PIN_4)
	{
		keyFlag++;
	}
	// 改变灯的颜色
	switch(keyFlag % 3)
	{
		case 0: 
			GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1, GPIO_PIN_1);
			GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, 0);
			GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_3, 0);
			break;
		case 1:
			GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1, 0);
			GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, GPIO_PIN_2);
			GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_3, 0);
			break;
		case 2:
			GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1, 0);
			GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, 0);
			GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_3, GPIO_PIN_3);
			break;
	}
}

Pulse Width Modulator(PWM)

与STM32相似，TM4C的PWM利用定时器实现，但TM4C的PWM模块中有自带的定时器，不需要像STM32那样使用定时器外设。

类比STM32，TM4C的分频系数相当于PSC，Period相当于ARR，Width相当于CCRx，PWM频率的计算公式为：

\[Frequency = \frac {时钟总线频率（这里是40MHz）}{分频系数*Period} \]

占空比的计算公式为：

\[Duty=\frac{Width + 1}{Period} \]

观察PWM结构框图能知道，TM4C的PWM外设包含两个PWM模块，每个模块有4个PWM Generator，每个PWM Generator控制两个PWM信号的产生。同一个PWM Generator产生的两个PWM信号的Period是相同的，但Width可以不同。

下面的表格十分重要，编程时需要一一对照查表。

TM4C中PWM的配置过程

1、使能PWM时钟 SysCtlPeripheralEnable()

2、使能被复用引脚的时钟 SysCtlPeripheralEnable()

3、使能引脚复用PWM功能 GPIOPinTypePWM()

4、将PWM信号分配到合适的引脚上 GPIOPinConfigure()

5、使能PWM时钟，设置PWM分频器为4分频（PWM时钟源为10M） SysCtlPWMClockSet();

6、配置为向下计数，参数立即更新模式 PWMGenConfigure()

7、设置周期时间（定时器计数范围） PWMGenPeriodSet()

8、设置信号0占空比25%，信号1占空比75% PWMPulseWidthSet()

9、启动PWM发生器的定时器 PWMGenEnable()

10、使能PWM输出 PWMOutputState()

常用函数

void SysCtlPWMClockSet(uint32_t ui32Config)

• 功能：设置分频系数
• 参数：

//*****************************************************************************
//
// The following are values that can be passed to the SysCtlPWMClockSet() API
// as the ui32Config parameter, and can be returned by the SysCtlPWMClockGet()
// API.
//
//*****************************************************************************
#define SYSCTL_PWMDIV_1         0x00000000  // PWM clock is processor clock /1
#define SYSCTL_PWMDIV_2         0x00100000  // PWM clock is processor clock /2
#define SYSCTL_PWMDIV_4         0x00120000  // PWM clock is processor clock /4
#define SYSCTL_PWMDIV_8         0x00140000  // PWM clock is processor clock /8
#define SYSCTL_PWMDIV_16        0x00160000  // PWM clock is processor clock /16
#define SYSCTL_PWMDIV_32        0x00180000  // PWM clock is processor clock /32
#define SYSCTL_PWMDIV_64        0x001A0000  // PWM clock is processor clock /64

void GPIOPinTypePWM(uint32_t ui32Port, uint8_t ui8Pins)

• 功能：为引脚分配PWM信号

void GPIOPinConfigure(uint32_t ui32PinConfig)

• 功能：使能GPIO引脚复用
• 参数：GPIO_Pxx_xxxx（xx引脚的xxxx功能）

void PWMGenConfigure(uint32_t ui32Base, uint32_t ui32Gen,uint32_t ui32Config)

• 功能：配置PWM Generator
• 参数：ui32Config：PWM寄存器的计数方式

void PWMGenPeriodSet(uint32_t ui32Base, uint32_t ui32Gen,uint32_t ui32Period)

• 功能：设置PWM Generator的Period

void PWMPulseWidthSet(uint32_t ui32Base, uint32_t ui32PWMOut,uint32_t ui32Width)

• 功能：设置PWM Output的Width

void PWMOutputState(uint32_t ui32Base, uint32_t ui32PWMOutBits,bool bEnable)

• 功能：使能PWM Output

void PWMGenEnable(uint32_t ui32Base, uint32_t ui32Gen)

• 功能：使能PWM Generator

例程

#include <stdint.h>
#include <stdbool.h>
#include "inc/hw_gpio.h"
#include "inc/hw_ints.h"
#include "driverlib/gpio.h"
#include "driverlib/pwm.h"
#include "driverlib/pin_map.h"
#include "inc/hw_memmap.h"
#include "driverlib/sysctl.h"
#include "driverlib/interrupt.h"

#define Delay_ms(n); SysCtlDelay(n*(SysCtlClockGet()/3000));

void PWM_Init()
{
	// 因为设置了时钟总线是40MHz，所以在这里分一下频设置为4分频，那么PWM时钟就是10MHz
	SysCtlPWMClockSet(SYSCTL_PWMDIV_4);
	// 使能时钟
	SysCtlPeripheralEnable(SYSCTL_PERIPH_PWM1);			//使能PWM模块1时钟																		
	SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);		//使能GPIOF时钟
	// 分配pwm信号
	GPIOPinTypePWM(GPIO_PORTF_BASE,GPIO_PIN_2);
	GPIOPinTypePWM(GPIO_PORTF_BASE,GPIO_PIN_3);
	// 使能引脚复用
	GPIOPinConfigure(GPIO_PF2_M1PWM6);		//PF2->PWM模块1信号6																							
	GPIOPinConfigure(GPIO_PF3_M1PWM7);		//PF3->PWM模块1信号7	
	// 配置PWM发生器
	// 模块1->发生器3->上下计数，不同步
	PWMGenConfigure(PWM1_BASE,PWM_GEN_3,PWM_GEN_MODE_UP_DOWN|PWM_GEN_MODE_NO_SYNC);
	//配置PWM周期，此时PWM输出频率为10M/2k = 50000Hz。计数器为16位，故第三个参数不能超过65535
	PWMGenPeriodSet(PWM1_BASE,PWM_GEN_3,2000);
	//配置PWM占空比为1%
	PWMPulseWidthSet(PWM1_BASE,PWM_OUT_6,PWMGenPeriodGet(PWM1_BASE, PWM_GEN_3)*0.01 - 1);
	PWMPulseWidthSet(PWM1_BASE,PWM_OUT_7,PWMGenPeriodGet(PWM1_BASE, PWM_GEN_3)*0.01 - 1);
	//使能PWM模块1输出
	PWMOutputState(PWM1_BASE,PWM_OUT_6_BIT,true);
	PWMOutputState(PWM1_BASE,PWM_OUT_7_BIT,true);
	//使能PWM发生器
	PWMGenEnable(PWM1_BASE,PWM_GEN_3);
}

void PWM_Set_Duty(uint32_t ui32Base,uint32_t ui32PWMOut,float duty)
{
	uint32_t ui32Gen;
	uint32_t ui32OutBits;

	switch(ui32PWMOut)
	{
		case PWM_OUT_0:	ui32Gen=PWM_GEN_0,ui32OutBits=PWM_OUT_0_BIT;	break;
		case PWM_OUT_1:	ui32Gen=PWM_GEN_0,ui32OutBits=PWM_OUT_1_BIT;	break;
		case PWM_OUT_2:	ui32Gen=PWM_GEN_1,ui32OutBits=PWM_OUT_2_BIT;	break;
		case PWM_OUT_3:	ui32Gen=PWM_GEN_1,ui32OutBits=PWM_OUT_3_BIT;	break;
		case PWM_OUT_4:	ui32Gen=PWM_GEN_2,ui32OutBits=PWM_OUT_4_BIT;	break;
		case PWM_OUT_5:	ui32Gen=PWM_GEN_2,ui32OutBits=PWM_OUT_5_BIT;	break;
		case PWM_OUT_6:	ui32Gen=PWM_GEN_3,ui32OutBits=PWM_OUT_6_BIT;	break;
		case PWM_OUT_7:	ui32Gen=PWM_GEN_3,ui32OutBits=PWM_OUT_7_BIT;	break;
	}
	//配置占空比
  PWMPulseWidthSet(ui32Base, ui32PWMOut, PWMGenPeriodGet(ui32Base, ui32Gen)*duty - 1);
  PWMOutputState(ui32Base, ui32OutBits, true);
  //使能发生器模块
  PWMGenEnable(ui32Base, ui32Gen);
}


int main()
{
	float duty1=0.1,duty2=0.9;
	float d=0.01;		// 步长
	// 设置时钟总线频率为40MHz
	SysCtlClockSet( SYSCTL_SYSDIV_5|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|SYSCTL_OSC_MAIN);
	PWM_Init();
    while(1)
    {
		PWM_Set_Duty(PWM1_BASE,PWM_OUT_6,duty1);
		PWM_Set_Duty(PWM1_BASE,PWM_OUT_7,duty2);
		Delay_ms(10);
        
		duty1+=d;
		duty2-=d;	
		if(duty1>=0.95 && duty2<=0.05)	d=-0.01;
		else if(duty2>=0.95 && duty1<=0.05)	d=0.01;
    }
}

Universal Asynchronous Receivers/Transmitters (UARTs)

和STM32F4的大差不差，但是比F4多一个硬件FIFO。

先对FIFO做一个简要的说明吧，全称为First In First Out，就是先进先出。想象一个水管，用手堵住一个口，然后往另一个口装水，装满了就把手拿掉，先进入的水就会先出来，其中水管的作用就相当于FIFO。所以FIFO实际上起到了一个缓存区的作用。FIFO的大小也有规定，比如一个16x8的FIFO，表示其容量为16个8位数据，就是说他最多可以装16个字节，超过16个字节就满了，同时还要触发中断。

TM4C的FIFO深度可以编程控制，支持1/8，1/4，1/2，3/4，7/8的深度，比如说我给FIFO设置为1/2深度，则FIFO中数据字节数超过16x1/2=8时就会产生一个中断。

通过下面TM4C的UART模块结构图，我们可以发现FIFO最大深度为16个字节，TX、RX各有一个FIFO

参考下图DataSheet的说明，TM4C的FIFO在上电后应该不会自动启动，需要代码里手动配置。如果不配置FIFO的话其相当于一个字节深度，跟STM32的DR寄存器差不多，装一个字节产生一个中断。

具体的UART操作逻辑和STM32差不太多，就不细说了。

常用函数

void GPIOPinTypeUART(uint32_t ui32Port, uint8_t ui8Pins)

• 功能：给引脚分配UART信号

void UARTClockSourceSet(uint32_t ui32Base, uint32_t ui32Source)

• 功能：为UART设置波特率时钟源
• 参数：ui32Base为串口基地址，ui32Source为串口的波特时钟源一般为UART_CLOCK_PIOSC是16MHz

void UARTStdioConfig(uint32_t ui32PortNum, uint32_t ui32Baud, uint32_t ui32SrcClock)

• 功能：配置串口参数
• 参数：PortNum：0~7，代表UARTx；Baud：波特率，比如115200；SrcClock：如果你上面波特率时钟源设置的是UART_CLOCK_PIOSC，那么SrcClock就是16000000

void UARTprintf(const char *pcString, ...)

• 功能：printf

void UARTConfigSetExpClk(uint32_t ui32Base, uint32_t ui32UARTClk,uint32_t ui32Baud, uint32_t ui32Config)

• 功能：配置串口参数
• 参数：ui32UARTClk为提供给UART的时钟频率，通过SysCtlClockGet()函数可以得到，通过ui32Config来配置串口的字长，校验位，停止位

void UARTCharPut(uint32_t ui32Base, unsigned char ucData)

• 功能：输出
• 说明：等待FIFO中有数据再发送，即阻塞式输出

int32_t UARTCharGet(uint32_t ui32Base)

• 说明：同上，阻塞式读取

bool UARTCharPutNonBlocking(uint32_t ui32Base, unsigned char ucData)

• 返回值：若TX的FIFO已满，直接返回false而不在那循环等待
• 说明：非阻塞式输出

int32_t UARTCharGetNonBlocking(uint32_t ui32Base)

• 说明：同上，非阻塞式读取，若RX的FIFO为空，直接返回False

void UARTFIFOEnable(uint32_t ui32Base)

• 功能：使能FIFO

void UARTFIFOLevelSet(uint32_t ui32Base, uint32_t ui32TxLevel,uint32_t ui32RxLevel)

• 功能：设置FIFO深度

void UARTIntEnable(uint32_t ui32Base, uint32_t ui32IntFlags)

• 功能：使能串口中断
• 参数：ui32IntFlags：UART_INT_RX/TX

void UARTIntRegister(uint32_t ui32Base, void (*pfnHandler)(void))

• 功能：注册串口中断回调函数

void IntPrioritySet(uint32_t ui32Interrupt, uint8_t ui8Priority)

• 功能：设置中断优先级
• 参数：ui32Interrupt为中断外设，如INT_UARTx，ui8Priority为中断优先级从0x0到0xE0，0x0优先级最高

uint32_t UARTIntStatus(uint32_t ui32Base, bool bMasked)

• 功能：读取UART中断状态
• 参考GPIOIntStatus

void UARTIntClear(uint32_t ui32Base, uint32_t ui32IntFlags)

• 功能：清除上个函数读取到的标志位

bool UARTCharsAvail(uint32_t ui32Base)

• 功能：判断FIFO是否有数据存在
• 返回值：有为true，无为false

void UARTEnable(uint32_t ui32Base)

• 功能：使能串口

例程

注：

• 该例程需要导入utils文件夹中的uartstdio.c，并设置包含utils文件夹。
• 需要将uartstdio.c中126行的static uint32_t g_ui32Base改成自己的串口

#include <stdint.h>
#include <stdbool.h>
#include <string.h>
#include "inc/tm4c123gh6pm.h"				//Register Definitions
#include "inc/hw_memmap.h"
#include "inc/hw_types.h"
#include "driverlib/sysctl.h"
#include "driverlib/interrupt.h"
#include "driverlib/gpio.h"
#include "driverlib/uart.h"
#include "uartstdio.h"
#include "driverlib/systick.h"
#include "driverlib/pin_map.h"

#define delay_ms(n); SysCtlDelay(n*(SysCtlClockGet()/3000));


char rxBuffer[256];

void UARTIntHandler(void) 
{
	uint32_t ui32Status;
	ui32Status = UARTIntStatus(UART1_BASE, true); //get interrupt status
	static int32_t cnt;
	UARTIntClear(UART1_BASE, ui32Status); 				//clear the asserted interrupts
	while(UARTCharsAvail(UART1_BASE)) 						//loop while there are chars
	{
		rxBuffer[cnt++] = UARTCharGetNonBlocking(UART1_BASE);
		GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, GPIO_PIN_2); //blink LED
		delay_ms(0.1);
		GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, 0); //turn off LED
	}
	cnt = 0;
	UARTprintf("%s\r\n", rxBuffer);
	memset(rxBuffer, 0x00, sizeof(rxBuffer));
}


void UART1_Init()
{
	//使能外设
	SysCtlPeripheralEnable(SYSCTL_PERIPH_UART1);
	//配置复用功能
	GPIOPinConfigure(GPIO_PB0_U1RX);
	GPIOPinConfigure(GPIO_PB1_U1TX);
	//分配UART信号
	GPIOPinTypeUART(GPIO_PORTB_BASE,GPIO_PIN_0|GPIO_PIN_1);
	//串口参数设置
	UARTClockSourceSet(UART1_BASE, UART_CLOCK_PIOSC);	//使用16MHz内部高精度振荡器(PIOSC)作为UART模块时钟
	UARTStdioConfig(1,115200, 16000000);				//UART编号、波特率、UART时钟频率（频率要和上一行设的一致）
	//FIFO配置，
	UARTFIFOLevelSet(UART1_BASE,UART_FIFO_TX4_8,UART_FIFO_RX2_8);	//FIFO填入4Byte时触发中断
	UARTFIFOEnable(UART1_BASE);
	//中断使能
	IntMasterEnable(); 			//enable processor interrupts
	IntEnable(INT_UART1); 		//enable the UART interrupt
	UARTIntEnable(UART1_BASE, UART_INT_RX);
	//注册中断服务函数
	UARTIntRegister(UART1_BASE,UARTIntHandler);
    
    UARTEnable(UART1_BASE);
}


int main(void) 
{	
	SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_16MHZ);
	
	SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
	//LED配置
	SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); 		//enable GPIO port for LED
	GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_2); //enable pin for LED PF2 	
	
	UART1_Init();
	UARTprintf("Enter Text: \n");
	
	while (1) //let interrupt handler do the UART echo function
	{	
		;
	} 
}

后面再准备详细研究一下TM4C的UART

General-Purpose Timers

TM4C有两种定时器，一种是16/32bit，另一种是32/64bit，两种定时器各有六个；对于一个16/32bit定时器来说，其可以拆分成两个16位定时器A和B工作，也可以组装成一个32位定时器工作。

常用函数

void SysCtlPeripheralEnable(uint32_t ui32Peripheral)

• 功能：使能外设
• 参数：ui32Peripheral如果为16/32bit的定时器就是TIMER，如果是32/64bit的定时器就是WTIMER。

void TimerConfigure(uint32_t ui32Base, uint32_t ui32Config)

• 功能：设置定时器模式

• 说明：

• 如果在定时器不拆分的情况下，可以将ui32Config设置为以下模式之一：

      TIMER_CFG_ONE_SHOT – 单次减计数模式
      TIMER_CFG_ONE_SHOT_UP – 单次加计数模式
      TIMER_CFG_PERIODIC – 连续减计数模式
      TIMER_CFG_PERIODIC_UP – 连续加计数模式
      TIMER_CFG_RTC – 实时时钟模式
  

  如果将定时器拆分的话则将ui32Config设置为TIMER_CFG_SPLIT_PAIR（分裂为一对）然后与以下模式进行或运算：

      TIMER_CFG_A_ONE_SHOT – 定时器A单次减计数
      TIMER_CFG_A_ONE_SHOT_UP –定时器A单次加计数
      TIMER_CFG_A_PERIODIC – 定时器A连续减计数
      TIMER_CFG_A_PERIODIC_UP – 定时器A连续加计数
  
      TIMER_CFG_B_ONE_SHOT – 定时器B单次减计数
      TIMER_CFG_B_ONE_SHOT_UP –定时器B单次加计数
      TIMER_CFG_B_PERIODIC – 定时器B连续减计数
      TIMER_CFG_B_PERIODIC_UP – 定时器B连续加计数
  

void TimerLoadSet(uint32_t ui32Base, uint32_t ui32Timer, uint32_t ui32Value)

• 功能：配置定时器频率

• 参数：ui32Base为定时器基地址，ui32Timer有TIMER_A，TIMER_B和TIMER_BOTH（单独A，单独B，AB都用）三种选择，在定时器拆分的情况下用哪个就设置哪个，在不拆分的情况下就设置为TIMER_A（对于其他函数也是，如果在级联的情况下还需要选择，那默认为选择TIMER_A），ui32Value为定时器加载值，一般来说定时器频率为N，那么定时器加载值=SysCtlClockGet()/N-1，即根据自己的定时器频率即可得定时器加载值。

  此函数适用于16bit，32bit的定时器，即适用于16/32bit的定时器拆分与级联，32/64bit定时器的拆分三种情况，对于64bit的定时器，即32/64bit定时器的级联使用TimerLoadSet64。

void TimerIntRegister(uint32_t ui32Base, uint32_t ui32Timer,void (*pfnHandler)(void))

• 功能：为定时器中断注册中断回调函数

void TimerIntEnable(uint32_t ui32Base, uint32_t ui32IntFlags)

• 功能：使能定时器中断
• 参数：ui32Base为定时器基地址，ui32IntFlags为中断模式，在定时器状态下一般设置为TIMER_TIMB_TIMEOUT或TIMER_TIMA_TIMEOUT

void TimerEnable(uint32_t ui32Base, uint32_t ui32Timer)

• 功能：使能定时器
• 参数：ui32Base为定时器基地址，ui32Timer也是有TIMER_A，TIMER_B和TIMER_BOTH三种

例程

#include <stdint.h>
#include <stdbool.h>
#include <string.h>
#include "inc/tm4c123gh6pm.h"
#include "inc/hw_memmap.h"
#include "inc/hw_types.h"
#include "driverlib/sysctl.h"
#include "driverlib/interrupt.h"
#include "driverlib/gpio.h"
#include "driverlib/uart.h"
#include "driverlib/timer.h"
#include "uartstdio.h"
#include "driverlib/systick.h"
#include "driverlib/pin_map.h"


#define delay_ms(n); SysCtlDelay(n*(SysCtlClockGet()/3000));

void TIM_IRQHandler(void);
void wTIM_IRQHandler(void);

void TIM_Init()
{
	uint32_t freq = 1000;
	// 使能定时器TIMER0，16/32bit
  SysCtlPeripheralEnable( SYSCTL_PERIPH_TIMER0);
  // 配置定时器，将定时器拆分，并配置拆分后的定时器A为周期性计数
	TimerConfigure(TIMER0_BASE, TIMER_CFG_SPLIT_PAIR | TIMER_CFG_A_PERIODIC_UP);
  // 设置定时器A装载值，因为要1ms进一次中断，所以1ms=1/1000，所以重装载值为SysCtlClockGet()/1000-1
	TimerLoadSet(TIMER0_BASE, TIMER_A,SysCtlClockGet()/freq - 1);
  // 为定时器A注册中断函数
	TimerIntRegister(TIMER0_BASE, TIMER_A, TIM_IRQHandler);
  // 使能Timer0的定时器A为超时中断
	TimerIntEnable(TIMER0_BASE, TIMER_TIMA_TIMEOUT);
  // 设置中断优先级
	IntPrioritySet(INT_TIMER0A, 0);
  // 使能中断
	IntEnable(INT_TIMER0A);
	IntMasterEnable();
  // 使能定时器
	TimerEnable( TIMER0_BASE,  TIMER_A);
}
// 32/64bit定时器级联
void wTIM_Init()
{
	uint64_t freq = 1000;
	SysCtlPeripheralEnable(SYSCTL_PERIPH_WTIMER0);
  // 设置不拆分并且周期计数
	TimerConfigure(WTIMER0_BASE, TIMER_CFG_PERIODIC_UP);
	TimerLoadSet64(WTIMER0_BASE, SysCtlClockGet() / freq - 1);
	// 级联的情况下默认都是设置定时器A
	TimerIntEnable(WTIMER0_BASE, TIMER_TIMA_TIMEOUT);
	TimerIntRegister(WTIMER0_BASE, TIMER_A, wTIM_IRQHandler);
	IntPrioritySet(INT_WTIMER0A, 1);
	// 中断使能
	IntEnable(INT_WTIMER0A);
	IntMasterEnable();
	
	TimerEnable(WTIMER0_BASE, TIMER_A);
}
void GPIO_Init()
{
	SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
	GPIODirModeSet(GPIO_PORTF_BASE, GPIO_PIN_2, GPIO_DIR_MODE_OUT);
	GPIOPadConfigSet(GPIO_PORTF_BASE, GPIO_PIN_2, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD);
//	GPIODirModeSet(GPIO_PORTF_BASE, GPIO_PIN_3, GPIO_DIR_MODE_OUT);
//	GPIOPadConfigSet(GPIO_PORTF_BASE, GPIO_PIN_3, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD);
}


int main(void) 
{	
	SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_16MHZ);
	GPIO_Init();
//	TIM_Init();
	wTIM_Init();
	while (1)  // Let interrupt handler do the UART echo function
	{	
		;
	} 
}


void TIM_IRQHandler()
{
	static uint32_t time_count;
	static int flag;
	// 读取定时器中断状态
  uint32_t status = TimerIntStatus(TIMER0_BASE, true);
  // 清除中断标志位
	TimerIntClear(TIMER0_BASE, status);
	// 1ms进一次中断
	time_count++;
  // 1s进入一次
	if(time_count==1000)
	{
	  time_count=0;
		flag++;
		if(flag % 2 == 1)
		{
			GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, GPIO_PIN_2);
		}
		else
		{
			GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, 0);
		}
	}
}

void wTIM_IRQHandler()
{
	static uint32_t time_count;
	static int flag;
  uint32_t status = TimerIntStatus( WTIMER0_BASE,  true);
	
	TimerIntClear(WTIMER0_BASE, status);
	time_count++;
	if(time_count == 1000)
	{
	  time_count = 0;
		flag++;
		if(flag % 2 == 1)
		{
			GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, GPIO_PIN_2);
		}
		else
		{
			GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, 0);
		}
	}
}

Quadrature Encoder Interface (QEI)

简单的说，就是TM4自带的编码器外设，能读取电机编码器并且测速以及读取位置（好用捏😋）

以下是DataSheet里的解释：（懒得翻译了，凑合着看吧）

可以发现，QEI有四个中断来源（有几个看不太懂什么意思，就不细说了）

芝士结构框图：

API函数就自己翻手册吧，没啥好说的

例子

QEI初始化函数：

void QEI_Init(void)
{
    const uint32_t MaxPos = 4000;
    
	// 使能外设
	SysCtlPeripheralEnable(SYSCTL_PERIPH_QEI0);
	while(!SysCtlPeripheralReady(SYSCTL_PERIPH_QEI0)){}
	SysCtlPeripheralEnable(SYSCTL_PERIPH_QEI1);
	while(!SysCtlPeripheralReady(SYSCTL_PERIPH_QEI1));
	
	SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC);
	SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
	SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
		
	// Unlock PD7
	HWREG(GPIO_PORTD_BASE + GPIO_O_LOCK) = GPIO_LOCK_KEY;
	HWREG(GPIO_PORTD_BASE + GPIO_O_CR)  |= 0x80;
	HWREG(GPIO_PORTD_BASE + GPIO_O_LOCK) = 0x00;
		
	// QEI1: PC5, PC6
	GPIOPinConfigure(GPIO_PC5_PHA1);
	GPIOPinTypeQEI(GPIO_PORTC_BASE , GPIO_PIN_5);
	GPIOPinConfigure(GPIO_PC6_PHB1);
	GPIOPinTypeQEI(GPIO_PORTC_BASE , GPIO_PIN_6);
	QEIConfigure(QEI1_BASE, (QEI_CONFIG_CAPTURE_A_B | QEI_CONFIG_RESET_IDX |QEI_CONFIG_QUADRATURE | QEI_CONFIG_NO_SWAP), MaxPos - 1);
	QEIVelocityConfigure(QEI1_BASE, QEI_VELDIV_1, SysCtlClockGet()/100);
	QEIVelocityEnable(QEI1_BASE);
	QEIEnable(QEI1_BASE);
	// QEI2: PD6, PD7
	GPIOPinConfigure(GPIO_PD6_PHA0);
	GPIOPinTypeQEI(GPIO_PORTD_BASE , GPIO_PIN_6);
	GPIOPinConfigure(GPIO_PD7_PHB0);
	GPIOPinTypeQEI(GPIO_PORTD_BASE , GPIO_PIN_7);
	QEIConfigure(QEI0_BASE, (QEI_CONFIG_CAPTURE_A_B | QEI_CONFIG_RESET_IDX |QEI_CONFIG_QUADRATURE | QEI_CONFIG_NO_SWAP), MaxPos - 1);
	QEIVelocityConfigure(QEI0_BASE, QEI_VELDIV_1, SysCtlClockGet()/100);
	QEIVelocityEnable(QEI0_BASE);
	QEIEnable(QEI0_BASE);
}

读取速度：

polarR = -1 * QEIDirectionGet(QEI1_BASE);
velocityR = polarR * QEIVelocityGet(QEI1_BASE);
polarL = 1 * QEIDirectionGet(QEI0_BASE);
velocityL = polarL * QEIVelocityGet(QEI0_BASE);
UARTprintf("R:%d, L:%d\n", velocityR, velocityL);

读取位置：

posL = QEIPositionGet(QEI0_BASE);
UARTprintf("PosL:%d\n", posL);