[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频率的计算公式为：
\]
占空比的计算公式为：
\]
观察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);
[TM4]TM4C123G使用笔记的更多相关文章
- git-简单流程（学习笔记）
这是阅读廖雪峰的官方网站的笔记,用于自己以后回看 1.进入项目文件夹 初始化一个Git仓库,使用git init命令. 添加文件到Git仓库,分两步: 第一步,使用命令git add <file ...
- js学习笔记：webpack基础入门（一）
之前听说过webpack,今天想正式的接触一下,先跟着webpack的官方用户指南走: 在这里有: 如何安装webpack 如何使用webpack 如何使用loader 如何使用webpack的开发者 ...
- SQL Server技术内幕笔记合集
SQL Server技术内幕笔记合集 发这一篇文章主要是方便大家找到我的笔记入口,方便大家o(∩_∩)o Microsoft SQL Server 6.5 技术内幕 笔记http://www.cnbl ...
- PHP-自定义模板-学习笔记
1. 开始 这几天,看了李炎恢老师的<PHP第二季度视频>中的“章节7:创建TPL自定义模板”,做一个学习笔记,通过绘制架构图.UML类图和思维导图,来对加深理解. 2. 整体架构图 ...
- PHP-会员登录与注册例子解析-学习笔记
1.开始 最近开始学习李炎恢老师的<PHP第二季度视频>中的“章节5:使用OOP注册会员”,做一个学习笔记,通过绘制基本页面流程和UML类图,来对加深理解. 2.基本页面流程 3.通过UM ...
- NET Core-学习笔记（三）
这里将要和大家分享的是学习总结第三篇:首先感慨一下这周跟随netcore官网学习是遇到的一些问题: a.官网的英文版教程使用的部分nuget包和我当时安装的最新包版本不一致,所以没法按照教材上给出的列 ...
- springMVC学习笔记--知识点总结1
以下是学习springmvc框架时的笔记整理: 结果跳转方式 1.设置ModelAndView,根据view的名称,和视图渲染器跳转到指定的页面. 比如jsp的视图渲染器是如下配置的: <!-- ...
- 读书笔记汇总 - SQL必知必会（第4版）
本系列记录并分享学习SQL的过程,主要内容为SQL的基础概念及练习过程. 书目信息 中文名:<SQL必知必会(第4版)> 英文名:<Sams Teach Yourself SQL i ...
- 2014年暑假c#学习笔记目录
2014年暑假c#学习笔记 一.C#编程基础 1. c#编程基础之枚举 2. c#编程基础之函数可变参数 3. c#编程基础之字符串基础 4. c#编程基础之字符串函数 5.c#编程基础之ref.ou ...
- JAVA GUI编程学习笔记目录
2014年暑假JAVA GUI编程学习笔记目录 1.JAVA之GUI编程概述 2.JAVA之GUI编程布局 3.JAVA之GUI编程Frame窗口 4.JAVA之GUI编程事件监听机制 5.JAVA之 ...
随机推荐
- Linux 中通过虚拟地址获取物理地址并锁定
在 Linux 开发过程中,申请内存后,某些时候需要用物理地址传给其他外设进行写入或者读取操作,同时考虑到防止被操作系统 sawp,导致实际的物理地址发生变化,从而在操作对应的虚拟地址时无法正常运行等 ...
- C# 二十年语法变迁之 C# 2,C# 3 ,C# 4参考
C# 二十年语法变迁之 C# 2,C# 3 ,C# 4参考 https://benbowen.blog/post/two_decades_of_csharp_i/ 自从 C# 于 2000 年推出以来 ...
- NC20325 [SDOI2009]HH的项链
题目链接 题目 题目描述 HH有一串由各种漂亮的贝壳组成的项链. HH相信不同的贝壳会带来好运,所以每次散步完后,他都会随意取出一 段贝壳,思考它们所表达的含义. HH不断地收集新的贝壳,因此他的项链 ...
- Centos中报错apt Command not Found
先说结论: 在centos下用yum install xxxyum和apt-get的区别: 一般来说著名的linux系统基本上分两大类: RedHat系列:Redhat.Centos.Fedora等 ...
- centos7使用repo方式安装zabbix4.0
1.安装zabbix的repo源 rpm -ivh https://mirrors.tuna.tsinghua.edu.cn/zabbix/zabbix/4.0/rhel/7/x86_64/zabbi ...
- std::shared_ptr 和 std::vector 的结合使用
#include <iostream> #include <string> #include <vector> std::shared_ptr<std::ve ...
- .Net 6 WebAPI 使用JWT进行 授权认证配置
.Net 6 WebAPI 使用JWT进行 授权认证 1.安装组件(Nuget) Microsoft.AspNetCore.Authentication.JwtBearer 2.Program.cs ...
- https://editor.csdn.net/md/?articleId=131348876
前言 前面搭建了基础环境,在使用统信UOS系统的相关行业也是不能上网的,但是可以传递压缩包,为了很好的方便相关从业人员工作,特将此种方式流程分享出来.(与国产银河麒麟不同) 本篇文章的重点就是离 ...
- django中model聚合使用
from django.db.models.functions import Cast, Coalesce, Concat, ConcatPair, Greatest # Cast,类型转换 q1 = ...
- requests请求超时尝试重连的3种方式
参考文档 https://urllib3.readthedocs.io/en/latest/reference/urllib3.util.html#module-urllib3.util.retry ...